detail/preprocessed/and_n.hpp

0001     ///////////////////////////////////////////////////////////////////////////////
0002     /// \file and_n.hpp
0003     /// Definitions of and_N, and_impl
0004     //
0005     //  Copyright 2008 Eric Niebler. Distributed under the Boost
0006     //  Software License, Version 1.0. (See accompanying file
0007     //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0008
0009
0010
0011     template<bool B, typename P0>
0012     struct and_2
0013       : mpl::bool_<P0::value>
0014     {};
0015     template<typename P0>
0016     struct and_2<false, P0>
0017       : mpl::false_
0018     {};
0019         template<typename G0 , typename G1, typename Expr, typename State, typename Data>
0020         struct _and_impl<proto::and_<G0 , G1>, Expr, State, Data>
0021           : proto::transform_impl<Expr, State, Data>
0022         {
0023             typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1;
0024             typedef typename Gimpl1::result_type result_type;
0025             result_type operator()(
0026                 typename _and_impl::expr_param e
0027               , typename _and_impl::state_param s
0028               , typename _and_impl::data_param d
0029             ) const
0030             {
0031
0032
0033
0034
0035                 Gimpl0()(e,s,d);
0036                 return Gimpl1()(e,s,d);
0037             }
0038         };
0039
0040
0041
0042     template<bool B, typename P0 , typename P1>
0043     struct and_3
0044       : and_2<
0045             P0::value ,
0046             P1
0047         >
0048     {};
0049     template<typename P0 , typename P1>
0050     struct and_3<false, P0 , P1>
0051       : mpl::false_
0052     {};
0053         template<typename G0 , typename G1 , typename G2, typename Expr, typename State, typename Data>
0054         struct _and_impl<proto::and_<G0 , G1 , G2>, Expr, State, Data>
0055           : proto::transform_impl<Expr, State, Data>
0056         {
0057             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;
0058             typedef typename Gimpl2::result_type result_type;
0059             result_type operator()(
0060                 typename _and_impl::expr_param e
0061               , typename _and_impl::state_param s
0062               , typename _and_impl::data_param d
0063             ) const
0064             {
0065
0066
0067
0068
0069                 Gimpl0()(e,s,d); Gimpl1()(e,s,d);
0070                 return Gimpl2()(e,s,d);
0071             }
0072         };
0073
0074
0075
0076     template<bool B, typename P0 , typename P1 , typename P2>
0077     struct and_4
0078       : and_3<
0079             P0::value ,
0080             P1 , P2
0081         >
0082     {};
0083     template<typename P0 , typename P1 , typename P2>
0084     struct and_4<false, P0 , P1 , P2>
0085       : mpl::false_
0086     {};
0087         template<typename G0 , typename G1 , typename G2 , typename G3, typename Expr, typename State, typename Data>
0088         struct _and_impl<proto::and_<G0 , G1 , G2 , G3>, Expr, State, Data>
0089           : proto::transform_impl<Expr, State, Data>
0090         {
0091             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;
0092             typedef typename Gimpl3::result_type result_type;
0093             result_type operator()(
0094                 typename _and_impl::expr_param e
0095               , typename _and_impl::state_param s
0096               , typename _and_impl::data_param d
0097             ) const
0098             {
0099
0100
0101
0102
0103                 Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d);
0104                 return Gimpl3()(e,s,d);
0105             }
0106         };
0107
0108
0109
0110     template<bool B, typename P0 , typename P1 , typename P2 , typename P3>
0111     struct and_5
0112       : and_4<
0113             P0::value ,
0114             P1 , P2 , P3
0115         >
0116     {};
0117     template<typename P0 , typename P1 , typename P2 , typename P3>
0118     struct and_5<false, P0 , P1 , P2 , P3>
0119       : mpl::false_
0120     {};
0121         template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4, typename Expr, typename State, typename Data>
0122         struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4>, Expr, State, Data>
0123           : proto::transform_impl<Expr, State, Data>
0124         {
0125             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;
0126             typedef typename Gimpl4::result_type result_type;
0127             result_type operator()(
0128                 typename _and_impl::expr_param e
0129               , typename _and_impl::state_param s
0130               , typename _and_impl::data_param d
0131             ) const
0132             {
0133
0134
0135
0136
0137                 Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d);
0138                 return Gimpl4()(e,s,d);
0139             }
0140         };
0141
0142
0143
0144     template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4>
0145     struct and_6
0146       : and_5<
0147             P0::value ,
0148             P1 , P2 , P3 , P4
0149         >
0150     {};
0151     template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4>
0152     struct and_6<false, P0 , P1 , P2 , P3 , P4>
0153       : mpl::false_
0154     {};
0155         template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5, typename Expr, typename State, typename Data>
0156         struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5>, Expr, State, Data>
0157           : proto::transform_impl<Expr, State, Data>
0158         {
0159             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;
0160             typedef typename Gimpl5::result_type result_type;
0161             result_type operator()(
0162                 typename _and_impl::expr_param e
0163               , typename _and_impl::state_param s
0164               , typename _and_impl::data_param d
0165             ) const
0166             {
0167
0168
0169
0170
0171                 Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d);
0172                 return Gimpl5()(e,s,d);
0173             }
0174         };
0175
0176
0177
0178     template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5>
0179     struct and_7
0180       : and_6<
0181             P0::value ,
0182             P1 , P2 , P3 , P4 , P5
0183         >
0184     {};
0185     template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5>
0186     struct and_7<false, P0 , P1 , P2 , P3 , P4 , P5>
0187       : mpl::false_
0188     {};
0189         template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6, typename Expr, typename State, typename Data>
0190         struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6>, Expr, State, Data>
0191           : proto::transform_impl<Expr, State, Data>
0192         {
0193             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;
0194             typedef typename Gimpl6::result_type result_type;
0195             result_type operator()(
0196                 typename _and_impl::expr_param e
0197               , typename _and_impl::state_param s
0198               , typename _and_impl::data_param d
0199             ) const
0200             {
0201
0202
0203
0204
0205                 Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d);
0206                 return Gimpl6()(e,s,d);
0207             }
0208         };
0209
0210
0211
0212     template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6>
0213     struct and_8
0214       : and_7<
0215             P0::value ,
0216             P1 , P2 , P3 , P4 , P5 , P6
0217         >
0218     {};
0219     template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6>
0220     struct and_8<false, P0 , P1 , P2 , P3 , P4 , P5 , P6>
0221       : mpl::false_
0222     {};
0223         template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7, typename Expr, typename State, typename Data>
0224         struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7>, Expr, State, Data>
0225           : proto::transform_impl<Expr, State, Data>
0226         {
0227             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;
0228             typedef typename Gimpl7::result_type result_type;
0229             result_type operator()(
0230                 typename _and_impl::expr_param e
0231               , typename _and_impl::state_param s
0232               , typename _and_impl::data_param d
0233             ) const
0234             {
0235
0236
0237
0238
0239                 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);
0240                 return Gimpl7()(e,s,d);
0241             }
0242         };
0243
0244
0245
0246     template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7>
0247     struct and_9
0248       : and_8<
0249             P0::value ,
0250             P1 , P2 , P3 , P4 , P5 , P6 , P7
0251         >
0252     {};
0253     template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7>
0254     struct and_9<false, P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7>
0255       : mpl::false_
0256     {};
0257         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>
0258         struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8>, Expr, State, Data>
0259           : proto::transform_impl<Expr, State, Data>
0260         {
0261             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;
0262             typedef typename Gimpl8::result_type result_type;
0263             result_type operator()(
0264                 typename _and_impl::expr_param e
0265               , typename _and_impl::state_param s
0266               , typename _and_impl::data_param d
0267             ) const
0268             {
0269
0270
0271
0272
0273                 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);
0274                 return Gimpl8()(e,s,d);
0275             }
0276         };
0277
0278
0279
0280     template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8>
0281     struct and_10
0282       : and_9<
0283             P0::value ,
0284             P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8
0285         >
0286     {};
0287     template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8>
0288     struct and_10<false, P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8>
0289       : mpl::false_
0290     {};
0291         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>
0292         struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9>, Expr, State, Data>
0293           : proto::transform_impl<Expr, State, Data>
0294         {
0295             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;
0296             typedef typename Gimpl9::result_type result_type;
0297             result_type operator()(
0298                 typename _and_impl::expr_param e
0299               , typename _and_impl::state_param s
0300               , typename _and_impl::data_param d
0301             ) const
0302             {
0303
0304
0305
0306
0307                 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);
0308                 return Gimpl9()(e,s,d);
0309             }
0310         };