Publishing R3
[platform/upstream/dldt.git] / inference-engine / thirdparty / clDNN / common / boost / 1.64.0 / include / boost-1_64 / boost / fusion / algorithm / iteration / detail / preprocessed / fold.hpp
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 }}