ceph/src/boost/libs/fusion/include/boost/fusion/algorithm/iteration/detail/preprocessed/reverse_iter_fold.hpp

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