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 }}