feedc0de/boost_fusion
1
0
Fork 0
forked from boostorg/fusion
Code Pull Requests Activity

Overhaul the fusion::fold family to make SFINAE-friendly.

Browse Source
This commit is contained in:
Kohei Takahashi
2015-09-04 00:51:56 +09:00
parent efd595fd10
commit d3449ab5e5
12 changed files with 131 additions and 489 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
include/boost/fusion/algorithm/iteration/accumulate.hpp
View File

@ -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);

15
include/boost/fusion/algorithm/iteration/accumulate_fwd.hpp
View File

@ -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);
}}

474
include/boost/fusion/algorithm/iteration/detail/fold.hpp
View File

@ -2,6 +2,7 @@
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)
@ -45,374 +46,121 @@ 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>
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 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<typename State::type>::type>
{
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);
}
typedef typename State::type type;
};
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
>
{
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 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)
{
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
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<typename State::type>::type>
: 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 State::type const&,
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);
}
};
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
>
{};
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
>::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
>
>::type
BOOST_PP_CAT(it_,BOOST_FUSION_FOLD_NAME)(mpl::int_<SeqSize>, It const& it, typename State::type state, F& f)
{
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 State::type const&,
BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM(It const)
)
>
, 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>
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
, BOOST_FUSION_FOLD_IMPL_FIRST_IT_META_TRANSFORM(
typename result_of::BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION<Seq>::type
)
, add_reference<typename add_const<State>::type>
, 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<typename add_const<State>::type>
, 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 +173,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,10 +185,7 @@ 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>
@ -455,10 +197,7 @@ namespace boost { namespace fusion
>::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>
@ -470,10 +209,7 @@ namespace boost { namespace fusion
>::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);
}
}}

7
include/boost/fusion/algorithm/iteration/detail/segmented_fold.hpp
View File

@ -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));
}

11
include/boost/fusion/algorithm/iteration/fold.hpp
View File

@ -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,23 +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/core/enable_if.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/add_reference.hpp>

12
include/boost/fusion/algorithm/iteration/iter_fold.hpp
View File

@ -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,19 +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/utility/result_of.hpp>
#include <boost/core/enable_if.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/add_reference.hpp>

11
include/boost/fusion/algorithm/iteration/reverse_fold.hpp
View File

@ -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,23 +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/core/enable_if.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/add_reference.hpp>

11
include/boost/fusion/algorithm/iteration/reverse_iter_fold.hpp
View File

@ -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,23 +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/core/enable_if.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/add_reference.hpp>