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

gpu-enable functions

Browse Source
This commit is contained in:
Eric Niebler
2014-01-09 17:58:06 -08:00
committed by Eric Niebler
parent 867c7e5dfb
commit c4f9f0d1b6
840 changed files with 7409 additions and 116 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -7,6 +7,7 @@
#if !defined(FUSION_ACCUMULATE_09172005_1032)
#define FUSION_ACCUMULATE_09172005_1032
#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>
@ -25,6 +26,7 @@ namespace boost { namespace fusion
}
template <typename Sequence, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
inline
typename
lazy_enable_if<
@ -37,6 +39,7 @@ namespace boost { namespace fusion
}
template <typename Sequence, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
inline
typename
lazy_enable_if<

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

@ -7,6 +7,7 @@
#if !defined(BOOST_FUSION_ACCUMULATE_FWD_HPP_INCLUDED)
#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>
@ -19,6 +20,7 @@ namespace boost { namespace fusion
}
template <typename Sequence, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
typename
lazy_enable_if<
traits::is_sequence<Sequence>
@ -27,6 +29,7 @@ namespace boost { namespace fusion
accumulate(Sequence& seq, State const& state, F f);
template <typename Sequence, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
typename
lazy_enable_if<
traits::is_sequence<Sequence>

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

@ -58,6 +58,7 @@ namespace boost { namespace fusion
struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)
{
template<typename State, typename It0, typename F>
BOOST_FUSION_GPU_ENABLED
static Result
call(State const& state,It0 const& it0,F f)
{
@ -103,6 +104,7 @@ namespace boost { namespace fusion
struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<Result,3>
{
template<typename State, typename It0, typename F>
BOOST_FUSION_GPU_ENABLED
static Result
call(State const& state,It0 const& it0,F f)
{
@ -133,6 +135,7 @@ namespace boost { namespace fusion
struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<Result,2>
{
template<typename State, typename It0, typename F>
BOOST_FUSION_GPU_ENABLED
static Result
call(State const& state,It0 const& it0,F f)
{
@ -150,6 +153,7 @@ namespace boost { namespace fusion
struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<Result,1>
{
template<typename State, typename It0, typename F>
BOOST_FUSION_GPU_ENABLED
static Result
call(State const& state,It0 const& it0,F f)
{
@ -162,6 +166,7 @@ namespace boost { namespace fusion
struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<Result,0>
{
template<typename State, typename It0, typename F>
BOOST_FUSION_GPU_ENABLED
static Result
call(State const& state,It0 const&, F)
{
@ -340,6 +345,7 @@ namespace boost { namespace fusion
>::type
type;
BOOST_FUSION_GPU_ENABLED
static type
call(StateRef state, Seq& seq, F f)
{
@ -363,6 +369,7 @@ namespace boost { namespace fusion
{
typedef StateRef type;
BOOST_FUSION_GPU_ENABLED
static StateRef
call(StateRef state, Seq&, F)
{
@ -397,6 +404,7 @@ namespace boost { namespace fusion
}
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
inline typename result_of::BOOST_FUSION_FOLD_NAME<
Seq
, State const
@ -411,6 +419,7 @@ namespace boost { namespace fusion
}
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
inline typename result_of::BOOST_FUSION_FOLD_NAME<
Seq const
, State const
@ -425,6 +434,7 @@ namespace boost { namespace fusion
}
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
inline typename result_of::BOOST_FUSION_FOLD_NAME<
Seq
, State const
@ -439,6 +449,7 @@ namespace boost { namespace fusion
}
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
inline typename result_of::BOOST_FUSION_FOLD_NAME<
Seq const
, State const

11
include/boost/fusion/algorithm/iteration/detail/for_each.hpp
View File

@ -7,6 +7,7 @@
#if !defined(FUSION_FOR_EACH_05052005_1028)
#define FUSION_FOR_EACH_05052005_1028
#include <boost/fusion/support/config.hpp>
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/iterator/equal_to.hpp>
@ -20,12 +21,14 @@ namespace boost { namespace fusion {
namespace detail
{
template <typename First, typename Last, typename F>
BOOST_FUSION_GPU_ENABLED
inline void
for_each_linear(First const&, Last const&, F const&, mpl::true_)
{
}
template <typename First, typename Last, typename F>
BOOST_FUSION_GPU_ENABLED
inline void
for_each_linear(First const& first, Last const& last, F const& f, mpl::false_)
{
@ -36,6 +39,7 @@ namespace detail
template <typename Sequence, typename F, typename Tag>
BOOST_FUSION_GPU_ENABLED
inline void
for_each_dispatch(Sequence& seq, F const& f, Tag)
{
@ -52,6 +56,7 @@ namespace detail
struct for_each_unrolled
{
template<typename I0, typename F>
BOOST_FUSION_GPU_ENABLED
static void call(I0 const& i0, F const& f)
{
f(*i0);
@ -72,6 +77,7 @@ namespace detail
struct for_each_unrolled<3>
{
template<typename I0, typename F>
BOOST_FUSION_GPU_ENABLED
static void call(I0 const& i0, F const& f)
{
f(*i0);
@ -88,6 +94,7 @@ namespace detail
struct for_each_unrolled<2>
{
template<typename I0, typename F>
BOOST_FUSION_GPU_ENABLED
static void call(I0 const& i0, F const& f)
{
f(*i0);
@ -101,6 +108,7 @@ namespace detail
struct for_each_unrolled<1>
{
template<typename I0, typename F>
BOOST_FUSION_GPU_ENABLED
static void call(I0 const& i0, F const& f)
{
f(*i0);
@ -111,12 +119,14 @@ namespace detail
struct for_each_unrolled<0>
{
template<typename It, typename F>
BOOST_FUSION_GPU_ENABLED
static void call(It const&, F const&)
{
}
};
template <typename Sequence, typename F>
BOOST_FUSION_GPU_ENABLED
inline void
for_each_dispatch(Sequence& seq, F const& f, random_access_traversal_tag)
{
@ -126,6 +136,7 @@ namespace detail
}
template <typename Sequence, typename F>
BOOST_FUSION_GPU_ENABLED
inline void
for_each(Sequence& seq, F const& f, mpl::false_) // unsegmented implementation
{

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

@ -24,6 +24,7 @@ namespace boost { namespace fusion
struct unrolled_fold
{
template<typename State, typename It0, typename F>
BOOST_FUSION_GPU_ENABLED
static Result
call(State const& state,It0 const& it0,F f)
{
@ -64,6 +65,7 @@ namespace boost { namespace fusion
struct unrolled_fold<Result,3>
{
template<typename State, typename It0, typename F>
BOOST_FUSION_GPU_ENABLED
static Result
call(State const& state,It0 const& it0,F f)
{
@ -90,6 +92,7 @@ namespace boost { namespace fusion
struct unrolled_fold<Result,2>
{
template<typename State, typename It0, typename F>
BOOST_FUSION_GPU_ENABLED
static Result
call(State const& state,It0 const& it0,F f)
{
@ -104,6 +107,7 @@ namespace boost { namespace fusion
struct unrolled_fold<Result,1>
{
template<typename State, typename It0, typename F>
BOOST_FUSION_GPU_ENABLED
static Result
call(State const& state,It0 const& it0,F f)
{
@ -115,6 +119,7 @@ namespace boost { namespace fusion
struct unrolled_fold<Result,0>
{
template<typename State, typename It0, typename F>
BOOST_FUSION_GPU_ENABLED
static Result
call(State const& state,It0 const&, F)
{
@ -277,6 +282,7 @@ namespace boost { namespace fusion
, SeqSize
>::type
type;
BOOST_FUSION_GPU_ENABLED
static type
call(StateRef state, Seq& seq, F f)
{
@ -296,6 +302,7 @@ namespace boost { namespace fusion
struct fold_impl<0,StateRef,Seq,F>
{
typedef StateRef type;
BOOST_FUSION_GPU_ENABLED
static StateRef
call(StateRef state, Seq&, F)
{
@ -327,6 +334,7 @@ namespace boost { namespace fusion
{};
}
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
inline typename result_of::fold<
Seq
, State const
@ -340,6 +348,7 @@ namespace boost { namespace fusion
f);
}
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
inline typename result_of::fold<
Seq const
, State const
@ -353,6 +362,7 @@ namespace boost { namespace fusion
f);
}
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
inline typename result_of::fold<
Seq
, State const
@ -366,6 +376,7 @@ namespace boost { namespace fusion
f);
}
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
inline typename result_of::fold<
Seq const
, State const

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

@ -23,6 +23,7 @@ namespace boost { namespace fusion
struct unrolled_iter_fold
{
template<typename State, typename It0, typename F>
BOOST_FUSION_GPU_ENABLED
static Result
call(State const& state,It0 const& it0,F f)
{
@ -63,6 +64,7 @@ namespace boost { namespace fusion
struct unrolled_iter_fold<Result,3>
{
template<typename State, typename It0, typename F>
BOOST_FUSION_GPU_ENABLED
static Result
call(State const& state,It0 const& it0,F f)
{
@ -89,6 +91,7 @@ namespace boost { namespace fusion
struct unrolled_iter_fold<Result,2>
{
template<typename State, typename It0, typename F>
BOOST_FUSION_GPU_ENABLED
static Result
call(State const& state,It0 const& it0,F f)
{
@ -103,6 +106,7 @@ namespace boost { namespace fusion
struct unrolled_iter_fold<Result,1>
{
template<typename State, typename It0, typename F>
BOOST_FUSION_GPU_ENABLED
static Result
call(State const& state,It0 const& it0,F f)
{
@ -114,6 +118,7 @@ namespace boost { namespace fusion
struct unrolled_iter_fold<Result,0>
{
template<typename State, typename It0, typename F>
BOOST_FUSION_GPU_ENABLED
static Result
call(State const& state,It0 const&, F)
{
@ -276,6 +281,7 @@ namespace boost { namespace fusion
, SeqSize
>::type
type;
BOOST_FUSION_GPU_ENABLED
static type
call(StateRef state, Seq& seq, F f)
{
@ -295,6 +301,7 @@ namespace boost { namespace fusion
struct iter_fold_impl<0,StateRef,Seq,F>
{
typedef StateRef type;
BOOST_FUSION_GPU_ENABLED
static StateRef
call(StateRef state, Seq&, F)
{
@ -326,6 +333,7 @@ namespace boost { namespace fusion
{};
}
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
inline typename result_of::iter_fold<
Seq
, State const
@ -339,6 +347,7 @@ namespace boost { namespace fusion
f);
}
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
inline typename result_of::iter_fold<
Seq const
, State const
@ -352,6 +361,7 @@ namespace boost { namespace fusion
f);
}
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
inline typename result_of::iter_fold<
Seq
, State const
@ -365,6 +375,7 @@ namespace boost { namespace fusion
f);
}
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
inline typename result_of::iter_fold<
Seq const
, State const

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

@ -23,6 +23,7 @@ namespace boost { namespace fusion
struct unrolled_reverse_fold
{
template<typename State, typename It0, typename F>
BOOST_FUSION_GPU_ENABLED
static Result
call(State const& state,It0 const& it0,F f)
{
@ -63,6 +64,7 @@ namespace boost { namespace fusion
struct unrolled_reverse_fold<Result,3>
{
template<typename State, typename It0, typename F>
BOOST_FUSION_GPU_ENABLED
static Result
call(State const& state,It0 const& it0,F f)
{
@ -89,6 +91,7 @@ namespace boost { namespace fusion
struct unrolled_reverse_fold<Result,2>
{
template<typename State, typename It0, typename F>
BOOST_FUSION_GPU_ENABLED
static Result
call(State const& state,It0 const& it0,F f)
{
@ -103,6 +106,7 @@ namespace boost { namespace fusion
struct unrolled_reverse_fold<Result,1>
{
template<typename State, typename It0, typename F>
BOOST_FUSION_GPU_ENABLED
static Result
call(State const& state,It0 const& it0,F f)
{
@ -114,6 +118,7 @@ namespace boost { namespace fusion
struct unrolled_reverse_fold<Result,0>
{
template<typename State, typename It0, typename F>
BOOST_FUSION_GPU_ENABLED
static Result
call(State const& state,It0 const&, F)
{
@ -276,6 +281,7 @@ namespace boost { namespace fusion
, SeqSize
>::type
type;
BOOST_FUSION_GPU_ENABLED
static type
call(StateRef state, Seq& seq, F f)
{
@ -295,6 +301,7 @@ namespace boost { namespace fusion
struct reverse_fold_impl<0,StateRef,Seq,F>
{
typedef StateRef type;
BOOST_FUSION_GPU_ENABLED
static StateRef
call(StateRef state, Seq&, F)
{
@ -326,6 +333,7 @@ namespace boost { namespace fusion
{};
}
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
inline typename result_of::reverse_fold<
Seq
, State const
@ -339,6 +347,7 @@ namespace boost { namespace fusion
f);
}
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
inline typename result_of::reverse_fold<
Seq const
, State const
@ -352,6 +361,7 @@ namespace boost { namespace fusion
f);
}
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
inline typename result_of::reverse_fold<
Seq
, State const
@ -365,6 +375,7 @@ namespace boost { namespace fusion
f);
}
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
inline typename result_of::reverse_fold<
Seq const
, State const

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

@ -23,6 +23,7 @@ namespace boost { namespace fusion
struct unrolled_reverse_iter_fold
{
template<typename State, typename It0, typename F>
BOOST_FUSION_GPU_ENABLED
static Result
call(State const& state,It0 const& it0,F f)
{
@ -63,6 +64,7 @@ namespace boost { namespace fusion
struct unrolled_reverse_iter_fold<Result,3>
{
template<typename State, typename It0, typename F>
BOOST_FUSION_GPU_ENABLED
static Result
call(State const& state,It0 const& it0,F f)
{
@ -89,6 +91,7 @@ namespace boost { namespace fusion
struct unrolled_reverse_iter_fold<Result,2>
{
template<typename State, typename It0, typename F>
BOOST_FUSION_GPU_ENABLED
static Result
call(State const& state,It0 const& it0,F f)
{
@ -103,6 +106,7 @@ namespace boost { namespace fusion
struct unrolled_reverse_iter_fold<Result,1>
{
template<typename State, typename It0, typename F>
BOOST_FUSION_GPU_ENABLED
static Result
call(State const& state,It0 const& it0,F f)
{
@ -114,6 +118,7 @@ namespace boost { namespace fusion
struct unrolled_reverse_iter_fold<Result,0>
{
template<typename State, typename It0, typename F>
BOOST_FUSION_GPU_ENABLED
static Result
call(State const& state,It0 const&, F)
{
@ -276,6 +281,7 @@ namespace boost { namespace fusion
, SeqSize
>::type
type;
BOOST_FUSION_GPU_ENABLED
static type
call(StateRef state, Seq& seq, F f)
{
@ -295,6 +301,7 @@ namespace boost { namespace fusion
struct reverse_iter_fold_impl<0,StateRef,Seq,F>
{
typedef StateRef type;
BOOST_FUSION_GPU_ENABLED
static StateRef
call(StateRef state, Seq&, F)
{
@ -326,6 +333,7 @@ namespace boost { namespace fusion
{};
}
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
inline typename result_of::reverse_iter_fold<
Seq
, State const
@ -339,6 +347,7 @@ namespace boost { namespace fusion
f);
}
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
inline typename result_of::reverse_iter_fold<
Seq const
, State const
@ -352,6 +361,7 @@ namespace boost { namespace fusion
f);
}
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
inline typename result_of::reverse_iter_fold<
Seq
, State const
@ -365,6 +375,7 @@ namespace boost { namespace fusion
f);
}
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
inline typename result_of::reverse_iter_fold<
Seq const
, State const

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

@ -7,6 +7,7 @@
#if !defined(BOOST_FUSION_FOLD_S_HPP_INCLUDED)
#define BOOST_FUSION_FOLD_S_HPP_INCLUDED
#include <boost/fusion/support/config.hpp>
#include <boost/fusion/algorithm/iteration/fold_fwd.hpp>
#include <boost/fusion/support/segmented_fold_until.hpp>
@ -15,6 +16,7 @@ namespace boost { namespace fusion { namespace detail
template <typename Fun>
struct segmented_fold_fun
{
BOOST_FUSION_GPU_ENABLED
explicit segmented_fold_fun(Fun const& f)
: fun(f)
{}
@ -27,6 +29,7 @@ namespace boost { namespace fusion { namespace detail
typedef typename result_of::fold<Sequence, State, Fun>::type type;
typedef mpl::true_ continue_type;
BOOST_FUSION_GPU_ENABLED
static type call(Sequence& seq, State const& state, Context const&, segmented_fold_fun const& fun)
{
return fusion::fold(seq, state, fun.fun);
@ -49,6 +52,7 @@ namespace boost { namespace fusion { namespace detail
>::type
type;
BOOST_FUSION_GPU_ENABLED
static type call(State& state, Sequence& seq, Fun fun)
{
return fusion::segmented_fold_until(seq, state, segmented_fold_fun<Fun>(fun));

4
include/boost/fusion/algorithm/iteration/detail/segmented_for_each.hpp
View File

@ -7,6 +7,7 @@
#if !defined(BOOST_FUSION_SEGMENTED_FOR_EACH_HPP_INCLUDED)
#define BOOST_FUSION_SEGMENTED_FOR_EACH_HPP_INCLUDED
#include <boost/fusion/support/config.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/fusion/support/void.hpp>
#include <boost/fusion/algorithm/iteration/for_each_fwd.hpp>
@ -17,6 +18,7 @@ namespace boost { namespace fusion { namespace detail
template <typename Fun>
struct segmented_for_each_fun
{
BOOST_FUSION_GPU_ENABLED
explicit segmented_for_each_fun(Fun const& f)
: fun(f)
{}
@ -29,6 +31,7 @@ namespace boost { namespace fusion { namespace detail
typedef void_ type;
typedef mpl::true_ continue_type;
BOOST_FUSION_GPU_ENABLED
static type call(Sequence& seq, State const&, Context const&, segmented_for_each_fun const& fun)
{
fusion::for_each(seq, fun.fun);
@ -38,6 +41,7 @@ namespace boost { namespace fusion { namespace detail
};
template <typename Sequence, typename F>
BOOST_FUSION_GPU_ENABLED
inline void
for_each(Sequence& seq, F const& f, mpl::true_) // segmented implementation
{

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

@ -9,6 +9,7 @@
#ifndef BOOST_FUSION_ALGORITHM_ITERATION_FOLD_HPP
#define BOOST_FUSION_ALGORITHM_ITERATION_FOLD_HPP
#include <boost/fusion/support/config.hpp>
#include <boost/fusion/algorithm/iteration/fold_fwd.hpp>
#include <boost/config.hpp>
#include <boost/fusion/sequence/intrinsic/begin.hpp>

4
include/boost/fusion/algorithm/iteration/fold_fwd.hpp
View File

@ -17,6 +17,7 @@ namespace boost { namespace fusion
}
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
typename result_of::fold<
Seq
, State const
@ -25,6 +26,7 @@ namespace boost { namespace fusion
fold(Seq& seq, State const& state, F f);
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
typename result_of::fold<
Seq const
, State const
@ -33,6 +35,7 @@ namespace boost { namespace fusion
fold(Seq const& seq, State const& state, F f);
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
typename result_of::fold<
Seq
, State const
@ -41,6 +44,7 @@ namespace boost { namespace fusion
fold(Seq& seq, State& state, F f);
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
typename result_of::fold<
Seq const
, State const

3
include/boost/fusion/algorithm/iteration/for_each.hpp
View File

@ -8,6 +8,7 @@
#if !defined(BOOST_FUSION_FOR_EACH_20070527_0943)
#define BOOST_FUSION_FOR_EACH_20070527_0943
#include <boost/fusion/support/config.hpp>
#include <boost/fusion/algorithm/iteration/detail/for_each.hpp>
#include <boost/fusion/algorithm/iteration/detail/segmented_for_each.hpp>
#include <boost/fusion/support/is_segmented.hpp>
@ -26,6 +27,7 @@ namespace boost { namespace fusion
}
template <typename Sequence, typename F>
BOOST_FUSION_GPU_ENABLED
inline
typename
enable_if<
@ -38,6 +40,7 @@ namespace boost { namespace fusion
}
template <typename Sequence, typename F>
BOOST_FUSION_GPU_ENABLED
inline
typename
enable_if<

3
include/boost/fusion/algorithm/iteration/for_each_fwd.hpp
View File

@ -7,6 +7,7 @@
#if !defined(BOOST_FUSION_FOR_EACH_FWD_HPP_INCLUDED)
#define BOOST_FUSION_FOR_EACH_FWD_HPP_INCLUDED
#include <boost/fusion/support/config.hpp>
#include <boost/fusion/support/is_sequence.hpp>
#include <boost/utility/enable_if.hpp>
@ -19,6 +20,7 @@ namespace boost { namespace fusion
}
template <typename Sequence, typename F>
BOOST_FUSION_GPU_ENABLED
inline
typename
enable_if<
@ -28,6 +30,7 @@ namespace boost { namespace fusion
for_each(Sequence& seq, F const& f);
template <typename Sequence, typename F>
BOOST_FUSION_GPU_ENABLED
inline
typename
enable_if<

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

@ -9,6 +9,7 @@
#ifndef BOOST_FUSION_ALGORITHM_ITERATION_ITER_FOLD_HPP
#define BOOST_FUSION_ALGORITHM_ITERATION_ITER_FOLD_HPP
#include <boost/fusion/support/config.hpp>
#include <boost/fusion/algorithm/iteration/iter_fold_fwd.hpp>
#include <boost/config.hpp>
#include <boost/fusion/sequence/intrinsic/begin.hpp>

4
include/boost/fusion/algorithm/iteration/iter_fold_fwd.hpp
View File

@ -17,6 +17,7 @@ namespace boost { namespace fusion
}
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
typename result_of::iter_fold<
Seq
, State const
@ -25,6 +26,7 @@ namespace boost { namespace fusion
iter_fold(Seq& seq, State const& state, F f);
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
typename result_of::iter_fold<
Seq const
, State const
@ -33,6 +35,7 @@ namespace boost { namespace fusion
iter_fold(Seq const& seq, State const& state, F f);
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
typename result_of::iter_fold<
Seq
, State const
@ -41,6 +44,7 @@ namespace boost { namespace fusion
iter_fold(Seq& seq, State& state, F f);
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
typename result_of::iter_fold<
Seq const
, State const

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

@ -9,6 +9,7 @@
#ifndef BOOST_FUSION_ALGORITHM_ITERATION_REVERSE_FOLD_HPP
#define BOOST_FUSION_ALGORITHM_ITERATION_REVERSE_FOLD_HPP
#include <boost/fusion/support/config.hpp>
#include <boost/fusion/algorithm/iteration/reverse_fold_fwd.hpp>
#include <boost/config.hpp>
#include <boost/fusion/sequence/intrinsic/begin.hpp>

4
include/boost/fusion/algorithm/iteration/reverse_fold_fwd.hpp
View File

@ -17,6 +17,7 @@ namespace boost { namespace fusion
}
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
typename result_of::reverse_fold<
Seq
, State const
@ -25,6 +26,7 @@ namespace boost { namespace fusion
reverse_fold(Seq& seq, State const& state, F f);
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
typename result_of::reverse_fold<
Seq const
, State const
@ -33,6 +35,7 @@ namespace boost { namespace fusion
reverse_fold(Seq const& seq, State const& state, F f);
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
typename result_of::reverse_fold<
Seq
, State const
@ -41,6 +44,7 @@ namespace boost { namespace fusion
reverse_fold(Seq& seq, State& state, F f);
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
typename result_of::reverse_fold<
Seq const
, State const

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

@ -8,6 +8,7 @@
#ifndef BOOST_FUSION_ALGORITHM_ITERATION_REVERSE_ITER_FOLD_HPP
#define BOOST_FUSION_ALGORITHM_ITERATION_REVERSE_ITER_FOLD_HPP
#include <boost/fusion/support/config.hpp>
#include <boost/fusion/algorithm/iteration/reverse_iter_fold_fwd.hpp>
#include <boost/config.hpp>
#include <boost/fusion/sequence/intrinsic/begin.hpp>

4
include/boost/fusion/algorithm/iteration/reverse_iter_fold_fwd.hpp
View File

@ -17,6 +17,7 @@ namespace boost { namespace fusion
}
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
typename result_of::reverse_iter_fold<
Seq
, State const
@ -25,6 +26,7 @@ namespace boost { namespace fusion
reverse_iter_fold(Seq& seq, State const& state, F f);
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
typename result_of::reverse_iter_fold<
Seq const
, State const
@ -33,6 +35,7 @@ namespace boost { namespace fusion
reverse_iter_fold(Seq const& seq, State const& state, F f);
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
typename result_of::reverse_iter_fold<
Seq
, State const
@ -41,6 +44,7 @@ namespace boost { namespace fusion
reverse_iter_fold(Seq& seq, State& state, F f);
template<typename Seq, typename State, typename F>
BOOST_FUSION_GPU_ENABLED
typename result_of::reverse_iter_fold<
Seq const
, State const