You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
462 lines
16 KiB
462 lines
16 KiB
/*============================================================================= |
|
Copyright (c) 2001-2011 Joel de Guzman |
|
Copyright (c) 2006 Dan Marsden |
|
Copyright (c) 2009-2010 Christopher Schmidt |
|
|
|
Distributed under the Boost Software License, Version 1.0. (See accompanying |
|
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) |
|
==============================================================================*/ |
|
#include <boost/preprocessor/cat.hpp> |
|
|
|
#ifdef BOOST_FUSION_REVERSE_FOLD |
|
# ifdef BOOST_FUSION_ITER_FOLD |
|
# define BOOST_FUSION_FOLD_NAME reverse_iter_fold |
|
# else |
|
# define BOOST_FUSION_FOLD_NAME reverse_fold |
|
# endif |
|
|
|
# define BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION end |
|
# define BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION prior |
|
# define BOOST_FUSION_FOLD_IMPL_FIRST_IT_META_TRANSFORM(IT) \ |
|
typename fusion::result_of::prior<IT>::type |
|
# define BOOST_FUSION_FOLD_IMPL_FIRST_IT_TRANSFORM(IT) fusion::prior(IT) |
|
#else |
|
# ifdef BOOST_FUSION_ITER_FOLD |
|
# define BOOST_FUSION_FOLD_NAME iter_fold |
|
# else |
|
# define BOOST_FUSION_FOLD_NAME fold |
|
# endif |
|
|
|
# define BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION begin |
|
# define BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION next |
|
# define BOOST_FUSION_FOLD_IMPL_FIRST_IT_META_TRANSFORM(IT) IT |
|
# define BOOST_FUSION_FOLD_IMPL_FIRST_IT_TRANSFORM(IT) IT |
|
#endif |
|
#ifdef BOOST_FUSION_ITER_FOLD |
|
# define BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM(IT) IT& |
|
# define BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(IT) IT |
|
#else |
|
# define BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM(IT) \ |
|
typename fusion::result_of::deref<IT>::type |
|
# define BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(IT) fusion::deref(IT) |
|
#endif |
|
|
|
namespace boost { namespace fusion |
|
{ |
|
namespace detail |
|
{ |
|
template<typename State, typename It, typename F> |
|
struct BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state) |
|
: boost::result_of< |
|
F( |
|
typename add_reference<typename add_const<State>::type>::type, |
|
BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM(It)) |
|
> |
|
{}; |
|
|
|
template<typename Result,int N> |
|
struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME) |
|
{ |
|
template<typename State, typename It0, typename F> |
|
static Result |
|
call(State const& state,It0 const& it0,F f) |
|
{ |
|
typedef typename |
|
result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION< |
|
It0 const |
|
>::type |
|
It1; |
|
It1 it1 = fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it0); |
|
typedef typename |
|
result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION< |
|
It1 |
|
>::type |
|
It2; |
|
It2 it2 = fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it1); |
|
typedef typename |
|
result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION< |
|
It2 |
|
>::type |
|
It3; |
|
It3 it3 = fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it2); |
|
|
|
typedef typename BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<State,It0,F>::type State1; |
|
State1 const state1=f(state,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it0)); |
|
|
|
typedef typename BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<State1,It1,F>::type State2; |
|
State2 const state2=f(state1,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it1)); |
|
|
|
typedef typename BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<State2,It2,F>::type State3; |
|
State3 const state3=f(state2,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it2)); |
|
|
|
return BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)< |
|
Result |
|
, N-4 |
|
>::call( |
|
f(state3,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it3)), |
|
fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it3), |
|
f); |
|
} |
|
}; |
|
|
|
template<typename Result> |
|
struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<Result,3> |
|
{ |
|
template<typename State, typename It0, typename F> |
|
static Result |
|
call(State const& state,It0 const& it0,F f) |
|
{ |
|
typedef typename |
|
result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION< |
|
It0 const |
|
>::type |
|
It1; |
|
It1 it1 = fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it0); |
|
typedef typename |
|
result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION< |
|
It1 |
|
>::type |
|
It2; |
|
It2 it2 = fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it1); |
|
|
|
typedef typename BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<State,It0,F>::type State1; |
|
State1 const state1=f(state,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it0)); |
|
|
|
typedef typename BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<State1,It1,F>::type State2; |
|
State2 const state2=f(state1,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it1)); |
|
|
|
return f(state2,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it2)); |
|
} |
|
}; |
|
|
|
template<typename Result> |
|
struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<Result,2> |
|
{ |
|
template<typename State, typename It0, typename F> |
|
static Result |
|
call(State const& state,It0 const& it0,F f) |
|
{ |
|
typedef typename BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<State,It0,F>::type State1; |
|
State1 const state1=f(state,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it0)); |
|
|
|
return f( |
|
state1, |
|
BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM( |
|
fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it0))); |
|
} |
|
}; |
|
|
|
template<typename Result> |
|
struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<Result,1> |
|
{ |
|
template<typename State, typename It0, typename F> |
|
static Result |
|
call(State const& state,It0 const& it0,F f) |
|
{ |
|
return f(state, |
|
BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it0)); |
|
} |
|
}; |
|
|
|
template<typename Result> |
|
struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<Result,0> |
|
{ |
|
template<typename State, typename It0, typename F> |
|
static Result |
|
call(State const& state,It0 const& it0, F) |
|
{ |
|
return static_cast<Result>(state); |
|
} |
|
}; |
|
|
|
template<typename StateRef, typename It0, typename F, int N> |
|
struct BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME) |
|
{ |
|
typedef typename |
|
BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)< |
|
StateRef |
|
, It0 const |
|
, F |
|
>::type |
|
rest1; |
|
typedef typename |
|
result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION< |
|
It0 const |
|
>::type |
|
it1; |
|
typedef typename |
|
BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)< |
|
rest1 |
|
, it1 |
|
, F |
|
>::type |
|
rest2; |
|
typedef typename |
|
result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<it1>::type |
|
it2; |
|
typedef typename |
|
BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)< |
|
rest2 |
|
, it2 |
|
, F |
|
>::type |
|
rest3; |
|
typedef typename |
|
result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<it2>::type |
|
it3; |
|
|
|
typedef typename |
|
BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)< |
|
typename BOOST_PP_CAT( |
|
BOOST_FUSION_FOLD_NAME, _lvalue_state)< |
|
rest3 |
|
, it3 |
|
, F |
|
>::type |
|
, typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION< |
|
it3 |
|
>::type |
|
, F |
|
, N-4 |
|
>::type |
|
type; |
|
}; |
|
|
|
template<typename StateRef, typename It0, typename F> |
|
struct BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)< |
|
StateRef |
|
, It0 |
|
, F |
|
, 3 |
|
> |
|
{ |
|
typedef typename |
|
BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)< |
|
StateRef |
|
, It0 const |
|
, F |
|
>::type |
|
rest1; |
|
typedef typename |
|
result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION< |
|
It0 const |
|
>::type |
|
it1; |
|
|
|
typedef typename |
|
BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)< |
|
typename BOOST_PP_CAT( |
|
BOOST_FUSION_FOLD_NAME, _lvalue_state)< |
|
rest1 |
|
, it1 |
|
, F |
|
>::type |
|
, typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION< |
|
it1 const |
|
>::type const |
|
, F |
|
>::type |
|
type; |
|
}; |
|
|
|
template<typename StateRef, typename It0, typename F> |
|
struct BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)< |
|
StateRef |
|
, It0 |
|
, F |
|
, 2 |
|
> |
|
: BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)< |
|
typename BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)< |
|
StateRef |
|
, It0 const |
|
, F |
|
>::type |
|
, typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION< |
|
It0 const |
|
>::type const |
|
, F |
|
> |
|
{}; |
|
|
|
template<typename StateRef, typename It0, typename F> |
|
struct BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)< |
|
StateRef |
|
, It0 |
|
, F |
|
, 1 |
|
> |
|
: BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)< |
|
StateRef |
|
, It0 const |
|
, F |
|
> |
|
{}; |
|
|
|
template<typename StateRef, typename It0, typename F> |
|
struct BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)< |
|
StateRef |
|
, It0 |
|
, F |
|
, 0 |
|
> |
|
{ |
|
typedef StateRef type; |
|
}; |
|
|
|
template<typename StateRef, typename It0, typename F, int SeqSize> |
|
struct BOOST_PP_CAT(result_of_first_unrolled,BOOST_FUSION_FOLD_NAME) |
|
{ |
|
typedef typename |
|
BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)< |
|
typename boost::result_of< |
|
F( |
|
StateRef, |
|
BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM( |
|
It0 const) |
|
) |
|
>::type |
|
, typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION< |
|
It0 const |
|
>::type |
|
, F |
|
, SeqSize-1 |
|
>::type |
|
type; |
|
}; |
|
|
|
template<int SeqSize, typename StateRef, typename Seq, typename F> |
|
struct BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME,_impl) |
|
{ |
|
typedef typename |
|
BOOST_PP_CAT( |
|
result_of_first_unrolled,BOOST_FUSION_FOLD_NAME)< |
|
StateRef |
|
, BOOST_FUSION_FOLD_IMPL_FIRST_IT_META_TRANSFORM( |
|
typename result_of::BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION<Seq>::type |
|
) |
|
, F |
|
, SeqSize |
|
>::type |
|
type; |
|
|
|
static type |
|
call(StateRef state, Seq& seq, F f) |
|
{ |
|
typedef |
|
BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)< |
|
type |
|
, SeqSize |
|
> |
|
unrolled_impl; |
|
|
|
return unrolled_impl::call( |
|
state, |
|
BOOST_FUSION_FOLD_IMPL_FIRST_IT_TRANSFORM( |
|
fusion::BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION(seq)), |
|
f); |
|
} |
|
}; |
|
|
|
template<typename StateRef, typename Seq, typename F> |
|
struct BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME,_impl)<0,StateRef,Seq,F> |
|
{ |
|
typedef StateRef type; |
|
|
|
static StateRef |
|
call(StateRef state, Seq&, F) |
|
{ |
|
return static_cast<StateRef>(state); |
|
} |
|
}; |
|
|
|
template<typename Seq, typename State, typename F, bool IsSegmented> |
|
struct BOOST_PP_CAT(result_of_, BOOST_FUSION_FOLD_NAME) |
|
: BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME,_impl)< |
|
result_of::size<Seq>::value |
|
, typename add_reference< |
|
typename add_const<State>::type |
|
>::type |
|
, Seq |
|
, F |
|
> |
|
{}; |
|
} |
|
|
|
namespace result_of |
|
{ |
|
template<typename Seq, typename State, typename F> |
|
struct BOOST_FUSION_FOLD_NAME |
|
: detail::BOOST_PP_CAT(result_of_, BOOST_FUSION_FOLD_NAME)< |
|
Seq |
|
, State |
|
, F |
|
, traits::is_segmented<Seq>::type::value |
|
> |
|
{}; |
|
} |
|
|
|
template<typename Seq, typename State, typename F> |
|
inline typename result_of::BOOST_FUSION_FOLD_NAME< |
|
Seq |
|
, State const |
|
, F |
|
>::type |
|
BOOST_FUSION_FOLD_NAME(Seq& seq, State const& state, F f) |
|
{ |
|
return result_of::BOOST_FUSION_FOLD_NAME<Seq,State const,F>::call( |
|
state, |
|
seq, |
|
f); |
|
} |
|
|
|
template<typename Seq, typename State, typename F> |
|
inline typename result_of::BOOST_FUSION_FOLD_NAME< |
|
Seq const |
|
, State const |
|
, F |
|
>::type |
|
BOOST_FUSION_FOLD_NAME(Seq const& seq, State const& state, F f) |
|
{ |
|
return result_of::BOOST_FUSION_FOLD_NAME<Seq const,State const,F>::call( |
|
state, |
|
seq, |
|
f); |
|
} |
|
|
|
template<typename Seq, typename State, typename F> |
|
inline typename result_of::BOOST_FUSION_FOLD_NAME< |
|
Seq |
|
, State const |
|
, F |
|
>::type |
|
BOOST_FUSION_FOLD_NAME(Seq& seq, State& state, F f) |
|
{ |
|
return result_of::BOOST_FUSION_FOLD_NAME<Seq,State,F>::call( |
|
state, |
|
seq, |
|
f); |
|
} |
|
|
|
template<typename Seq, typename State, typename F> |
|
inline typename result_of::BOOST_FUSION_FOLD_NAME< |
|
Seq const |
|
, State const |
|
, F |
|
>::type |
|
BOOST_FUSION_FOLD_NAME(Seq const& seq, State& state, F f) |
|
{ |
|
return result_of::BOOST_FUSION_FOLD_NAME<Seq const,State,F>::call( |
|
state, |
|
seq, |
|
f); |
|
} |
|
}} |
|
|
|
#undef BOOST_FUSION_FOLD_NAME |
|
#undef BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION |
|
#undef BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION |
|
#undef BOOST_FUSION_FOLD_IMPL_FIRST_IT_META_TRANSFORM |
|
#undef BOOST_FUSION_FOLD_IMPL_FIRST_IT_TRANSFORM |
|
#undef BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM |
|
#undef BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM
|
|
|