[ceph.git] / ceph / src / boost / libs / fusion / include / boost / fusion / algorithm / iteration / detail / preprocessed / fold.hpp

/*=============================================================================
    Copyright (c) 2001-2011 Joel de Guzman
    Copyright (c) 2007 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)

    This is an auto-generated file. Do not edit!
==============================================================================*/
# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) void
# else
# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) typename T::type
# endif
namespace boost { namespace fusion
{
    namespace detail
    {
        template<int SeqSize, typename It, typename State, typename F, typename = void
# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
          
          , bool = SeqSize == 0
# endif
        >
        struct result_of_it_fold
        {};
        template<typename It, typename State, typename F>
        struct result_of_it_fold<0,It,State,F
          , typename boost::enable_if_has_type<BOOST_FUSION_FOLD_IMPL_ENABLER(State)>::type
# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
          , true
# endif
          >
        {
            typedef typename State::type type;
        };
        template<int SeqSize, typename It, typename State, typename F>
        struct result_of_it_fold<SeqSize,It,State,F
          , typename boost::enable_if_has_type<
# if BOOST_WORKAROUND (BOOST_MSVC, >= 1500)
                
                
                
                typename boost::disable_if_c<SeqSize == 0, State>::type::type
# else
                BOOST_FUSION_FOLD_IMPL_ENABLER(State)
# endif
            >::type
# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
          , false
# endif
          >
          : result_of_it_fold<
                SeqSize-1
              , typename result_of::next<It>::type
              , boost::result_of<
                    F(
                        typename add_reference<typename State::type>::type,
                        typename fusion::result_of::deref<It const>::type
                    )
                >
              , F
            >
        {};
        template<typename It, typename State, typename F>
        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
        inline typename result_of_it_fold<
            0
          , It
          , State
          , F
        >::type
        it_fold(mpl::int_<0>, It const&, typename State::type state, F&)
        {
            return state;
        }
        template<typename It, typename State, typename F, int SeqSize>
        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
        inline typename lazy_enable_if_c<
            SeqSize != 0
          , result_of_it_fold<
                SeqSize
              , It
              , State
              , F
            >
        >::type
        it_fold(mpl::int_<SeqSize>, It const& it, typename State::type state, F& f)
        {
            return it_fold<
                typename result_of::next<It>::type
              , boost::result_of<
                    F(
                        typename add_reference<typename State::type>::type,
                        typename fusion::result_of::deref<It const>::type
                    )
                >
              , F
            >(
                mpl::int_<SeqSize-1>()
              , fusion::next(it)
              , f(state, fusion::deref(it))
              , f
            );
        }
        template<typename Seq, typename State, typename F
          , bool = traits::is_sequence<Seq>::value
          , bool = traits::is_segmented<Seq>::value>
        struct result_of_fold
        {};
        template<typename Seq, typename State, typename F>
        struct result_of_fold<Seq, State, F, true, false>
          : result_of_it_fold<
                result_of::size<Seq>::value
              , typename result_of::begin<Seq>::type
              , add_reference<State>
              , F
            >
        {};
        template<typename Seq, typename State, typename F>
        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
        inline typename result_of_fold<Seq, State, F>::type
        fold(Seq& seq, State& state, F& f)
        {
            return it_fold<
                typename result_of::begin<Seq>::type
              , add_reference<State>
              , F
            >(
                typename result_of::size<Seq>::type()
              , fusion::begin(seq)
              , state
              , f
            );
        }
    }
    namespace result_of
    {
        template<typename Seq, typename State, typename F>
        struct fold
          : detail::result_of_fold<Seq, State, F>
        {};
    }
    template<typename Seq, typename State, typename F>
    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
    inline typename result_of::fold<
        Seq
      , State const
      , F
    >::type
    fold(Seq& seq, State const& state, F f)
    {
        return detail::fold<Seq, State const, F>(seq, state, f);
    }
    template<typename Seq, typename State, typename F>
    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
    inline typename result_of::fold<
        Seq const
      , State const
      , F
    >::type
    fold(Seq const& seq, State const& state, F f)
    {
        return detail::fold<Seq const, State const, F>(seq, state, f);
    }
    template<typename Seq, typename State, typename F>
    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
    inline typename result_of::fold<
        Seq
      , State
      , F
    >::type
    fold(Seq& seq, State& state, F f)
    {
        return detail::fold<Seq, State, F>(seq, state, f);
    }
    template<typename Seq, typename State, typename F>
    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
    inline typename result_of::fold<
        Seq const
      , State
      , F
    >::type
    fold(Seq const& seq, State& state, F f)
    {
        return detail::fold<Seq const, State, F>(seq, state, f);
    }
}}
Commit	Line	Data
7c673cae FG	1	/*=============================================================================
	2	Copyright (c) 2001-2011 Joel de Guzman
	3	Copyright (c) 2007 Dan Marsden
	4	Copyright (c) 2009-2010 Christopher Schmidt
	5
	6	Distributed under the Boost Software License, Version 1.0. (See accompanying
	7	file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
	8
	9	This is an auto-generated file. Do not edit!
	10	==============================================================================*/
	11	# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
	12	# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) void
	13	# else
	14	# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) typename T::type
	15	# endif
	16	namespace boost { namespace fusion
	17	{
	18	namespace detail
	19	{
	20	template<int SeqSize, typename It, typename State, typename F, typename = void
	21	# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
	22
	23	, bool = SeqSize == 0
	24	# endif
	25	>
	26	struct result_of_it_fold
	27	{};
	28	template<typename It, typename State, typename F>
	29	struct result_of_it_fold<0,It,State,F
	30	, typename boost::enable_if_has_type<BOOST_FUSION_FOLD_IMPL_ENABLER(State)>::type
	31	# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
	32	, true
	33	# endif
	34	>
	35	{
	36	typedef typename State::type type;
	37	};
	38	template<int SeqSize, typename It, typename State, typename F>
	39	struct result_of_it_fold<SeqSize,It,State,F
	40	, typename boost::enable_if_has_type<
	41	# if BOOST_WORKAROUND (BOOST_MSVC, >= 1500)
	42
	43
	44
	45	typename boost::disable_if_c<SeqSize == 0, State>::type::type
	46	# else
	47	BOOST_FUSION_FOLD_IMPL_ENABLER(State)
	48	# endif
	49	>::type
	50	# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
	51	, false
	52	# endif
	53	>
	54	: result_of_it_fold<
	55	SeqSize-1
	56	, typename result_of::next<It>::type
	57	, boost::result_of<
	58	F(
	59	typename add_reference<typename State::type>::type,
	60	typename fusion::result_of::deref<It const>::type
	61	)
	62	>
	63	, F
	64	>
65	{};
66	template<typename It, typename State, typename F>
67	BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
68	inline typename result_of_it_fold<
69	0
70	, It
71	, State
72	, F
73	>::type
74	it_fold(mpl::int_<0>, It const&, typename State::type state, F&)
75	{
76	return state;
77	}
78	template<typename It, typename State, typename F, int SeqSize>
79	BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
80	inline typename lazy_enable_if_c<
81	SeqSize != 0
82	, result_of_it_fold<
83	SeqSize
84	, It
85	, State
86	, F
87	>
88	>::type
89	it_fold(mpl::int_<SeqSize>, It const& it, typename State::type state, F& f)
90	{
91	return it_fold<
92	typename result_of::next<It>::type
93	, boost::result_of<
94	F(
95	typename add_reference<typename State::type>::type,
96	typename fusion::result_of::deref<It const>::type
97	)
98	>
99	, F
100	>(
101	mpl::int_<SeqSize-1>()
102	, fusion::next(it)
103	, f(state, fusion::deref(it))
104	, f
105	);
106	}
107	template<typename Seq, typename State, typename F
108	, bool = traits::is_sequence<Seq>::value
109	, bool = traits::is_segmented<Seq>::value>
110	struct result_of_fold
111	{};
112	template<typename Seq, typename State, typename F>
113	struct result_of_fold<Seq, State, F, true, false>
114	: result_of_it_fold<
115	result_of::size<Seq>::value
116	, typename result_of::begin<Seq>::type
117	, add_reference<State>
118	, F
119	>
120	{};
121	template<typename Seq, typename State, typename F>
122	BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
123	inline typename result_of_fold<Seq, State, F>::type
124	fold(Seq& seq, State& state, F& f)
125	{
126	return it_fold<
127	typename result_of::begin<Seq>::type
128	, add_reference<State>
129	, F
130	>(
131	typename result_of::size<Seq>::type()
132	, fusion::begin(seq)
133	, state
134	, f
135	);
136	}
137	}
138	namespace result_of
139	{
140	template<typename Seq, typename State, typename F>
141	struct fold
142	: detail::result_of_fold<Seq, State, F>
143	{};
144	}
145	template<typename Seq, typename State, typename F>
146	BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
147	inline typename result_of::fold<
148	Seq
149	, State const
150	, F
151	>::type
152	fold(Seq& seq, State const& state, F f)
153	{
154	return detail::fold<Seq, State const, F>(seq, state, f);
155	}
156	template<typename Seq, typename State, typename F>
157	BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
158	inline typename result_of::fold<
159	Seq const
160	, State const
161	, F
162	>::type
163	fold(Seq const& seq, State const& state, F f)
164	{
165	return detail::fold<Seq const, State const, F>(seq, state, f);
166	}
167	template<typename Seq, typename State, typename F>
168	BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
169	inline typename result_of::fold<
170	Seq
171	, State
172	, F
173	>::type
174	fold(Seq& seq, State& state, F f)
175	{
176	return detail::fold<Seq, State, F>(seq, state, f);
177	}
178	template<typename Seq, typename State, typename F>
179	BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
180	inline typename result_of::fold<
181	Seq const
182	, State
183	, F
184	>::type
185	fold(Seq const& seq, State& state, F f)
186	{
187	return detail::fold<Seq const, State, F>(seq, state, f);
188	}
189	}}