diff options
Diffstat (limited to 'boost/fusion/algorithm/iteration')
16 files changed, 656 insertions, 1764 deletions
diff --git a/boost/fusion/algorithm/iteration/accumulate.hpp b/boost/fusion/algorithm/iteration/accumulate.hpp index fe7112e323..7d524a15c2 100644 --- a/boost/fusion/algorithm/iteration/accumulate.hpp +++ b/boost/fusion/algorithm/iteration/accumulate.hpp @@ -1,5 +1,6 @@ /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2015 Kohei Takahashi 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) @@ -10,8 +11,6 @@ #include <boost/fusion/support/config.hpp> #include <boost/fusion/algorithm/iteration/accumulate_fwd.hpp> #include <boost/fusion/algorithm/iteration/fold.hpp> -#include <boost/fusion/support/is_sequence.hpp> -#include <boost/utility/enable_if.hpp> namespace boost { namespace fusion { @@ -27,11 +26,7 @@ namespace boost { namespace fusion template <typename Sequence, typename State, typename F> BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - inline typename - lazy_enable_if< - traits::is_sequence<Sequence> - , result_of::accumulate<Sequence, State const, F> - >::type + inline typename result_of::accumulate<Sequence, State const, F>::type accumulate(Sequence& seq, State const& state, F f) { return fusion::fold(seq, state, f); @@ -39,11 +34,7 @@ namespace boost { namespace fusion template <typename Sequence, typename State, typename F> BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - inline typename - lazy_enable_if< - traits::is_sequence<Sequence> - , result_of::accumulate<Sequence const, State const, F> - >::type + inline typename result_of::accumulate<Sequence const, State const, F>::type accumulate(Sequence const& seq, State const& state, F f) { return fusion::fold(seq, state, f); diff --git a/boost/fusion/algorithm/iteration/accumulate_fwd.hpp b/boost/fusion/algorithm/iteration/accumulate_fwd.hpp index 50c4d39d4e..f00e67f966 100644 --- a/boost/fusion/algorithm/iteration/accumulate_fwd.hpp +++ b/boost/fusion/algorithm/iteration/accumulate_fwd.hpp @@ -1,5 +1,6 @@ /*============================================================================= Copyright (c) 2011 Eric Niebler + Copyright (c) 2015 Kohei Takahashi 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) @@ -8,8 +9,6 @@ #define BOOST_FUSION_ACCUMULATE_FWD_HPP_INCLUDED #include <boost/fusion/support/config.hpp> -#include <boost/fusion/support/is_sequence.hpp> -#include <boost/utility/enable_if.hpp> namespace boost { namespace fusion { @@ -21,20 +20,12 @@ namespace boost { namespace fusion template <typename Sequence, typename State, typename F> BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - inline typename - lazy_enable_if< - traits::is_sequence<Sequence> - , result_of::accumulate<Sequence, State const, F> - >::type + inline typename result_of::accumulate<Sequence, State const, F>::type accumulate(Sequence& seq, State const& state, F f); template <typename Sequence, typename State, typename F> BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - inline typename - lazy_enable_if< - traits::is_sequence<Sequence> - , result_of::accumulate<Sequence const, State const, F> - >::type + inline typename result_of::accumulate<Sequence const, State const, F>::type accumulate(Sequence const& seq, State const& state, F f); }} diff --git a/boost/fusion/algorithm/iteration/detail/fold.hpp b/boost/fusion/algorithm/iteration/detail/fold.hpp index 1813bd247a..4c82b80029 100644 --- a/boost/fusion/algorithm/iteration/detail/fold.hpp +++ b/boost/fusion/algorithm/iteration/detail/fold.hpp @@ -2,12 +2,15 @@ Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2006 Dan Marsden Copyright (c) 2009-2010 Christopher Schmidt + Copyright (c) 2015 Kohei Takahashi 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> +#define FUSION_HASH # + #ifdef BOOST_FUSION_REVERSE_FOLD # ifdef BOOST_FUSION_ITER_FOLD # define BOOST_FUSION_FOLD_NAME reverse_iter_fold @@ -41,378 +44,193 @@ # define BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(IT) fusion::deref(IT) #endif +#if (defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)) +FUSION_HASH if BOOST_WORKAROUND BOOST_PREVENT_MACRO_SUBSTITUTION (BOOST_MSVC, < 1500) +FUSION_HASH define BOOST_FUSION_FOLD_IMPL_ENABLER(T) void +FUSION_HASH else +FUSION_HASH define BOOST_FUSION_FOLD_IMPL_ENABLER(T) typename T::type +FUSION_HASH endif +#else +# if BOOST_WORKAROUND(BOOST_MSVC, < 1500) +# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) void +# else +# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) typename T::type +# endif +#endif + namespace boost { namespace fusion { namespace detail { - template<typename State, typename It, typename F> - struct BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state) - : fusion::detail::result_of_with_decltype< - F( - typename add_reference<typename add_const<State>::type>::type, - BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM(It)) - > + template<int SeqSize, typename It, typename State, typename F, typename = void +#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES) +FUSION_HASH if BOOST_WORKAROUND BOOST_PREVENT_MACRO_SUBSTITUTION (BOOST_MSVC, < 1500) +#endif +#if BOOST_WORKAROUND(BOOST_MSVC, < 1500) || \ + (defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)) + // Dirty hack: those compilers cannot choose exactly one partial specialization. + , bool = SeqSize == 0 +#endif +#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES) +FUSION_HASH endif +#endif + > + struct BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME) {}; - template<typename Result,int N> - struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME) - { - template<typename State3, typename It3, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_3(State3 const& state3,It3 const& it3,F& f) - { - 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 State2, typename It2, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_2(State2 const& state2,It2 const& it2,F& f) - { - return call_3( - f(state2,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it2)), - fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it2), - f); - } - - template<typename State1, typename It1, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_1(State1 const& state1,It1 const& it1,F& f) - { - return call_2( - f(state1,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it1)), - fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it1), - f); - } - - template<typename State, typename It0, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call(State const& state,It0 const& it0,F f) - { - return call_1( - f(state,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it0)), - fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it0), - f); - } - }; - - template<typename Result> - struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<Result,3> - { - template<typename State2, typename It2, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_2(State2 const& state2,It2 const& it2,F& f) - { - return f(state2,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it2)); - } - - template<typename State1, typename It1, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_1(State1 const& state1,It1 const& it1,F& f) - { - return call_2( - f(state1,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it1)), - fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it1), - f); - } - - template<typename State, typename It0, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call(State const& state,It0 const& it0,F f) - { - return call_1( - f(state,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it0)), - fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it0), - f); - } - }; - - template<typename Result> - struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<Result,2> - { - template<typename State1, typename It1, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_1(State1 const& state1,It1 const& it1,F& f) - { - return f(state1,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it1)); - } - - template<typename State, typename It0, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call(State const& state,It0 const& it0,F f) - { - return call_1( - f(state,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it0)), - fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it0), - f); - } - }; - - template<typename Result> - struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<Result,1> - { - template<typename State, typename It0, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - 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> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call(State const& state,It0 const&, 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 - > + template<typename It, typename State, typename F> + struct BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME)<0,It,State,F + , typename boost::enable_if_has_type<BOOST_FUSION_FOLD_IMPL_ENABLER(State)>::type +#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES) +FUSION_HASH if BOOST_WORKAROUND BOOST_PREVENT_MACRO_SUBSTITUTION (BOOST_MSVC, < 1500) +#endif +#if BOOST_WORKAROUND(BOOST_MSVC, < 1500) || \ + (defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)) + , true +#endif +#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES) +FUSION_HASH endif +#endif + > { - 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; + typedef typename State::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 + template<int SeqSize, typename It, typename State, typename F> + struct BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME)<SeqSize,It,State,F + , typename boost::enable_if_has_type< +#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES) +FUSION_HASH if BOOST_WORKAROUND BOOST_PREVENT_MACRO_SUBSTITUTION (BOOST_MSVC, >= 1500) +#endif +#if BOOST_WORKAROUND(BOOST_MSVC, >= 1500) || \ + (defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)) + // Following SFINAE enables to avoid MSVC 9's partial specialization + // ambiguous bug but MSVC 8 don't compile, and moreover MSVC 8 style + // workaround won't work with MSVC 9. + typename boost::disable_if_c<SeqSize == 0, State>::type::type +#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES) +FUSION_HASH else + BOOST_FUSION_FOLD_IMPL_ENABLER(State) +#endif +#else + BOOST_FUSION_FOLD_IMPL_ENABLER(State) +#endif +#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES) +FUSION_HASH endif +#endif + >::type +#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES) +FUSION_HASH if BOOST_WORKAROUND BOOST_PREVENT_MACRO_SUBSTITUTION (BOOST_MSVC, < 1500) +#endif +#if BOOST_WORKAROUND(BOOST_MSVC, < 1500) || \ + (defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)) + , false +#endif +#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES) +FUSION_HASH endif +#endif + > + : BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME)< + SeqSize-1 + , typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<It>::type + , boost::result_of< + F( + typename add_reference<typename State::type>::type, + BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM(It const) + ) + > , F > {}; - template<typename StateRef, typename It0, typename F> - struct BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)< - StateRef - , It0 + template<typename It, typename State, typename F> + BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED + inline typename BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME)< + 0 + , It + , State , F - , 1 - > - : BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)< - StateRef - , It0 const + >::type + BOOST_PP_CAT(it_,BOOST_FUSION_FOLD_NAME)(mpl::int_<0>, It const&, typename State::type state, F&) + { + return state; + } + + template<typename It, typename State, typename F, int SeqSize> + BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED + inline typename lazy_enable_if_c< + SeqSize != 0 + , BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME)< + SeqSize + , It + , State , 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 fusion::detail::result_of_with_decltype< - 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) + >::type + BOOST_PP_CAT(it_,BOOST_FUSION_FOLD_NAME)(mpl::int_<SeqSize>, It const& it, typename State::type state, F& f) { - 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 + return BOOST_PP_CAT(it_,BOOST_FUSION_FOLD_NAME)< + typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<It>::type + , boost::result_of< + F( + typename add_reference<typename State::type>::type, + BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM(It const) ) - , F - , SeqSize - >::type - type; - - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - 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; - - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static StateRef - call(StateRef state, Seq&, F) - { - return static_cast<StateRef>(state); - } - }; + > + , F + >( + mpl::int_<SeqSize-1>() + , fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it) + , f(state, BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it)) + , f + ); + } + + template<typename Seq, typename State, typename F + , bool = traits::is_sequence<Seq>::value + , bool = traits::is_segmented<Seq>::value> + struct BOOST_PP_CAT(result_of_,BOOST_FUSION_FOLD_NAME) + {}; - 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)< + template<typename Seq, typename State, typename F> + struct BOOST_PP_CAT(result_of_,BOOST_FUSION_FOLD_NAME)<Seq, State, F, true, false> + : BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME)< result_of::size<Seq>::value - , typename add_reference< - typename add_const<State>::type - >::type - , Seq + , BOOST_FUSION_FOLD_IMPL_FIRST_IT_META_TRANSFORM( + typename result_of::BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION<Seq>::type + ) + , add_reference<State> , F > {}; + + template<typename Seq, typename State, typename F> + BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED + inline typename BOOST_PP_CAT(result_of_,BOOST_FUSION_FOLD_NAME)<Seq, State, F>::type + BOOST_FUSION_FOLD_NAME(Seq& seq, State& state, F& f) + { + return BOOST_PP_CAT(it_,BOOST_FUSION_FOLD_NAME)< + BOOST_FUSION_FOLD_IMPL_FIRST_IT_META_TRANSFORM( + typename result_of::BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION<Seq>::type + ) + , add_reference<State> + , F + >( + typename result_of::size<Seq>::type() + , BOOST_FUSION_FOLD_IMPL_FIRST_IT_TRANSFORM( + fusion::BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION(seq) + ) + , state + , 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 - > + : detail::BOOST_PP_CAT(result_of_,BOOST_FUSION_FOLD_NAME)<Seq, State, F> {}; } @@ -425,10 +243,7 @@ namespace boost { namespace fusion >::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); + return detail::BOOST_FUSION_FOLD_NAME<Seq, State const, F>(seq, state, f); } template<typename Seq, typename State, typename F> @@ -440,47 +255,40 @@ namespace boost { namespace fusion >::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); + return detail::BOOST_FUSION_FOLD_NAME<Seq const, State const, F>(seq, state, f); } template<typename Seq, typename State, typename F> BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED inline typename result_of::BOOST_FUSION_FOLD_NAME< Seq - , State const + , State , 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); + return detail::BOOST_FUSION_FOLD_NAME<Seq, State, F>(seq, state, f); } template<typename Seq, typename State, typename F> BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED inline typename result_of::BOOST_FUSION_FOLD_NAME< Seq const - , State const + , State , 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); + return detail::BOOST_FUSION_FOLD_NAME<Seq const, State, F>(seq, state, f); } }} #undef BOOST_FUSION_FOLD_NAME +#undef BOOST_FUSION_FOLD_IMPL_ENABLER #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 +#undef FUSION_HASH diff --git a/boost/fusion/algorithm/iteration/detail/preprocessed/fold.hpp b/boost/fusion/algorithm/iteration/detail/preprocessed/fold.hpp index bd3b1dbdac..c23ba16c28 100644 --- a/boost/fusion/algorithm/iteration/detail/preprocessed/fold.hpp +++ b/boost/fusion/algorithm/iteration/detail/preprocessed/fold.hpp @@ -8,345 +8,138 @@ This is an auto-generated file. Do not edit! ==============================================================================*/ +# if BOOST_WORKAROUND (BOOST_MSVC, < 1500) +# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) void +# else +# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) typename T::type +# endif namespace boost { namespace fusion { namespace detail { - template<typename State, typename It, typename F> - struct fold_lvalue_state - : fusion::detail::result_of_with_decltype< - F( - typename add_reference<typename add_const<State>::type>::type, - typename fusion::result_of::deref<It>::type) - > - {}; - template<typename Result,int N> - struct unrolled_fold - { - template<typename State3, typename It3, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_3(State3 const& state3,It3 const& it3,F& f) - { - return unrolled_fold< - Result - , N-4 - >::call( - f(state3,fusion::deref(it3)), - fusion::next(it3), - f); - } - template<typename State2, typename It2, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_2(State2 const& state2,It2 const& it2,F& f) - { - return call_3( - f(state2,fusion::deref(it2)), - fusion::next(it2), - f); - } - template<typename State1, typename It1, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_1(State1 const& state1,It1 const& it1,F& f) - { - return call_2( - f(state1,fusion::deref(it1)), - fusion::next(it1), - f); - } - template<typename State, typename It0, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call(State const& state,It0 const& it0,F f) - { - return call_1( - f(state,fusion::deref(it0)), - fusion::next(it0), - f); - } - }; - template<typename Result> - struct unrolled_fold<Result,3> - { - template<typename State2, typename It2, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_2(State2 const& state2,It2 const& it2,F& f) - { - return f(state2,fusion::deref(it2)); - } - template<typename State1, typename It1, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_1(State1 const& state1,It1 const& it1,F& f) - { - return call_2( - f(state1,fusion::deref(it1)), - fusion::next(it1), - f); - } - template<typename State, typename It0, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call(State const& state,It0 const& it0,F f) - { - return call_1( - f(state,fusion::deref(it0)), - fusion::next(it0), - f); - } - }; - template<typename Result> - struct unrolled_fold<Result,2> - { - template<typename State1, typename It1, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_1(State1 const& state1,It1 const& it1,F& f) - { - return f(state1,fusion::deref(it1)); - } - template<typename State, typename It0, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call(State const& state,It0 const& it0,F f) - { - return call_1( - f(state,fusion::deref(it0)), - fusion::next(it0), - f); - } - }; - template<typename Result> - struct unrolled_fold<Result,1> - { - template<typename State, typename It0, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call(State const& state,It0 const& it0,F f) - { - return f(state, - fusion::deref(it0)); - } - }; - template<typename Result> - struct unrolled_fold<Result,0> - { - template<typename State, typename It0, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call(State const& state,It0 const&, F) - { - return static_cast<Result>(state); - } - }; - template<typename StateRef, typename It0, typename F, int N> - struct result_of_unrolled_fold - { - typedef typename - fold_lvalue_state< - StateRef - , It0 const - , F - >::type - rest1; - typedef typename - result_of::next< - It0 const - >::type - it1; - typedef typename - fold_lvalue_state< - rest1 - , it1 - , F - >::type - rest2; - typedef typename - result_of::next<it1>::type - it2; - typedef typename - fold_lvalue_state< - rest2 - , it2 - , F - >::type - rest3; - typedef typename - result_of::next<it2>::type - it3; - typedef typename - result_of_unrolled_fold< - typename fold_lvalue_state< - rest3 - , it3 - , F - >::type - , typename result_of::next< - it3 - >::type - , F - , N-4 - >::type - type; - }; - template<typename StateRef, typename It0, typename F> - struct result_of_unrolled_fold< - StateRef - , It0 - , F - , 3 + template<int SeqSize, typename It, typename State, typename F, typename = void +# if BOOST_WORKAROUND (BOOST_MSVC, < 1500) + + , bool = SeqSize == 0 +# endif > + struct result_of_it_fold + {}; + template<typename It, typename State, typename F> + struct result_of_it_fold<0,It,State,F + , typename boost::enable_if_has_type<BOOST_FUSION_FOLD_IMPL_ENABLER(State)>::type +# if BOOST_WORKAROUND (BOOST_MSVC, < 1500) + , true +# endif + > { - typedef typename - fold_lvalue_state< - StateRef - , It0 const - , F - >::type - rest1; - typedef typename - result_of::next< - It0 const - >::type - it1; - typedef typename - fold_lvalue_state< - typename fold_lvalue_state< - rest1 - , it1 - , F - >::type - , typename result_of::next< - it1 const - >::type const - , F - >::type - type; + typedef typename State::type type; }; - template<typename StateRef, typename It0, typename F> - struct result_of_unrolled_fold< - StateRef - , It0 - , F - , 2 - > - : fold_lvalue_state< - typename fold_lvalue_state< - StateRef - , It0 const - , F - >::type - , typename result_of::next< - It0 const - >::type const + template<int SeqSize, typename It, typename State, typename F> + struct result_of_it_fold<SeqSize,It,State,F + , typename boost::enable_if_has_type< +# if BOOST_WORKAROUND (BOOST_MSVC, >= 1500) + + + + typename boost::disable_if_c<SeqSize == 0, State>::type::type +# else + BOOST_FUSION_FOLD_IMPL_ENABLER(State) +# endif + >::type +# if BOOST_WORKAROUND (BOOST_MSVC, < 1500) + , false +# endif + > + : result_of_it_fold< + SeqSize-1 + , typename result_of::next<It>::type + , boost::result_of< + F( + typename add_reference<typename State::type>::type, + typename fusion::result_of::deref<It const>::type + ) + > , F > {}; - template<typename StateRef, typename It0, typename F> - struct result_of_unrolled_fold< - StateRef - , It0 + template<typename It, typename State, typename F> + BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED + inline typename result_of_it_fold< + 0 + , It + , State , F - , 1 - > - : fold_lvalue_state< - StateRef - , It0 const + >::type + it_fold(mpl::int_<0>, It const&, typename State::type state, F&) + { + return state; + } + template<typename It, typename State, typename F, int SeqSize> + BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED + inline typename lazy_enable_if_c< + SeqSize != 0 + , result_of_it_fold< + SeqSize + , It + , State , F > - {}; - template<typename StateRef, typename It0, typename F> - struct result_of_unrolled_fold< - StateRef - , It0 - , F - , 0 - > + >::type + it_fold(mpl::int_<SeqSize>, It const& it, typename State::type state, F& f) { - typedef StateRef type; - }; - template<typename StateRef, typename It0, typename F, int SeqSize> - struct result_of_first_unrolledfold - { - typedef typename - result_of_unrolled_fold< - typename fusion::detail::result_of_with_decltype< - F( - StateRef, - typename fusion::result_of::deref< It0 const>::type - ) - >::type - , typename result_of::next< - It0 const - >::type - , F - , SeqSize-1 - >::type - type; - }; - template<int SeqSize, typename StateRef, typename Seq, typename F> - struct fold_impl - { - typedef typename - result_of_first_unrolledfold< - StateRef - , typename result_of::begin<Seq>::type - , F - , SeqSize - >::type - type; - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static type - call(StateRef state, Seq& seq, F f) - { - typedef - unrolled_fold< - type - , SeqSize - > - unrolled_impl; - return unrolled_impl::call( - state, - fusion::begin(seq), - f); - } - }; - template<typename StateRef, typename Seq, typename F> - struct fold_impl<0,StateRef,Seq,F> - { - typedef StateRef type; - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static StateRef - call(StateRef state, Seq&, F) - { - return static_cast<StateRef>(state); - } - }; - template<typename Seq, typename State, typename F, bool IsSegmented> + return it_fold< + typename result_of::next<It>::type + , boost::result_of< + F( + typename add_reference<typename State::type>::type, + typename fusion::result_of::deref<It const>::type + ) + > + , F + >( + mpl::int_<SeqSize-1>() + , fusion::next(it) + , f(state, fusion::deref(it)) + , f + ); + } + template<typename Seq, typename State, typename F + , bool = traits::is_sequence<Seq>::value + , bool = traits::is_segmented<Seq>::value> struct result_of_fold - : fold_impl< + {}; + template<typename Seq, typename State, typename F> + struct result_of_fold<Seq, State, F, true, false> + : result_of_it_fold< result_of::size<Seq>::value - , typename add_reference< - typename add_const<State>::type - >::type - , Seq + , typename result_of::begin<Seq>::type + , add_reference<State> , F > {}; + template<typename Seq, typename State, typename F> + BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED + inline typename result_of_fold<Seq, State, F>::type + fold(Seq& seq, State& state, F& f) + { + return it_fold< + typename result_of::begin<Seq>::type + , add_reference<State> + , F + >( + typename result_of::size<Seq>::type() + , fusion::begin(seq) + , state + , f + ); + } } namespace result_of { template<typename Seq, typename State, typename F> struct fold - : detail::result_of_fold< - Seq - , State - , F - , traits::is_segmented<Seq>::type::value - > + : detail::result_of_fold<Seq, State, F> {}; } template<typename Seq, typename State, typename F> @@ -358,10 +151,7 @@ namespace boost { namespace fusion >::type fold(Seq& seq, State const& state, F f) { - return result_of::fold<Seq,State const,F>::call( - state, - seq, - f); + return detail::fold<Seq, State const, F>(seq, state, f); } template<typename Seq, typename State, typename F> BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED @@ -372,37 +162,28 @@ namespace boost { namespace fusion >::type fold(Seq const& seq, State const& state, F f) { - return result_of::fold<Seq const,State const,F>::call( - state, - seq, - f); + return detail::fold<Seq const, State const, F>(seq, state, f); } template<typename Seq, typename State, typename F> BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED inline typename result_of::fold< Seq - , State const + , State , F >::type fold(Seq& seq, State& state, F f) { - return result_of::fold<Seq,State,F>::call( - state, - seq, - f); + return detail::fold<Seq, State, F>(seq, state, f); } template<typename Seq, typename State, typename F> BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED inline typename result_of::fold< Seq const - , State const + , State , F >::type fold(Seq const& seq, State& state, F f) { - return result_of::fold<Seq const,State,F>::call( - state, - seq, - f); + return detail::fold<Seq const, State, F>(seq, state, f); } }} diff --git a/boost/fusion/algorithm/iteration/detail/preprocessed/iter_fold.hpp b/boost/fusion/algorithm/iteration/detail/preprocessed/iter_fold.hpp index 1d294a8722..d49a868568 100644 --- a/boost/fusion/algorithm/iteration/detail/preprocessed/iter_fold.hpp +++ b/boost/fusion/algorithm/iteration/detail/preprocessed/iter_fold.hpp @@ -7,345 +7,138 @@ This is an auto-generated file. Do not edit! ==============================================================================*/ +# if BOOST_WORKAROUND (BOOST_MSVC, < 1500) +# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) void +# else +# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) typename T::type +# endif namespace boost { namespace fusion { namespace detail { - template<typename State, typename It, typename F> - struct iter_fold_lvalue_state - : fusion::detail::result_of_with_decltype< - F( - typename add_reference<typename add_const<State>::type>::type, - It&) - > - {}; - template<typename Result,int N> - struct unrolled_iter_fold - { - template<typename State3, typename It3, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_3(State3 const& state3,It3 const& it3,F& f) - { - return unrolled_iter_fold< - Result - , N-4 - >::call( - f(state3,it3), - fusion::next(it3), - f); - } - template<typename State2, typename It2, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_2(State2 const& state2,It2 const& it2,F& f) - { - return call_3( - f(state2,it2), - fusion::next(it2), - f); - } - template<typename State1, typename It1, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_1(State1 const& state1,It1 const& it1,F& f) - { - return call_2( - f(state1,it1), - fusion::next(it1), - f); - } - template<typename State, typename It0, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call(State const& state,It0 const& it0,F f) - { - return call_1( - f(state,it0), - fusion::next(it0), - f); - } - }; - template<typename Result> - struct unrolled_iter_fold<Result,3> - { - template<typename State2, typename It2, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_2(State2 const& state2,It2 const& it2,F& f) - { - return f(state2,it2); - } - template<typename State1, typename It1, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_1(State1 const& state1,It1 const& it1,F& f) - { - return call_2( - f(state1,it1), - fusion::next(it1), - f); - } - template<typename State, typename It0, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call(State const& state,It0 const& it0,F f) - { - return call_1( - f(state,it0), - fusion::next(it0), - f); - } - }; - template<typename Result> - struct unrolled_iter_fold<Result,2> - { - template<typename State1, typename It1, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_1(State1 const& state1,It1 const& it1,F& f) - { - return f(state1,it1); - } - template<typename State, typename It0, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call(State const& state,It0 const& it0,F f) - { - return call_1( - f(state,it0), - fusion::next(it0), - f); - } - }; - template<typename Result> - struct unrolled_iter_fold<Result,1> - { - template<typename State, typename It0, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call(State const& state,It0 const& it0,F f) - { - return f(state, - it0); - } - }; - template<typename Result> - struct unrolled_iter_fold<Result,0> - { - template<typename State, typename It0, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call(State const& state,It0 const&, F) - { - return static_cast<Result>(state); - } - }; - template<typename StateRef, typename It0, typename F, int N> - struct result_of_unrolled_iter_fold - { - typedef typename - iter_fold_lvalue_state< - StateRef - , It0 const - , F - >::type - rest1; - typedef typename - result_of::next< - It0 const - >::type - it1; - typedef typename - iter_fold_lvalue_state< - rest1 - , it1 - , F - >::type - rest2; - typedef typename - result_of::next<it1>::type - it2; - typedef typename - iter_fold_lvalue_state< - rest2 - , it2 - , F - >::type - rest3; - typedef typename - result_of::next<it2>::type - it3; - typedef typename - result_of_unrolled_iter_fold< - typename iter_fold_lvalue_state< - rest3 - , it3 - , F - >::type - , typename result_of::next< - it3 - >::type - , F - , N-4 - >::type - type; - }; - template<typename StateRef, typename It0, typename F> - struct result_of_unrolled_iter_fold< - StateRef - , It0 - , F - , 3 + template<int SeqSize, typename It, typename State, typename F, typename = void +# if BOOST_WORKAROUND (BOOST_MSVC, < 1500) + + , bool = SeqSize == 0 +# endif > + struct result_of_it_iter_fold + {}; + template<typename It, typename State, typename F> + struct result_of_it_iter_fold<0,It,State,F + , typename boost::enable_if_has_type<BOOST_FUSION_FOLD_IMPL_ENABLER(State)>::type +# if BOOST_WORKAROUND (BOOST_MSVC, < 1500) + , true +# endif + > { - typedef typename - iter_fold_lvalue_state< - StateRef - , It0 const - , F - >::type - rest1; - typedef typename - result_of::next< - It0 const - >::type - it1; - typedef typename - iter_fold_lvalue_state< - typename iter_fold_lvalue_state< - rest1 - , it1 - , F - >::type - , typename result_of::next< - it1 const - >::type const - , F - >::type - type; + typedef typename State::type type; }; - template<typename StateRef, typename It0, typename F> - struct result_of_unrolled_iter_fold< - StateRef - , It0 - , F - , 2 - > - : iter_fold_lvalue_state< - typename iter_fold_lvalue_state< - StateRef - , It0 const - , F - >::type - , typename result_of::next< - It0 const - >::type const + template<int SeqSize, typename It, typename State, typename F> + struct result_of_it_iter_fold<SeqSize,It,State,F + , typename boost::enable_if_has_type< +# if BOOST_WORKAROUND (BOOST_MSVC, >= 1500) + + + + typename boost::disable_if_c<SeqSize == 0, State>::type::type +# else + BOOST_FUSION_FOLD_IMPL_ENABLER(State) +# endif + >::type +# if BOOST_WORKAROUND (BOOST_MSVC, < 1500) + , false +# endif + > + : result_of_it_iter_fold< + SeqSize-1 + , typename result_of::next<It>::type + , boost::result_of< + F( + typename add_reference<typename State::type>::type, + It const& + ) + > , F > {}; - template<typename StateRef, typename It0, typename F> - struct result_of_unrolled_iter_fold< - StateRef - , It0 + template<typename It, typename State, typename F> + BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED + inline typename result_of_it_iter_fold< + 0 + , It + , State , F - , 1 - > - : iter_fold_lvalue_state< - StateRef - , It0 const + >::type + it_iter_fold(mpl::int_<0>, It const&, typename State::type state, F&) + { + return state; + } + template<typename It, typename State, typename F, int SeqSize> + BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED + inline typename lazy_enable_if_c< + SeqSize != 0 + , result_of_it_iter_fold< + SeqSize + , It + , State , F > - {}; - template<typename StateRef, typename It0, typename F> - struct result_of_unrolled_iter_fold< - StateRef - , It0 - , F - , 0 - > + >::type + it_iter_fold(mpl::int_<SeqSize>, It const& it, typename State::type state, F& f) { - typedef StateRef type; - }; - template<typename StateRef, typename It0, typename F, int SeqSize> - struct result_of_first_unrollediter_fold - { - typedef typename - result_of_unrolled_iter_fold< - typename fusion::detail::result_of_with_decltype< - F( - StateRef, - It0 const& - ) - >::type - , typename result_of::next< - It0 const - >::type - , F - , SeqSize-1 - >::type - type; - }; - template<int SeqSize, typename StateRef, typename Seq, typename F> - struct iter_fold_impl - { - typedef typename - result_of_first_unrollediter_fold< - StateRef - , typename result_of::begin<Seq>::type - , F - , SeqSize - >::type - type; - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static type - call(StateRef state, Seq& seq, F f) - { - typedef - unrolled_iter_fold< - type - , SeqSize - > - unrolled_impl; - return unrolled_impl::call( - state, - fusion::begin(seq), - f); - } - }; - template<typename StateRef, typename Seq, typename F> - struct iter_fold_impl<0,StateRef,Seq,F> - { - typedef StateRef type; - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static StateRef - call(StateRef state, Seq&, F) - { - return static_cast<StateRef>(state); - } - }; - template<typename Seq, typename State, typename F, bool IsSegmented> + return it_iter_fold< + typename result_of::next<It>::type + , boost::result_of< + F( + typename add_reference<typename State::type>::type, + It const& + ) + > + , F + >( + mpl::int_<SeqSize-1>() + , fusion::next(it) + , f(state, it) + , f + ); + } + template<typename Seq, typename State, typename F + , bool = traits::is_sequence<Seq>::value + , bool = traits::is_segmented<Seq>::value> struct result_of_iter_fold - : iter_fold_impl< + {}; + template<typename Seq, typename State, typename F> + struct result_of_iter_fold<Seq, State, F, true, false> + : result_of_it_iter_fold< result_of::size<Seq>::value - , typename add_reference< - typename add_const<State>::type - >::type - , Seq + , typename result_of::begin<Seq>::type + , add_reference<State> , F > {}; + template<typename Seq, typename State, typename F> + BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED + inline typename result_of_iter_fold<Seq, State, F>::type + iter_fold(Seq& seq, State& state, F& f) + { + return it_iter_fold< + typename result_of::begin<Seq>::type + , add_reference<State> + , F + >( + typename result_of::size<Seq>::type() + , fusion::begin(seq) + , state + , f + ); + } } namespace result_of { template<typename Seq, typename State, typename F> struct iter_fold - : detail::result_of_iter_fold< - Seq - , State - , F - , traits::is_segmented<Seq>::type::value - > + : detail::result_of_iter_fold<Seq, State, F> {}; } template<typename Seq, typename State, typename F> @@ -357,10 +150,7 @@ namespace boost { namespace fusion >::type iter_fold(Seq& seq, State const& state, F f) { - return result_of::iter_fold<Seq,State const,F>::call( - state, - seq, - f); + return detail::iter_fold<Seq, State const, F>(seq, state, f); } template<typename Seq, typename State, typename F> BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED @@ -371,37 +161,28 @@ namespace boost { namespace fusion >::type iter_fold(Seq const& seq, State const& state, F f) { - return result_of::iter_fold<Seq const,State const,F>::call( - state, - seq, - f); + return detail::iter_fold<Seq const, State const, F>(seq, state, f); } template<typename Seq, typename State, typename F> BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED inline typename result_of::iter_fold< Seq - , State const + , State , F >::type iter_fold(Seq& seq, State& state, F f) { - return result_of::iter_fold<Seq,State,F>::call( - state, - seq, - f); + return detail::iter_fold<Seq, State, F>(seq, state, f); } template<typename Seq, typename State, typename F> BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED inline typename result_of::iter_fold< Seq const - , State const + , State , F >::type iter_fold(Seq const& seq, State& state, F f) { - return result_of::iter_fold<Seq const,State,F>::call( - state, - seq, - f); + return detail::iter_fold<Seq const, State, F>(seq, state, f); } }} diff --git a/boost/fusion/algorithm/iteration/detail/preprocessed/reverse_fold.hpp b/boost/fusion/algorithm/iteration/detail/preprocessed/reverse_fold.hpp index 947897821a..4b3b3b1e09 100644 --- a/boost/fusion/algorithm/iteration/detail/preprocessed/reverse_fold.hpp +++ b/boost/fusion/algorithm/iteration/detail/preprocessed/reverse_fold.hpp @@ -7,345 +7,138 @@ This is an auto-generated file. Do not edit! ==============================================================================*/ +# if BOOST_WORKAROUND (BOOST_MSVC, < 1500) +# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) void +# else +# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) typename T::type +# endif namespace boost { namespace fusion { namespace detail { - template<typename State, typename It, typename F> - struct reverse_fold_lvalue_state - : fusion::detail::result_of_with_decltype< - F( - typename add_reference<typename add_const<State>::type>::type, - typename fusion::result_of::deref<It>::type) - > - {}; - template<typename Result,int N> - struct unrolled_reverse_fold - { - template<typename State3, typename It3, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_3(State3 const& state3,It3 const& it3,F& f) - { - return unrolled_reverse_fold< - Result - , N-4 - >::call( - f(state3,fusion::deref(it3)), - fusion::prior(it3), - f); - } - template<typename State2, typename It2, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_2(State2 const& state2,It2 const& it2,F& f) - { - return call_3( - f(state2,fusion::deref(it2)), - fusion::prior(it2), - f); - } - template<typename State1, typename It1, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_1(State1 const& state1,It1 const& it1,F& f) - { - return call_2( - f(state1,fusion::deref(it1)), - fusion::prior(it1), - f); - } - template<typename State, typename It0, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call(State const& state,It0 const& it0,F f) - { - return call_1( - f(state,fusion::deref(it0)), - fusion::prior(it0), - f); - } - }; - template<typename Result> - struct unrolled_reverse_fold<Result,3> - { - template<typename State2, typename It2, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_2(State2 const& state2,It2 const& it2,F& f) - { - return f(state2,fusion::deref(it2)); - } - template<typename State1, typename It1, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_1(State1 const& state1,It1 const& it1,F& f) - { - return call_2( - f(state1,fusion::deref(it1)), - fusion::prior(it1), - f); - } - template<typename State, typename It0, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call(State const& state,It0 const& it0,F f) - { - return call_1( - f(state,fusion::deref(it0)), - fusion::prior(it0), - f); - } - }; - template<typename Result> - struct unrolled_reverse_fold<Result,2> - { - template<typename State1, typename It1, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_1(State1 const& state1,It1 const& it1,F& f) - { - return f(state1,fusion::deref(it1)); - } - template<typename State, typename It0, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call(State const& state,It0 const& it0,F f) - { - return call_1( - f(state,fusion::deref(it0)), - fusion::prior(it0), - f); - } - }; - template<typename Result> - struct unrolled_reverse_fold<Result,1> - { - template<typename State, typename It0, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call(State const& state,It0 const& it0,F f) - { - return f(state, - fusion::deref(it0)); - } - }; - template<typename Result> - struct unrolled_reverse_fold<Result,0> - { - template<typename State, typename It0, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call(State const& state,It0 const&, F) - { - return static_cast<Result>(state); - } - }; - template<typename StateRef, typename It0, typename F, int N> - struct result_of_unrolled_reverse_fold - { - typedef typename - reverse_fold_lvalue_state< - StateRef - , It0 const - , F - >::type - rest1; - typedef typename - result_of::prior< - It0 const - >::type - it1; - typedef typename - reverse_fold_lvalue_state< - rest1 - , it1 - , F - >::type - rest2; - typedef typename - result_of::prior<it1>::type - it2; - typedef typename - reverse_fold_lvalue_state< - rest2 - , it2 - , F - >::type - rest3; - typedef typename - result_of::prior<it2>::type - it3; - typedef typename - result_of_unrolled_reverse_fold< - typename reverse_fold_lvalue_state< - rest3 - , it3 - , F - >::type - , typename result_of::prior< - it3 - >::type - , F - , N-4 - >::type - type; - }; - template<typename StateRef, typename It0, typename F> - struct result_of_unrolled_reverse_fold< - StateRef - , It0 - , F - , 3 + template<int SeqSize, typename It, typename State, typename F, typename = void +# if BOOST_WORKAROUND (BOOST_MSVC, < 1500) + + , bool = SeqSize == 0 +# endif > + struct result_of_it_reverse_fold + {}; + template<typename It, typename State, typename F> + struct result_of_it_reverse_fold<0,It,State,F + , typename boost::enable_if_has_type<BOOST_FUSION_FOLD_IMPL_ENABLER(State)>::type +# if BOOST_WORKAROUND (BOOST_MSVC, < 1500) + , true +# endif + > { - typedef typename - reverse_fold_lvalue_state< - StateRef - , It0 const - , F - >::type - rest1; - typedef typename - result_of::prior< - It0 const - >::type - it1; - typedef typename - reverse_fold_lvalue_state< - typename reverse_fold_lvalue_state< - rest1 - , it1 - , F - >::type - , typename result_of::prior< - it1 const - >::type const - , F - >::type - type; + typedef typename State::type type; }; - template<typename StateRef, typename It0, typename F> - struct result_of_unrolled_reverse_fold< - StateRef - , It0 - , F - , 2 - > - : reverse_fold_lvalue_state< - typename reverse_fold_lvalue_state< - StateRef - , It0 const - , F - >::type - , typename result_of::prior< - It0 const - >::type const + template<int SeqSize, typename It, typename State, typename F> + struct result_of_it_reverse_fold<SeqSize,It,State,F + , typename boost::enable_if_has_type< +# if BOOST_WORKAROUND (BOOST_MSVC, >= 1500) + + + + typename boost::disable_if_c<SeqSize == 0, State>::type::type +# else + BOOST_FUSION_FOLD_IMPL_ENABLER(State) +# endif + >::type +# if BOOST_WORKAROUND (BOOST_MSVC, < 1500) + , false +# endif + > + : result_of_it_reverse_fold< + SeqSize-1 + , typename result_of::prior<It>::type + , boost::result_of< + F( + typename add_reference<typename State::type>::type, + typename fusion::result_of::deref<It const>::type + ) + > , F > {}; - template<typename StateRef, typename It0, typename F> - struct result_of_unrolled_reverse_fold< - StateRef - , It0 + template<typename It, typename State, typename F> + BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED + inline typename result_of_it_reverse_fold< + 0 + , It + , State , F - , 1 - > - : reverse_fold_lvalue_state< - StateRef - , It0 const + >::type + it_reverse_fold(mpl::int_<0>, It const&, typename State::type state, F&) + { + return state; + } + template<typename It, typename State, typename F, int SeqSize> + BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED + inline typename lazy_enable_if_c< + SeqSize != 0 + , result_of_it_reverse_fold< + SeqSize + , It + , State , F > - {}; - template<typename StateRef, typename It0, typename F> - struct result_of_unrolled_reverse_fold< - StateRef - , It0 - , F - , 0 - > + >::type + it_reverse_fold(mpl::int_<SeqSize>, It const& it, typename State::type state, F& f) { - typedef StateRef type; - }; - template<typename StateRef, typename It0, typename F, int SeqSize> - struct result_of_first_unrolledreverse_fold - { - typedef typename - result_of_unrolled_reverse_fold< - typename fusion::detail::result_of_with_decltype< - F( - StateRef, - typename fusion::result_of::deref< It0 const>::type - ) - >::type - , typename result_of::prior< - It0 const - >::type - , F - , SeqSize-1 - >::type - type; - }; - template<int SeqSize, typename StateRef, typename Seq, typename F> - struct reverse_fold_impl - { - typedef typename - result_of_first_unrolledreverse_fold< - StateRef - , typename fusion::result_of::prior< typename result_of::end<Seq>::type >::type - , F - , SeqSize - >::type - type; - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static type - call(StateRef state, Seq& seq, F f) - { - typedef - unrolled_reverse_fold< - type - , SeqSize - > - unrolled_impl; - return unrolled_impl::call( - state, - fusion::prior( fusion::end(seq)), - f); - } - }; - template<typename StateRef, typename Seq, typename F> - struct reverse_fold_impl<0,StateRef,Seq,F> - { - typedef StateRef type; - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static StateRef - call(StateRef state, Seq&, F) - { - return static_cast<StateRef>(state); - } - }; - template<typename Seq, typename State, typename F, bool IsSegmented> + return it_reverse_fold< + typename result_of::prior<It>::type + , boost::result_of< + F( + typename add_reference<typename State::type>::type, + typename fusion::result_of::deref<It const>::type + ) + > + , F + >( + mpl::int_<SeqSize-1>() + , fusion::prior(it) + , f(state, fusion::deref(it)) + , f + ); + } + template<typename Seq, typename State, typename F + , bool = traits::is_sequence<Seq>::value + , bool = traits::is_segmented<Seq>::value> struct result_of_reverse_fold - : reverse_fold_impl< + {}; + template<typename Seq, typename State, typename F> + struct result_of_reverse_fold<Seq, State, F, true, false> + : result_of_it_reverse_fold< result_of::size<Seq>::value - , typename add_reference< - typename add_const<State>::type - >::type - , Seq + , typename fusion::result_of::prior< typename result_of::end<Seq>::type >::type + , add_reference<State> , F > {}; + template<typename Seq, typename State, typename F> + BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED + inline typename result_of_reverse_fold<Seq, State, F>::type + reverse_fold(Seq& seq, State& state, F& f) + { + return it_reverse_fold< + typename fusion::result_of::prior< typename result_of::end<Seq>::type >::type + , add_reference<State> + , F + >( + typename result_of::size<Seq>::type() + , fusion::prior( fusion::end(seq) ) + , state + , f + ); + } } namespace result_of { template<typename Seq, typename State, typename F> struct reverse_fold - : detail::result_of_reverse_fold< - Seq - , State - , F - , traits::is_segmented<Seq>::type::value - > + : detail::result_of_reverse_fold<Seq, State, F> {}; } template<typename Seq, typename State, typename F> @@ -357,10 +150,7 @@ namespace boost { namespace fusion >::type reverse_fold(Seq& seq, State const& state, F f) { - return result_of::reverse_fold<Seq,State const,F>::call( - state, - seq, - f); + return detail::reverse_fold<Seq, State const, F>(seq, state, f); } template<typename Seq, typename State, typename F> BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED @@ -371,37 +161,28 @@ namespace boost { namespace fusion >::type reverse_fold(Seq const& seq, State const& state, F f) { - return result_of::reverse_fold<Seq const,State const,F>::call( - state, - seq, - f); + return detail::reverse_fold<Seq const, State const, F>(seq, state, f); } template<typename Seq, typename State, typename F> BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED inline typename result_of::reverse_fold< Seq - , State const + , State , F >::type reverse_fold(Seq& seq, State& state, F f) { - return result_of::reverse_fold<Seq,State,F>::call( - state, - seq, - f); + return detail::reverse_fold<Seq, State, F>(seq, state, f); } template<typename Seq, typename State, typename F> BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED inline typename result_of::reverse_fold< Seq const - , State const + , State , F >::type reverse_fold(Seq const& seq, State& state, F f) { - return result_of::reverse_fold<Seq const,State,F>::call( - state, - seq, - f); + return detail::reverse_fold<Seq const, State, F>(seq, state, f); } }} diff --git a/boost/fusion/algorithm/iteration/detail/preprocessed/reverse_iter_fold.hpp b/boost/fusion/algorithm/iteration/detail/preprocessed/reverse_iter_fold.hpp index bf1edca53d..10bd9c7d3b 100644 --- a/boost/fusion/algorithm/iteration/detail/preprocessed/reverse_iter_fold.hpp +++ b/boost/fusion/algorithm/iteration/detail/preprocessed/reverse_iter_fold.hpp @@ -7,345 +7,138 @@ This is an auto-generated file. Do not edit! ==============================================================================*/ +# if BOOST_WORKAROUND (BOOST_MSVC, < 1500) +# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) void +# else +# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) typename T::type +# endif namespace boost { namespace fusion { namespace detail { - template<typename State, typename It, typename F> - struct reverse_iter_fold_lvalue_state - : fusion::detail::result_of_with_decltype< - F( - typename add_reference<typename add_const<State>::type>::type, - It&) - > - {}; - template<typename Result,int N> - struct unrolled_reverse_iter_fold - { - template<typename State3, typename It3, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_3(State3 const& state3,It3 const& it3,F& f) - { - return unrolled_reverse_iter_fold< - Result - , N-4 - >::call( - f(state3,it3), - fusion::prior(it3), - f); - } - template<typename State2, typename It2, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_2(State2 const& state2,It2 const& it2,F& f) - { - return call_3( - f(state2,it2), - fusion::prior(it2), - f); - } - template<typename State1, typename It1, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_1(State1 const& state1,It1 const& it1,F& f) - { - return call_2( - f(state1,it1), - fusion::prior(it1), - f); - } - template<typename State, typename It0, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call(State const& state,It0 const& it0,F f) - { - return call_1( - f(state,it0), - fusion::prior(it0), - f); - } - }; - template<typename Result> - struct unrolled_reverse_iter_fold<Result,3> - { - template<typename State2, typename It2, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_2(State2 const& state2,It2 const& it2,F& f) - { - return f(state2,it2); - } - template<typename State1, typename It1, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_1(State1 const& state1,It1 const& it1,F& f) - { - return call_2( - f(state1,it1), - fusion::prior(it1), - f); - } - template<typename State, typename It0, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call(State const& state,It0 const& it0,F f) - { - return call_1( - f(state,it0), - fusion::prior(it0), - f); - } - }; - template<typename Result> - struct unrolled_reverse_iter_fold<Result,2> - { - template<typename State1, typename It1, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call_1(State1 const& state1,It1 const& it1,F& f) - { - return f(state1,it1); - } - template<typename State, typename It0, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call(State const& state,It0 const& it0,F f) - { - return call_1( - f(state,it0), - fusion::prior(it0), - f); - } - }; - template<typename Result> - struct unrolled_reverse_iter_fold<Result,1> - { - template<typename State, typename It0, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call(State const& state,It0 const& it0,F f) - { - return f(state, - it0); - } - }; - template<typename Result> - struct unrolled_reverse_iter_fold<Result,0> - { - template<typename State, typename It0, typename F> - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static Result - call(State const& state,It0 const&, F) - { - return static_cast<Result>(state); - } - }; - template<typename StateRef, typename It0, typename F, int N> - struct result_of_unrolled_reverse_iter_fold - { - typedef typename - reverse_iter_fold_lvalue_state< - StateRef - , It0 const - , F - >::type - rest1; - typedef typename - result_of::prior< - It0 const - >::type - it1; - typedef typename - reverse_iter_fold_lvalue_state< - rest1 - , it1 - , F - >::type - rest2; - typedef typename - result_of::prior<it1>::type - it2; - typedef typename - reverse_iter_fold_lvalue_state< - rest2 - , it2 - , F - >::type - rest3; - typedef typename - result_of::prior<it2>::type - it3; - typedef typename - result_of_unrolled_reverse_iter_fold< - typename reverse_iter_fold_lvalue_state< - rest3 - , it3 - , F - >::type - , typename result_of::prior< - it3 - >::type - , F - , N-4 - >::type - type; - }; - template<typename StateRef, typename It0, typename F> - struct result_of_unrolled_reverse_iter_fold< - StateRef - , It0 - , F - , 3 + template<int SeqSize, typename It, typename State, typename F, typename = void +# if BOOST_WORKAROUND (BOOST_MSVC, < 1500) + + , bool = SeqSize == 0 +# endif > + struct result_of_it_reverse_iter_fold + {}; + template<typename It, typename State, typename F> + struct result_of_it_reverse_iter_fold<0,It,State,F + , typename boost::enable_if_has_type<BOOST_FUSION_FOLD_IMPL_ENABLER(State)>::type +# if BOOST_WORKAROUND (BOOST_MSVC, < 1500) + , true +# endif + > { - typedef typename - reverse_iter_fold_lvalue_state< - StateRef - , It0 const - , F - >::type - rest1; - typedef typename - result_of::prior< - It0 const - >::type - it1; - typedef typename - reverse_iter_fold_lvalue_state< - typename reverse_iter_fold_lvalue_state< - rest1 - , it1 - , F - >::type - , typename result_of::prior< - it1 const - >::type const - , F - >::type - type; + typedef typename State::type type; }; - template<typename StateRef, typename It0, typename F> - struct result_of_unrolled_reverse_iter_fold< - StateRef - , It0 - , F - , 2 - > - : reverse_iter_fold_lvalue_state< - typename reverse_iter_fold_lvalue_state< - StateRef - , It0 const - , F - >::type - , typename result_of::prior< - It0 const - >::type const + template<int SeqSize, typename It, typename State, typename F> + struct result_of_it_reverse_iter_fold<SeqSize,It,State,F + , typename boost::enable_if_has_type< +# if BOOST_WORKAROUND (BOOST_MSVC, >= 1500) + + + + typename boost::disable_if_c<SeqSize == 0, State>::type::type +# else + BOOST_FUSION_FOLD_IMPL_ENABLER(State) +# endif + >::type +# if BOOST_WORKAROUND (BOOST_MSVC, < 1500) + , false +# endif + > + : result_of_it_reverse_iter_fold< + SeqSize-1 + , typename result_of::prior<It>::type + , boost::result_of< + F( + typename add_reference<typename State::type>::type, + It const& + ) + > , F > {}; - template<typename StateRef, typename It0, typename F> - struct result_of_unrolled_reverse_iter_fold< - StateRef - , It0 + template<typename It, typename State, typename F> + BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED + inline typename result_of_it_reverse_iter_fold< + 0 + , It + , State , F - , 1 - > - : reverse_iter_fold_lvalue_state< - StateRef - , It0 const + >::type + it_reverse_iter_fold(mpl::int_<0>, It const&, typename State::type state, F&) + { + return state; + } + template<typename It, typename State, typename F, int SeqSize> + BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED + inline typename lazy_enable_if_c< + SeqSize != 0 + , result_of_it_reverse_iter_fold< + SeqSize + , It + , State , F > - {}; - template<typename StateRef, typename It0, typename F> - struct result_of_unrolled_reverse_iter_fold< - StateRef - , It0 - , F - , 0 - > + >::type + it_reverse_iter_fold(mpl::int_<SeqSize>, It const& it, typename State::type state, F& f) { - typedef StateRef type; - }; - template<typename StateRef, typename It0, typename F, int SeqSize> - struct result_of_first_unrolledreverse_iter_fold - { - typedef typename - result_of_unrolled_reverse_iter_fold< - typename fusion::detail::result_of_with_decltype< - F( - StateRef, - It0 const& - ) - >::type - , typename result_of::prior< - It0 const - >::type - , F - , SeqSize-1 - >::type - type; - }; - template<int SeqSize, typename StateRef, typename Seq, typename F> - struct reverse_iter_fold_impl - { - typedef typename - result_of_first_unrolledreverse_iter_fold< - StateRef - , typename fusion::result_of::prior< typename result_of::end<Seq>::type >::type - , F - , SeqSize - >::type - type; - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static type - call(StateRef state, Seq& seq, F f) - { - typedef - unrolled_reverse_iter_fold< - type - , SeqSize - > - unrolled_impl; - return unrolled_impl::call( - state, - fusion::prior( fusion::end(seq)), - f); - } - }; - template<typename StateRef, typename Seq, typename F> - struct reverse_iter_fold_impl<0,StateRef,Seq,F> - { - typedef StateRef type; - BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static StateRef - call(StateRef state, Seq&, F) - { - return static_cast<StateRef>(state); - } - }; - template<typename Seq, typename State, typename F, bool IsSegmented> + return it_reverse_iter_fold< + typename result_of::prior<It>::type + , boost::result_of< + F( + typename add_reference<typename State::type>::type, + It const& + ) + > + , F + >( + mpl::int_<SeqSize-1>() + , fusion::prior(it) + , f(state, it) + , f + ); + } + template<typename Seq, typename State, typename F + , bool = traits::is_sequence<Seq>::value + , bool = traits::is_segmented<Seq>::value> struct result_of_reverse_iter_fold - : reverse_iter_fold_impl< + {}; + template<typename Seq, typename State, typename F> + struct result_of_reverse_iter_fold<Seq, State, F, true, false> + : result_of_it_reverse_iter_fold< result_of::size<Seq>::value - , typename add_reference< - typename add_const<State>::type - >::type - , Seq + , typename fusion::result_of::prior< typename result_of::end<Seq>::type >::type + , add_reference<State> , F > {}; + template<typename Seq, typename State, typename F> + BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED + inline typename result_of_reverse_iter_fold<Seq, State, F>::type + reverse_iter_fold(Seq& seq, State& state, F& f) + { + return it_reverse_iter_fold< + typename fusion::result_of::prior< typename result_of::end<Seq>::type >::type + , add_reference<State> + , F + >( + typename result_of::size<Seq>::type() + , fusion::prior( fusion::end(seq) ) + , state + , f + ); + } } namespace result_of { template<typename Seq, typename State, typename F> struct reverse_iter_fold - : detail::result_of_reverse_iter_fold< - Seq - , State - , F - , traits::is_segmented<Seq>::type::value - > + : detail::result_of_reverse_iter_fold<Seq, State, F> {}; } template<typename Seq, typename State, typename F> @@ -357,10 +150,7 @@ namespace boost { namespace fusion >::type reverse_iter_fold(Seq& seq, State const& state, F f) { - return result_of::reverse_iter_fold<Seq,State const,F>::call( - state, - seq, - f); + return detail::reverse_iter_fold<Seq, State const, F>(seq, state, f); } template<typename Seq, typename State, typename F> BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED @@ -371,37 +161,28 @@ namespace boost { namespace fusion >::type reverse_iter_fold(Seq const& seq, State const& state, F f) { - return result_of::reverse_iter_fold<Seq const,State const,F>::call( - state, - seq, - f); + return detail::reverse_iter_fold<Seq const, State const, F>(seq, state, f); } template<typename Seq, typename State, typename F> BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED inline typename result_of::reverse_iter_fold< Seq - , State const + , State , F >::type reverse_iter_fold(Seq& seq, State& state, F f) { - return result_of::reverse_iter_fold<Seq,State,F>::call( - state, - seq, - f); + return detail::reverse_iter_fold<Seq, State, F>(seq, state, f); } template<typename Seq, typename State, typename F> BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED inline typename result_of::reverse_iter_fold< Seq const - , State const + , State , F >::type reverse_iter_fold(Seq const& seq, State& state, F f) { - return result_of::reverse_iter_fold<Seq const,State,F>::call( - state, - seq, - f); + return detail::reverse_iter_fold<Seq const, State, F>(seq, state, f); } }} diff --git a/boost/fusion/algorithm/iteration/detail/segmented_fold.hpp b/boost/fusion/algorithm/iteration/detail/segmented_fold.hpp index 4ff679af2e..350bff75b3 100644 --- a/boost/fusion/algorithm/iteration/detail/segmented_fold.hpp +++ b/boost/fusion/algorithm/iteration/detail/segmented_fold.hpp @@ -10,6 +10,7 @@ #include <boost/fusion/support/config.hpp> #include <boost/fusion/algorithm/iteration/fold_fwd.hpp> #include <boost/fusion/support/segmented_fold_until.hpp> +#include <boost/mpl/bool.hpp> namespace boost { namespace fusion { namespace detail { @@ -38,11 +39,11 @@ namespace boost { namespace fusion { namespace detail }; // The default implementation of this lives in detail/fold.hpp - template <typename Sequence, typename State, typename Fun, bool IsSegmented> + template <typename Sequence, typename State, typename Fun, bool IsSequence, bool IsSegmented> struct result_of_fold; template <typename Sequence, typename State, typename Fun> - struct result_of_fold<Sequence, State, Fun, true> + struct result_of_fold<Sequence, State, Fun, true, true> { typedef typename result_of::segmented_fold_until< @@ -53,7 +54,7 @@ namespace boost { namespace fusion { namespace detail type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED - static type call(State& state, Sequence& seq, Fun fun) + static type call(Sequence& seq, State& state, Fun& fun) { return fusion::segmented_fold_until(seq, state, segmented_fold_fun<Fun>(fun)); } diff --git a/boost/fusion/algorithm/iteration/fold.hpp b/boost/fusion/algorithm/iteration/fold.hpp index a2a0146ab4..039e01c0c7 100644 --- a/boost/fusion/algorithm/iteration/fold.hpp +++ b/boost/fusion/algorithm/iteration/fold.hpp @@ -2,6 +2,7 @@ Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2007 Dan Marsden Copyright (c) 2009-2010 Christopher Schmidt + Copyright (c) 2015 Kohei Takahashi 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) @@ -10,24 +11,17 @@ #define BOOST_FUSION_ALGORITHM_ITERATION_FOLD_HPP #include <boost/fusion/support/config.hpp> -#include <boost/fusion/support/detail/result_of.hpp> #include <boost/fusion/algorithm/iteration/fold_fwd.hpp> #include <boost/config.hpp> #include <boost/fusion/sequence/intrinsic/begin.hpp> -#include <boost/fusion/sequence/intrinsic/end.hpp> -#include <boost/fusion/sequence/intrinsic/empty.hpp> #include <boost/fusion/sequence/intrinsic/size.hpp> #include <boost/fusion/support/is_segmented.hpp> -#include <boost/fusion/iterator/equal_to.hpp> +#include <boost/fusion/support/is_sequence.hpp> #include <boost/fusion/iterator/deref.hpp> #include <boost/fusion/iterator/value_of.hpp> -#include <boost/fusion/iterator/prior.hpp> #include <boost/fusion/iterator/next.hpp> -#include <boost/mpl/eval_if.hpp> -#include <boost/mpl/if.hpp> -#include <boost/mpl/bool.hpp> #include <boost/utility/result_of.hpp> -#include <boost/type_traits/add_const.hpp> +#include <boost/core/enable_if.hpp> #include <boost/type_traits/add_reference.hpp> #if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES) diff --git a/boost/fusion/algorithm/iteration/fold_fwd.hpp b/boost/fusion/algorithm/iteration/fold_fwd.hpp index f8328e80f9..0dbac7618b 100644 --- a/boost/fusion/algorithm/iteration/fold_fwd.hpp +++ b/boost/fusion/algorithm/iteration/fold_fwd.hpp @@ -38,7 +38,7 @@ namespace boost { namespace fusion BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED inline typename result_of::fold< Seq - , State const + , State , F >::type fold(Seq& seq, State& state, F f); @@ -47,7 +47,7 @@ namespace boost { namespace fusion BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED inline typename result_of::fold< Seq const - , State const + , State , F >::type fold(Seq const& seq, State& state, F f); diff --git a/boost/fusion/algorithm/iteration/iter_fold.hpp b/boost/fusion/algorithm/iteration/iter_fold.hpp index b59a6957bc..cff5b4edf9 100644 --- a/boost/fusion/algorithm/iteration/iter_fold.hpp +++ b/boost/fusion/algorithm/iteration/iter_fold.hpp @@ -1,6 +1,7 @@ /*============================================================================= Copyright (c) 2010 Christopher Schmidt Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2015 Kohei Takahashi 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) @@ -13,20 +14,14 @@ #include <boost/fusion/algorithm/iteration/iter_fold_fwd.hpp> #include <boost/config.hpp> #include <boost/fusion/sequence/intrinsic/begin.hpp> -#include <boost/fusion/sequence/intrinsic/end.hpp> -#include <boost/fusion/sequence/intrinsic/empty.hpp> #include <boost/fusion/sequence/intrinsic/size.hpp> #include <boost/fusion/support/is_segmented.hpp> -#include <boost/fusion/support/detail/result_of.hpp> -#include <boost/fusion/iterator/equal_to.hpp> +#include <boost/fusion/support/is_sequence.hpp> #include <boost/fusion/iterator/deref.hpp> #include <boost/fusion/iterator/value_of.hpp> -#include <boost/fusion/iterator/prior.hpp> #include <boost/fusion/iterator/next.hpp> -#include <boost/mpl/eval_if.hpp> -#include <boost/mpl/if.hpp> -#include <boost/mpl/bool.hpp> -#include <boost/type_traits/add_const.hpp> +#include <boost/utility/result_of.hpp> +#include <boost/core/enable_if.hpp> #include <boost/type_traits/add_reference.hpp> #define BOOST_FUSION_ITER_FOLD diff --git a/boost/fusion/algorithm/iteration/iter_fold_fwd.hpp b/boost/fusion/algorithm/iteration/iter_fold_fwd.hpp index 6c595cf198..1d8543ca5f 100644 --- a/boost/fusion/algorithm/iteration/iter_fold_fwd.hpp +++ b/boost/fusion/algorithm/iteration/iter_fold_fwd.hpp @@ -38,7 +38,7 @@ namespace boost { namespace fusion BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED inline typename result_of::iter_fold< Seq - , State const + , State , F >::type iter_fold(Seq& seq, State& state, F f); @@ -47,7 +47,7 @@ namespace boost { namespace fusion BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED inline typename result_of::iter_fold< Seq const - , State const + , State , F >::type iter_fold(Seq const& seq, State& state, F f); diff --git a/boost/fusion/algorithm/iteration/reverse_fold.hpp b/boost/fusion/algorithm/iteration/reverse_fold.hpp index dffff79e14..252ad30836 100644 --- a/boost/fusion/algorithm/iteration/reverse_fold.hpp +++ b/boost/fusion/algorithm/iteration/reverse_fold.hpp @@ -1,6 +1,7 @@ /*============================================================================= Copyright (c) 2010 Christopher Schmidt Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2015 Kohei Takahashi 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) @@ -10,24 +11,17 @@ #define BOOST_FUSION_ALGORITHM_ITERATION_REVERSE_FOLD_HPP #include <boost/fusion/support/config.hpp> -#include <boost/fusion/support/detail/result_of.hpp> #include <boost/fusion/algorithm/iteration/reverse_fold_fwd.hpp> #include <boost/config.hpp> -#include <boost/fusion/sequence/intrinsic/begin.hpp> #include <boost/fusion/sequence/intrinsic/end.hpp> -#include <boost/fusion/sequence/intrinsic/empty.hpp> #include <boost/fusion/sequence/intrinsic/size.hpp> #include <boost/fusion/support/is_segmented.hpp> -#include <boost/fusion/iterator/equal_to.hpp> +#include <boost/fusion/support/is_sequence.hpp> #include <boost/fusion/iterator/deref.hpp> #include <boost/fusion/iterator/value_of.hpp> #include <boost/fusion/iterator/prior.hpp> -#include <boost/fusion/iterator/next.hpp> -#include <boost/mpl/eval_if.hpp> -#include <boost/mpl/if.hpp> -#include <boost/mpl/bool.hpp> #include <boost/utility/result_of.hpp> -#include <boost/type_traits/add_const.hpp> +#include <boost/core/enable_if.hpp> #include <boost/type_traits/add_reference.hpp> #define BOOST_FUSION_REVERSE_FOLD diff --git a/boost/fusion/algorithm/iteration/reverse_fold_fwd.hpp b/boost/fusion/algorithm/iteration/reverse_fold_fwd.hpp index 42c8ac2163..c5e24b34a9 100644 --- a/boost/fusion/algorithm/iteration/reverse_fold_fwd.hpp +++ b/boost/fusion/algorithm/iteration/reverse_fold_fwd.hpp @@ -38,7 +38,7 @@ namespace boost { namespace fusion BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED inline typename result_of::reverse_fold< Seq - , State const + , State , F >::type reverse_fold(Seq& seq, State& state, F f); @@ -47,7 +47,7 @@ namespace boost { namespace fusion BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED inline typename result_of::reverse_fold< Seq const - , State const + , State , F >::type reverse_fold(Seq const& seq, State& state, F f); diff --git a/boost/fusion/algorithm/iteration/reverse_iter_fold.hpp b/boost/fusion/algorithm/iteration/reverse_iter_fold.hpp index d36861f37b..3276bbde57 100644 --- a/boost/fusion/algorithm/iteration/reverse_iter_fold.hpp +++ b/boost/fusion/algorithm/iteration/reverse_iter_fold.hpp @@ -1,6 +1,7 @@ /*============================================================================= Copyright (c) 2010 Christopher Schmidt Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2015 Kohei Takahashi 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) @@ -9,24 +10,17 @@ #define BOOST_FUSION_ALGORITHM_ITERATION_REVERSE_ITER_FOLD_HPP #include <boost/fusion/support/config.hpp> -#include <boost/fusion/support/detail/result_of.hpp> #include <boost/fusion/algorithm/iteration/reverse_iter_fold_fwd.hpp> #include <boost/config.hpp> -#include <boost/fusion/sequence/intrinsic/begin.hpp> #include <boost/fusion/sequence/intrinsic/end.hpp> -#include <boost/fusion/sequence/intrinsic/empty.hpp> #include <boost/fusion/sequence/intrinsic/size.hpp> #include <boost/fusion/support/is_segmented.hpp> -#include <boost/fusion/iterator/equal_to.hpp> +#include <boost/fusion/support/is_sequence.hpp> #include <boost/fusion/iterator/deref.hpp> #include <boost/fusion/iterator/value_of.hpp> #include <boost/fusion/iterator/prior.hpp> -#include <boost/fusion/iterator/next.hpp> -#include <boost/mpl/eval_if.hpp> -#include <boost/mpl/if.hpp> -#include <boost/mpl/bool.hpp> #include <boost/utility/result_of.hpp> -#include <boost/type_traits/add_const.hpp> +#include <boost/core/enable_if.hpp> #include <boost/type_traits/add_reference.hpp> #define BOOST_FUSION_REVERSE_FOLD diff --git a/boost/fusion/algorithm/iteration/reverse_iter_fold_fwd.hpp b/boost/fusion/algorithm/iteration/reverse_iter_fold_fwd.hpp index 21d99deead..76f0186392 100644 --- a/boost/fusion/algorithm/iteration/reverse_iter_fold_fwd.hpp +++ b/boost/fusion/algorithm/iteration/reverse_iter_fold_fwd.hpp @@ -38,7 +38,7 @@ namespace boost { namespace fusion BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED inline typename result_of::reverse_iter_fold< Seq - , State const + , State , F >::type reverse_iter_fold(Seq& seq, State& state, F f); @@ -47,7 +47,7 @@ namespace boost { namespace fusion BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED inline typename result_of::reverse_iter_fold< Seq const - , State const + , State , F >::type reverse_iter_fold(Seq const& seq, State& state, F f); |