boostorg/fusion
1
0
Fork 1
mirror of https://github.com/boostorg/fusion.git synced 2025-07-21 16:22:45 +02:00
Code Issues Packages Projects Releases Wiki Activity

Regenerate preprocessed files.

Browse Source
This commit is contained in:
Kohei Takahashi
2015-10-17 11:24:19 +09:00
parent 1d45a87201
commit a81024f617
9 changed files with 375 additions and 1337 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -12,341 +12,110 @@ namespace boost { namespace fusion
{ {
namespace detail namespace detail
{ {
template<typename State, typename It, typename F> template<int SeqSize, typename It, typename State, typename F, typename = void>
struct fold_lvalue_state struct result_of_it_fold
: 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> template<typename It, typename State, typename F>
struct unrolled_fold struct result_of_it_fold<0,It,State,F
, typename boost::enable_if_has_type<typename State::type>::type>
{ {
template<typename State3, typename It3, typename F> typedef typename State::type type;
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> template<int SeqSize, typename It, typename State, typename F>
struct unrolled_fold<Result,3> struct result_of_it_fold<SeqSize,It,State,F
{
template<typename State2, typename It2, typename F> , typename boost::enable_if_has_type<
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename boost::disable_if_c<SeqSize == 0, State>::type::type
static Result >::type>
call_2(State2 const& state2,It2 const& it2,F& f) : result_of_it_fold<
{ SeqSize-1
return f(state2,fusion::deref(it2)); , typename result_of::next<It>::type
} , boost::result_of<
template<typename State1, typename It1, typename F> F(
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename State::type>::type,
static Result typename fusion::result_of::deref<It const>::type
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
>
{
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;
};
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
, F , F
> >
{}; {};
template<typename StateRef, typename It0, typename F> template<typename It, typename State, typename F>
struct result_of_unrolled_fold< BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
StateRef inline typename result_of_it_fold<
, It0 0
, It
, State
, F , F
, 1 >::type
> it_fold(mpl::int_<0>, It const&, typename State::type state, F&)
: fold_lvalue_state< {
StateRef return state;
, It0 const }
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 , F
> >
{}; >::type
template<typename StateRef, typename It0, typename F> it_fold(mpl::int_<SeqSize>, It const& it, typename State::type state, F& f)
struct result_of_unrolled_fold<
StateRef
, It0
, F
, 0
>
{ {
typedef StateRef type; return it_fold<
}; typename result_of::next<It>::type
template<typename StateRef, typename It0, typename F, int SeqSize> , boost::result_of<
struct result_of_first_unrolledfold F(
{ typename add_reference<typename State::type>::type,
typedef typename typename fusion::result_of::deref<It const>::type
result_of_unrolled_fold< )
typename fusion::detail::result_of_with_decltype< >
F( , F
StateRef, >(
typename fusion::result_of::deref< It0 const>::type mpl::int_<SeqSize-1>()
) , fusion::next(it)
>::type , f(state, fusion::deref(it))
, typename result_of::next< , f
It0 const );
>::type }
, F template<typename Seq, typename State, typename F
, SeqSize-1 , bool = traits::is_sequence<Seq>::value
>::type , bool = traits::is_segmented<Seq>::value>
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>
struct result_of_fold 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 result_of::size<Seq>::value
, typename add_reference< , typename result_of::begin<Seq>::type
typename add_const<State>::type , add_reference<State>
>::type
, Seq
, F , 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 namespace result_of
{ {
template<typename Seq, typename State, typename F> template<typename Seq, typename State, typename F>
struct fold struct fold
: detail::result_of_fold< : detail::result_of_fold<Seq, State, F>
Seq
, State
, F
, traits::is_segmented<Seq>::type::value
>
{}; {};
} }
template<typename Seq, typename State, typename F> template<typename Seq, typename State, typename F>
@ -358,10 +127,7 @@ namespace boost { namespace fusion
>::type >::type
fold(Seq& seq, State const& state, F f) fold(Seq& seq, State const& state, F f)
{ {
return result_of::fold<Seq,State const,F>::call( return detail::fold<Seq, State const, F>(seq, state, f);
state,
seq,
f);
} }
template<typename Seq, typename State, typename F> template<typename Seq, typename State, typename F>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
@ -372,37 +138,28 @@ namespace boost { namespace fusion
>::type >::type
fold(Seq const& seq, State const& state, F f) fold(Seq const& seq, State const& state, F f)
{ {
return result_of::fold<Seq const,State const,F>::call( return detail::fold<Seq const, State const, F>(seq, state, f);
state,
seq,
f);
} }
template<typename Seq, typename State, typename F> template<typename Seq, typename State, typename F>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::fold< inline typename result_of::fold<
Seq Seq
, State const , State
, F , F
>::type >::type
fold(Seq& seq, State& state, F f) fold(Seq& seq, State& state, F f)
{ {
return result_of::fold<Seq,State,F>::call( return detail::fold<Seq, State, F>(seq, state, f);
state,
seq,
f);
} }
template<typename Seq, typename State, typename F> template<typename Seq, typename State, typename F>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::fold< inline typename result_of::fold<
Seq const Seq const
, State const , State
, F , F
>::type >::type
fold(Seq const& seq, State& state, F f) fold(Seq const& seq, State& state, F f)
{ {
return result_of::fold<Seq const,State,F>::call( return detail::fold<Seq const, State, F>(seq, state, f);
state,
seq,
f);
} }
}} }}

423
include/boost/fusion/algorithm/iteration/detail/preprocessed/iter_fold.hpp
View File

@ -11,341 +11,110 @@ namespace boost { namespace fusion
{ {
namespace detail namespace detail
{ {
template<typename State, typename It, typename F> template<int SeqSize, typename It, typename State, typename F, typename = void>
struct iter_fold_lvalue_state struct result_of_it_iter_fold
: fusion::detail::result_of_with_decltype<
F(
typename add_reference<typename add_const<State>::type>::type,
It&)
>
{}; {};
template<typename Result,int N> template<typename It, typename State, typename F>
struct unrolled_iter_fold struct result_of_it_iter_fold<0,It,State,F
, typename boost::enable_if_has_type<typename State::type>::type>
{ {
template<typename State3, typename It3, typename F> typedef typename State::type type;
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> template<int SeqSize, typename It, typename State, typename F>
struct unrolled_iter_fold<Result,3> struct result_of_it_iter_fold<SeqSize,It,State,F
{
template<typename State2, typename It2, typename F> , typename boost::enable_if_has_type<
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename boost::disable_if_c<SeqSize == 0, State>::type::type
static Result >::type>
call_2(State2 const& state2,It2 const& it2,F& f) : result_of_it_iter_fold<
{ SeqSize-1
return f(state2,it2); , typename result_of::next<It>::type
} , boost::result_of<
template<typename State1, typename It1, typename F> F(
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename State::type>::type,
static Result It const&
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
>
{
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;
};
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
, F , F
> >
{}; {};
template<typename StateRef, typename It0, typename F> template<typename It, typename State, typename F>
struct result_of_unrolled_iter_fold< BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
StateRef inline typename result_of_it_iter_fold<
, It0 0
, It
, State
, F , F
, 1 >::type
> it_iter_fold(mpl::int_<0>, It const&, typename State::type state, F&)
: iter_fold_lvalue_state< {
StateRef return state;
, It0 const }
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 , F
> >
{}; >::type
template<typename StateRef, typename It0, typename F> it_iter_fold(mpl::int_<SeqSize>, It const& it, typename State::type state, F& f)
struct result_of_unrolled_iter_fold<
StateRef
, It0
, F
, 0
>
{ {
typedef StateRef type; return it_iter_fold<
}; typename result_of::next<It>::type
template<typename StateRef, typename It0, typename F, int SeqSize> , boost::result_of<
struct result_of_first_unrollediter_fold F(
{ typename add_reference<typename State::type>::type,
typedef typename It const&
result_of_unrolled_iter_fold< )
typename fusion::detail::result_of_with_decltype< >
F( , F
StateRef, >(
It0 const& mpl::int_<SeqSize-1>()
) , fusion::next(it)
>::type , f(state, it)
, typename result_of::next< , f
It0 const );
>::type }
, F template<typename Seq, typename State, typename F
, SeqSize-1 , bool = traits::is_sequence<Seq>::value
>::type , bool = traits::is_segmented<Seq>::value>
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>
struct result_of_iter_fold 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 result_of::size<Seq>::value
, typename add_reference< , typename result_of::begin<Seq>::type
typename add_const<State>::type , add_reference<State>
>::type
, Seq
, F , 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 namespace result_of
{ {
template<typename Seq, typename State, typename F> template<typename Seq, typename State, typename F>
struct iter_fold struct iter_fold
: detail::result_of_iter_fold< : detail::result_of_iter_fold<Seq, State, F>
Seq
, State
, F
, traits::is_segmented<Seq>::type::value
>
{}; {};
} }
template<typename Seq, typename State, typename F> template<typename Seq, typename State, typename F>
@ -357,10 +126,7 @@ namespace boost { namespace fusion
>::type >::type
iter_fold(Seq& seq, State const& state, F f) iter_fold(Seq& seq, State const& state, F f)
{ {
return result_of::iter_fold<Seq,State const,F>::call( return detail::iter_fold<Seq, State const, F>(seq, state, f);
state,
seq,
f);
} }
template<typename Seq, typename State, typename F> template<typename Seq, typename State, typename F>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
@ -371,37 +137,28 @@ namespace boost { namespace fusion
>::type >::type
iter_fold(Seq const& seq, State const& state, F f) iter_fold(Seq const& seq, State const& state, F f)
{ {
return result_of::iter_fold<Seq const,State const,F>::call( return detail::iter_fold<Seq const, State const, F>(seq, state, f);
state,
seq,
f);
} }
template<typename Seq, typename State, typename F> template<typename Seq, typename State, typename F>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::iter_fold< inline typename result_of::iter_fold<
Seq Seq
, State const , State
, F , F
>::type >::type
iter_fold(Seq& seq, State& state, F f) iter_fold(Seq& seq, State& state, F f)
{ {
return result_of::iter_fold<Seq,State,F>::call( return detail::iter_fold<Seq, State, F>(seq, state, f);
state,
seq,
f);
} }
template<typename Seq, typename State, typename F> template<typename Seq, typename State, typename F>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::iter_fold< inline typename result_of::iter_fold<
Seq const Seq const
, State const , State
, F , F
>::type >::type
iter_fold(Seq const& seq, State& state, F f) iter_fold(Seq const& seq, State& state, F f)
{ {
return result_of::iter_fold<Seq const,State,F>::call( return detail::iter_fold<Seq const, State, F>(seq, state, f);
state,
seq,
f);
} }
}} }}

423
include/boost/fusion/algorithm/iteration/detail/preprocessed/reverse_fold.hpp
View File

@ -11,341 +11,110 @@ namespace boost { namespace fusion
{ {
namespace detail namespace detail
{ {
template<typename State, typename It, typename F> template<int SeqSize, typename It, typename State, typename F, typename = void>
struct reverse_fold_lvalue_state struct result_of_it_reverse_fold
: 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> template<typename It, typename State, typename F>
struct unrolled_reverse_fold struct result_of_it_reverse_fold<0,It,State,F
, typename boost::enable_if_has_type<typename State::type>::type>
{ {
template<typename State3, typename It3, typename F> typedef typename State::type type;
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> template<int SeqSize, typename It, typename State, typename F>
struct unrolled_reverse_fold<Result,3> struct result_of_it_reverse_fold<SeqSize,It,State,F
{
template<typename State2, typename It2, typename F> , typename boost::enable_if_has_type<
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename boost::disable_if_c<SeqSize == 0, State>::type::type
static Result >::type>
call_2(State2 const& state2,It2 const& it2,F& f) : result_of_it_reverse_fold<
{ SeqSize-1
return f(state2,fusion::deref(it2)); , typename result_of::prior<It>::type
} , boost::result_of<
template<typename State1, typename It1, typename F> F(
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename State::type>::type,
static Result typename fusion::result_of::deref<It const>::type
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
>
{
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;
};
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
, F , F
> >
{}; {};
template<typename StateRef, typename It0, typename F> template<typename It, typename State, typename F>
struct result_of_unrolled_reverse_fold< BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
StateRef inline typename result_of_it_reverse_fold<
, It0 0
, It
, State
, F , F
, 1 >::type
> it_reverse_fold(mpl::int_<0>, It const&, typename State::type state, F&)
: reverse_fold_lvalue_state< {
StateRef return state;
, It0 const }
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 , F
> >
{}; >::type
template<typename StateRef, typename It0, typename F> it_reverse_fold(mpl::int_<SeqSize>, It const& it, typename State::type state, F& f)
struct result_of_unrolled_reverse_fold<
StateRef
, It0
, F
, 0
>
{ {
typedef StateRef type; return it_reverse_fold<
}; typename result_of::prior<It>::type
template<typename StateRef, typename It0, typename F, int SeqSize> , boost::result_of<
struct result_of_first_unrolledreverse_fold F(
{ typename add_reference<typename State::type>::type,
typedef typename typename fusion::result_of::deref<It const>::type
result_of_unrolled_reverse_fold< )
typename fusion::detail::result_of_with_decltype< >
F( , F
StateRef, >(
typename fusion::result_of::deref< It0 const>::type mpl::int_<SeqSize-1>()
) , fusion::prior(it)
>::type , f(state, fusion::deref(it))
, typename result_of::prior< , f
It0 const );
>::type }
, F template<typename Seq, typename State, typename F
, SeqSize-1 , bool = traits::is_sequence<Seq>::value
>::type , bool = traits::is_segmented<Seq>::value>
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>
struct result_of_reverse_fold 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 result_of::size<Seq>::value
, typename add_reference< , typename fusion::result_of::prior< typename result_of::end<Seq>::type >::type
typename add_const<State>::type , add_reference<State>
>::type
, Seq
, F , 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 namespace result_of
{ {
template<typename Seq, typename State, typename F> template<typename Seq, typename State, typename F>
struct reverse_fold struct reverse_fold
: detail::result_of_reverse_fold< : detail::result_of_reverse_fold<Seq, State, F>
Seq
, State
, F
, traits::is_segmented<Seq>::type::value
>
{}; {};
} }
template<typename Seq, typename State, typename F> template<typename Seq, typename State, typename F>
@ -357,10 +126,7 @@ namespace boost { namespace fusion
>::type >::type
reverse_fold(Seq& seq, State const& state, F f) reverse_fold(Seq& seq, State const& state, F f)
{ {
return result_of::reverse_fold<Seq,State const,F>::call( return detail::reverse_fold<Seq, State const, F>(seq, state, f);
state,
seq,
f);
} }
template<typename Seq, typename State, typename F> template<typename Seq, typename State, typename F>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
@ -371,37 +137,28 @@ namespace boost { namespace fusion
>::type >::type
reverse_fold(Seq const& seq, State const& state, F f) reverse_fold(Seq const& seq, State const& state, F f)
{ {
return result_of::reverse_fold<Seq const,State const,F>::call( return detail::reverse_fold<Seq const, State const, F>(seq, state, f);
state,
seq,
f);
} }
template<typename Seq, typename State, typename F> template<typename Seq, typename State, typename F>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::reverse_fold< inline typename result_of::reverse_fold<
Seq Seq
, State const , State
, F , F
>::type >::type
reverse_fold(Seq& seq, State& state, F f) reverse_fold(Seq& seq, State& state, F f)
{ {
return result_of::reverse_fold<Seq,State,F>::call( return detail::reverse_fold<Seq, State, F>(seq, state, f);
state,
seq,
f);
} }
template<typename Seq, typename State, typename F> template<typename Seq, typename State, typename F>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::reverse_fold< inline typename result_of::reverse_fold<
Seq const Seq const
, State const , State
, F , F
>::type >::type
reverse_fold(Seq const& seq, State& state, F f) reverse_fold(Seq const& seq, State& state, F f)
{ {
return result_of::reverse_fold<Seq const,State,F>::call( return detail::reverse_fold<Seq const, State, F>(seq, state, f);
state,
seq,
f);
} }
}} }}

423
include/boost/fusion/algorithm/iteration/detail/preprocessed/reverse_iter_fold.hpp
View File

@ -11,341 +11,110 @@ namespace boost { namespace fusion
{ {
namespace detail namespace detail
{ {
template<typename State, typename It, typename F> template<int SeqSize, typename It, typename State, typename F, typename = void>
struct reverse_iter_fold_lvalue_state struct result_of_it_reverse_iter_fold
: fusion::detail::result_of_with_decltype<
F(
typename add_reference<typename add_const<State>::type>::type,
It&)
>
{}; {};
template<typename Result,int N> template<typename It, typename State, typename F>
struct unrolled_reverse_iter_fold struct result_of_it_reverse_iter_fold<0,It,State,F
, typename boost::enable_if_has_type<typename State::type>::type>
{ {
template<typename State3, typename It3, typename F> typedef typename State::type type;
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> template<int SeqSize, typename It, typename State, typename F>
struct unrolled_reverse_iter_fold<Result,3> struct result_of_it_reverse_iter_fold<SeqSize,It,State,F
{
template<typename State2, typename It2, typename F> , typename boost::enable_if_has_type<
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename boost::disable_if_c<SeqSize == 0, State>::type::type
static Result >::type>
call_2(State2 const& state2,It2 const& it2,F& f) : result_of_it_reverse_iter_fold<
{ SeqSize-1
return f(state2,it2); , typename result_of::prior<It>::type
} , boost::result_of<
template<typename State1, typename It1, typename F> F(
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename State::type>::type,
static Result It const&
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
>
{
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;
};
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
, F , F
> >
{}; {};
template<typename StateRef, typename It0, typename F> template<typename It, typename State, typename F>
struct result_of_unrolled_reverse_iter_fold< BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
StateRef inline typename result_of_it_reverse_iter_fold<
, It0 0
, It
, State
, F , F
, 1 >::type
> it_reverse_iter_fold(mpl::int_<0>, It const&, typename State::type state, F&)
: reverse_iter_fold_lvalue_state< {
StateRef return state;
, It0 const }
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 , F
> >
{}; >::type
template<typename StateRef, typename It0, typename F> it_reverse_iter_fold(mpl::int_<SeqSize>, It const& it, typename State::type state, F& f)
struct result_of_unrolled_reverse_iter_fold<
StateRef
, It0
, F
, 0
>
{ {
typedef StateRef type; return it_reverse_iter_fold<
}; typename result_of::prior<It>::type
template<typename StateRef, typename It0, typename F, int SeqSize> , boost::result_of<
struct result_of_first_unrolledreverse_iter_fold F(
{ typename add_reference<typename State::type>::type,
typedef typename It const&
result_of_unrolled_reverse_iter_fold< )
typename fusion::detail::result_of_with_decltype< >
F( , F
StateRef, >(
It0 const& mpl::int_<SeqSize-1>()
) , fusion::prior(it)
>::type , f(state, it)
, typename result_of::prior< , f
It0 const );
>::type }
, F template<typename Seq, typename State, typename F
, SeqSize-1 , bool = traits::is_sequence<Seq>::value
>::type , bool = traits::is_segmented<Seq>::value>
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>
struct result_of_reverse_iter_fold 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 result_of::size<Seq>::value
, typename add_reference< , typename fusion::result_of::prior< typename result_of::end<Seq>::type >::type
typename add_const<State>::type , add_reference<State>
>::type
, Seq
, F , 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 namespace result_of
{ {
template<typename Seq, typename State, typename F> template<typename Seq, typename State, typename F>
struct reverse_iter_fold struct reverse_iter_fold
: detail::result_of_reverse_iter_fold< : detail::result_of_reverse_iter_fold<Seq, State, F>
Seq
, State
, F
, traits::is_segmented<Seq>::type::value
>
{}; {};
} }
template<typename Seq, typename State, typename F> template<typename Seq, typename State, typename F>
@ -357,10 +126,7 @@ namespace boost { namespace fusion
>::type >::type
reverse_iter_fold(Seq& seq, State const& state, F f) reverse_iter_fold(Seq& seq, State const& state, F f)
{ {
return result_of::reverse_iter_fold<Seq,State const,F>::call( return detail::reverse_iter_fold<Seq, State const, F>(seq, state, f);
state,
seq,
f);
} }
template<typename Seq, typename State, typename F> template<typename Seq, typename State, typename F>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
@ -371,37 +137,28 @@ namespace boost { namespace fusion
>::type >::type
reverse_iter_fold(Seq const& seq, State const& state, F f) reverse_iter_fold(Seq const& seq, State const& state, F f)
{ {
return result_of::reverse_iter_fold<Seq const,State const,F>::call( return detail::reverse_iter_fold<Seq const, State const, F>(seq, state, f);
state,
seq,
f);
} }
template<typename Seq, typename State, typename F> template<typename Seq, typename State, typename F>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::reverse_iter_fold< inline typename result_of::reverse_iter_fold<
Seq Seq
, State const , State
, F , F
>::type >::type
reverse_iter_fold(Seq& seq, State& state, F f) reverse_iter_fold(Seq& seq, State& state, F f)
{ {
return result_of::reverse_iter_fold<Seq,State,F>::call( return detail::reverse_iter_fold<Seq, State, F>(seq, state, f);
state,
seq,
f);
} }
template<typename Seq, typename State, typename F> template<typename Seq, typename State, typename F>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::reverse_iter_fold< inline typename result_of::reverse_iter_fold<
Seq const Seq const
, State const , State
, F , F
>::type >::type
reverse_iter_fold(Seq const& seq, State& state, F f) reverse_iter_fold(Seq const& seq, State& state, F f)
{ {
return result_of::reverse_iter_fold<Seq const,State,F>::call( return detail::reverse_iter_fold<Seq const, State, F>(seq, state, f);
state,
seq,
f);
} }
}} }}

4
include/boost/fusion/container/deque/detail/cpp03/preprocessed/deque10.hpp
View File

@ -201,7 +201,9 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
{} {}
template<typename Sequence> template<typename Sequence>
BOOST_FUSION_GPU_ENABLED BOOST_FUSION_GPU_ENABLED
deque(Sequence const& seq, typename disable_if<is_convertible<Sequence, T0> >::type* = 0) deque(Sequence const& seq
, typename disable_if<is_convertible<Sequence, T0> >::type* = 0
, typename enable_if<traits::is_sequence<Sequence> >::type* = 0)
: base(base::from_iterator(fusion::begin(seq))) : base(base::from_iterator(fusion::begin(seq)))
{} {}
template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9> template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9>

4
include/boost/fusion/container/deque/detail/cpp03/preprocessed/deque20.hpp
View File

@ -381,7 +381,9 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
{} {}
template<typename Sequence> template<typename Sequence>
BOOST_FUSION_GPU_ENABLED BOOST_FUSION_GPU_ENABLED
deque(Sequence const& seq, typename disable_if<is_convertible<Sequence, T0> >::type* = 0) deque(Sequence const& seq
, typename disable_if<is_convertible<Sequence, T0> >::type* = 0
, typename enable_if<traits::is_sequence<Sequence> >::type* = 0)
: base(base::from_iterator(fusion::begin(seq))) : base(base::from_iterator(fusion::begin(seq)))
{} {}
template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9 , typename U10 , typename U11 , typename U12 , typename U13 , typename U14 , typename U15 , typename U16 , typename U17 , typename U18 , typename U19> template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9 , typename U10 , typename U11 , typename U12 , typename U13 , typename U14 , typename U15 , typename U16 , typename U17 , typename U18 , typename U19>

4
include/boost/fusion/container/deque/detail/cpp03/preprocessed/deque30.hpp
View File

@ -561,7 +561,9 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
{} {}
template<typename Sequence> template<typename Sequence>
BOOST_FUSION_GPU_ENABLED BOOST_FUSION_GPU_ENABLED
deque(Sequence const& seq, typename disable_if<is_convertible<Sequence, T0> >::type* = 0) deque(Sequence const& seq
, typename disable_if<is_convertible<Sequence, T0> >::type* = 0
, typename enable_if<traits::is_sequence<Sequence> >::type* = 0)
: base(base::from_iterator(fusion::begin(seq))) : base(base::from_iterator(fusion::begin(seq)))
{} {}
template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9 , typename U10 , typename U11 , typename U12 , typename U13 , typename U14 , typename U15 , typename U16 , typename U17 , typename U18 , typename U19 , typename U20 , typename U21 , typename U22 , typename U23 , typename U24 , typename U25 , typename U26 , typename U27 , typename U28 , typename U29> template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9 , typename U10 , typename U11 , typename U12 , typename U13 , typename U14 , typename U15 , typename U16 , typename U17 , typename U18 , typename U19 , typename U20 , typename U21 , typename U22 , typename U23 , typename U24 , typename U25 , typename U26 , typename U27 , typename U28 , typename U29>

4
include/boost/fusion/container/deque/detail/cpp03/preprocessed/deque40.hpp
View File

@ -741,7 +741,9 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
{} {}
template<typename Sequence> template<typename Sequence>
BOOST_FUSION_GPU_ENABLED BOOST_FUSION_GPU_ENABLED
deque(Sequence const& seq, typename disable_if<is_convertible<Sequence, T0> >::type* = 0) deque(Sequence const& seq
, typename disable_if<is_convertible<Sequence, T0> >::type* = 0
, typename enable_if<traits::is_sequence<Sequence> >::type* = 0)
: base(base::from_iterator(fusion::begin(seq))) : base(base::from_iterator(fusion::begin(seq)))
{} {}
template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9 , typename U10 , typename U11 , typename U12 , typename U13 , typename U14 , typename U15 , typename U16 , typename U17 , typename U18 , typename U19 , typename U20 , typename U21 , typename U22 , typename U23 , typename U24 , typename U25 , typename U26 , typename U27 , typename U28 , typename U29 , typename U30 , typename U31 , typename U32 , typename U33 , typename U34 , typename U35 , typename U36 , typename U37 , typename U38 , typename U39> template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9 , typename U10 , typename U11 , typename U12 , typename U13 , typename U14 , typename U15 , typename U16 , typename U17 , typename U18 , typename U19 , typename U20 , typename U21 , typename U22 , typename U23 , typename U24 , typename U25 , typename U26 , typename U27 , typename U28 , typename U29 , typename U30 , typename U31 , typename U32 , typename U33 , typename U34 , typename U35 , typename U36 , typename U37 , typename U38 , typename U39>

4
include/boost/fusion/container/deque/detail/cpp03/preprocessed/deque50.hpp
View File

@ -921,7 +921,9 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
{} {}
template<typename Sequence> template<typename Sequence>
BOOST_FUSION_GPU_ENABLED BOOST_FUSION_GPU_ENABLED
deque(Sequence const& seq, typename disable_if<is_convertible<Sequence, T0> >::type* = 0) deque(Sequence const& seq
, typename disable_if<is_convertible<Sequence, T0> >::type* = 0
, typename enable_if<traits::is_sequence<Sequence> >::type* = 0)
: base(base::from_iterator(fusion::begin(seq))) : base(base::from_iterator(fusion::begin(seq)))
{} {}
template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9 , typename U10 , typename U11 , typename U12 , typename U13 , typename U14 , typename U15 , typename U16 , typename U17 , typename U18 , typename U19 , typename U20 , typename U21 , typename U22 , typename U23 , typename U24 , typename U25 , typename U26 , typename U27 , typename U28 , typename U29 , typename U30 , typename U31 , typename U32 , typename U33 , typename U34 , typename U35 , typename U36 , typename U37 , typename U38 , typename U39 , typename U40 , typename U41 , typename U42 , typename U43 , typename U44 , typename U45 , typename U46 , typename U47 , typename U48 , typename U49> template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9 , typename U10 , typename U11 , typename U12 , typename U13 , typename U14 , typename U15 , typename U16 , typename U17 , typename U18 , typename U19 , typename U20 , typename U21 , typename U22 , typename U23 , typename U24 , typename U25 , typename U26 , typename U27 , typename U28 , typename U29 , typename U30 , typename U31 , typename U32 , typename U33 , typename U34 , typename U35 , typename U36 , typename U37 , typename U38 , typename U39 , typename U40 , typename U41 , typename U42 , typename U43 , typename U44 , typename U45 , typename U46 , typename U47 , typename U48 , typename U49>