inference-engine/thirdparty/clDNN/common/boost/1.64.0/include/boost-1_64/boost/proto/detail/preprocessed/and_n.hpp

   1     ///////////////////////////////////////////////////////////////////////////////
   2     /// \file and_n.hpp
   3     /// Definitions of and_N, and_impl
   4     //
   5     //  Copyright 2008 Eric Niebler. Distributed under the Boost
   6     //  Software License, Version 1.0. (See accompanying file
   7     //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   8
   9
  10
  11     template<bool B, typename P0>
  12     struct and_2
  13       : mpl::bool_<P0::value>
  14     {};
  15     template<typename P0>
  16     struct and_2<false, P0>
  17       : mpl::false_
  18     {};
  19         template<typename G0 , typename G1, typename Expr, typename State, typename Data>
  20         struct _and_impl<proto::and_<G0 , G1>, Expr, State, Data>
  21           : proto::transform_impl<Expr, State, Data>
  22         {
  23             typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1;
  24             typedef typename Gimpl1::result_type result_type;
  25             result_type operator()(
  26                 typename _and_impl::expr_param e
  27               , typename _and_impl::state_param s
  28               , typename _and_impl::data_param d
  29             ) const
  30             {
  31
  32
  33
  34
  35                 Gimpl0()(e,s,d);
  36                 return Gimpl1()(e,s,d);
  37             }
  38         };
  39
  40
  41
  42     template<bool B, typename P0 , typename P1>
  43     struct and_3
  44       : and_2<
  45             P0::value ,
  46             P1
  47         >
  48     {};
  49     template<typename P0 , typename P1>
  50     struct and_3<false, P0 , P1>
  51       : mpl::false_
  52     {};
  53         template<typename G0 , typename G1 , typename G2, typename Expr, typename State, typename Data>
  54         struct _and_impl<proto::and_<G0 , G1 , G2>, Expr, State, Data>
  55           : proto::transform_impl<Expr, State, Data>
  56         {
  57             typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2;
  58             typedef typename Gimpl2::result_type result_type;
  59             result_type operator()(
  60                 typename _and_impl::expr_param e
  61               , typename _and_impl::state_param s
  62               , typename _and_impl::data_param d
  63             ) const
  64             {
  65
  66
  67
  68
  69                 Gimpl0()(e,s,d); Gimpl1()(e,s,d);
  70                 return Gimpl2()(e,s,d);
  71             }
  72         };
  73
  74
  75
  76     template<bool B, typename P0 , typename P1 , typename P2>
  77     struct and_4
  78       : and_3<
  79             P0::value ,
  80             P1 , P2
  81         >
  82     {};
  83     template<typename P0 , typename P1 , typename P2>
  84     struct and_4<false, P0 , P1 , P2>
  85       : mpl::false_
  86     {};
  87         template<typename G0 , typename G1 , typename G2 , typename G3, typename Expr, typename State, typename Data>
  88         struct _and_impl<proto::and_<G0 , G1 , G2 , G3>, Expr, State, Data>
  89           : proto::transform_impl<Expr, State, Data>
  90         {
  91             typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3;
  92             typedef typename Gimpl3::result_type result_type;
  93             result_type operator()(
  94                 typename _and_impl::expr_param e
  95               , typename _and_impl::state_param s
  96               , typename _and_impl::data_param d
  97             ) const
  98             {
  99
 100
 101
 102
 103                 Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d);
 104                 return Gimpl3()(e,s,d);
 105             }
 106         };
 107
 108
 109
 110     template<bool B, typename P0 , typename P1 , typename P2 , typename P3>
 111     struct and_5
 112       : and_4<
 113             P0::value ,
 114             P1 , P2 , P3
 115         >
 116     {};
 117     template<typename P0 , typename P1 , typename P2 , typename P3>
 118     struct and_5<false, P0 , P1 , P2 , P3>
 119       : mpl::false_
 120     {};
 121         template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4, typename Expr, typename State, typename Data>
 122         struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4>, Expr, State, Data>
 123           : proto::transform_impl<Expr, State, Data>
 124         {
 125             typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4;
 126             typedef typename Gimpl4::result_type result_type;
 127             result_type operator()(
 128                 typename _and_impl::expr_param e
 129               , typename _and_impl::state_param s
 130               , typename _and_impl::data_param d
 131             ) const
 132             {
 133
 134
 135
 136
 137                 Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d);
 138                 return Gimpl4()(e,s,d);
 139             }
 140         };
 141
 142
 143
 144     template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4>
 145     struct and_6
 146       : and_5<
 147             P0::value ,
 148             P1 , P2 , P3 , P4
 149         >
 150     {};
 151     template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4>
 152     struct and_6<false, P0 , P1 , P2 , P3 , P4>
 153       : mpl::false_
 154     {};
 155         template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5, typename Expr, typename State, typename Data>
 156         struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5>, Expr, State, Data>
 157           : proto::transform_impl<Expr, State, Data>
 158         {
 159             typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5;
 160             typedef typename Gimpl5::result_type result_type;
 161             result_type operator()(
 162                 typename _and_impl::expr_param e
 163               , typename _and_impl::state_param s
 164               , typename _and_impl::data_param d
 165             ) const
 166             {
 167
 168
 169
 170
 171                 Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d);
 172                 return Gimpl5()(e,s,d);
 173             }
 174         };
 175
 176
 177
 178     template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5>
 179     struct and_7
 180       : and_6<
 181             P0::value ,
 182             P1 , P2 , P3 , P4 , P5
 183         >
 184     {};
 185     template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5>
 186     struct and_7<false, P0 , P1 , P2 , P3 , P4 , P5>
 187       : mpl::false_
 188     {};
 189         template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6, typename Expr, typename State, typename Data>
 190         struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6>, Expr, State, Data>
 191           : proto::transform_impl<Expr, State, Data>
 192         {
 193             typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6;
 194             typedef typename Gimpl6::result_type result_type;
 195             result_type operator()(
 196                 typename _and_impl::expr_param e
 197               , typename _and_impl::state_param s
 198               , typename _and_impl::data_param d
 199             ) const
 200             {
 201
 202
 203
 204
 205                 Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d);
 206                 return Gimpl6()(e,s,d);
 207             }
 208         };
 209
 210
 211
 212     template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6>
 213     struct and_8
 214       : and_7<
 215             P0::value ,
 216             P1 , P2 , P3 , P4 , P5 , P6
 217         >
 218     {};
 219     template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6>
 220     struct and_8<false, P0 , P1 , P2 , P3 , P4 , P5 , P6>
 221       : mpl::false_
 222     {};
 223         template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7, typename Expr, typename State, typename Data>
 224         struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7>, Expr, State, Data>
 225           : proto::transform_impl<Expr, State, Data>
 226         {
 227             typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6; typedef typename proto::when<proto::_, G7> ::template impl<Expr, State, Data> Gimpl7;
 228             typedef typename Gimpl7::result_type result_type;
 229             result_type operator()(
 230                 typename _and_impl::expr_param e
 231               , typename _and_impl::state_param s
 232               , typename _and_impl::data_param d
 233             ) const
 234             {
 235
 236
 237
 238
 239                 Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d); Gimpl6()(e,s,d);
 240                 return Gimpl7()(e,s,d);
 241             }
 242         };
 243
 244
 245
 246     template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7>
 247     struct and_9
 248       : and_8<
 249             P0::value ,
 250             P1 , P2 , P3 , P4 , P5 , P6 , P7
 251         >
 252     {};
 253     template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7>
 254     struct and_9<false, P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7>
 255       : mpl::false_
 256     {};
 257         template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8, typename Expr, typename State, typename Data>
 258         struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8>, Expr, State, Data>
 259           : proto::transform_impl<Expr, State, Data>
 260         {
 261             typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6; typedef typename proto::when<proto::_, G7> ::template impl<Expr, State, Data> Gimpl7; typedef typename proto::when<proto::_, G8> ::template impl<Expr, State, Data> Gimpl8;
 262             typedef typename Gimpl8::result_type result_type;
 263             result_type operator()(
 264                 typename _and_impl::expr_param e
 265               , typename _and_impl::state_param s
 266               , typename _and_impl::data_param d
 267             ) const
 268             {
 269
 270
 271
 272
 273                 Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d); Gimpl6()(e,s,d); Gimpl7()(e,s,d);
 274                 return Gimpl8()(e,s,d);
 275             }
 276         };
 277
 278
 279
 280     template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8>
 281     struct and_10
 282       : and_9<
 283             P0::value ,
 284             P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8
 285         >
 286     {};
 287     template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8>
 288     struct and_10<false, P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8>
 289       : mpl::false_
 290     {};
 291         template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9, typename Expr, typename State, typename Data>
 292         struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9>, Expr, State, Data>
 293           : proto::transform_impl<Expr, State, Data>
 294         {
 295             typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6; typedef typename proto::when<proto::_, G7> ::template impl<Expr, State, Data> Gimpl7; typedef typename proto::when<proto::_, G8> ::template impl<Expr, State, Data> Gimpl8; typedef typename proto::when<proto::_, G9> ::template impl<Expr, State, Data> Gimpl9;
 296             typedef typename Gimpl9::result_type result_type;
 297             result_type operator()(
 298                 typename _and_impl::expr_param e
 299               , typename _and_impl::state_param s
 300               , typename _and_impl::data_param d
 301             ) const
 302             {
 303
 304
 305
 306
 307                 Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d); Gimpl6()(e,s,d); Gimpl7()(e,s,d); Gimpl8()(e,s,d);
 308                 return Gimpl9()(e,s,d);
 309             }
 310         };