cpp03/preprocessed/function_ptr_10.hpp

0001 /*=============================================================================
0002     Copyright (c) 2001-2007 Joel de Guzman
0003
0004     Distributed under the Boost Software License, Version 1.0. (See accompanying
0005     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0006 ==============================================================================*/
0007
0008
0009
0010
0011
0012
0013
0014     template <typename Dummy>
0015     struct function_ptr_impl<2, Dummy>
0016     {
0017         template <typename RT, typename FP>
0018         struct impl
0019         {
0020             typedef RT result_type;
0021             impl(FP fp_)
0022                 : fp(fp_) {}
0023             template <typename A0 , typename A1>
0024             RT operator()(A0 & a0 , A1 & a1) const
0025             {
0026                 return fp(a0 , a1);
0027             }
0028             FP fp;
0029         };
0030     };
0031
0032
0033
0034
0035
0036
0037
0038     template <typename Dummy>
0039     struct function_ptr_impl<3, Dummy>
0040     {
0041         template <typename RT, typename FP>
0042         struct impl
0043         {
0044             typedef RT result_type;
0045             impl(FP fp_)
0046                 : fp(fp_) {}
0047             template <typename A0 , typename A1 , typename A2>
0048             RT operator()(A0 & a0 , A1 & a1 , A2 & a2) const
0049             {
0050                 return fp(a0 , a1 , a2);
0051             }
0052             FP fp;
0053         };
0054     };
0055
0056
0057
0058
0059
0060
0061
0062     template <typename Dummy>
0063     struct function_ptr_impl<4, Dummy>
0064     {
0065         template <typename RT, typename FP>
0066         struct impl
0067         {
0068             typedef RT result_type;
0069             impl(FP fp_)
0070                 : fp(fp_) {}
0071             template <typename A0 , typename A1 , typename A2 , typename A3>
0072             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3) const
0073             {
0074                 return fp(a0 , a1 , a2 , a3);
0075             }
0076             FP fp;
0077         };
0078     };
0079
0080
0081
0082
0083
0084
0085
0086     template <typename Dummy>
0087     struct function_ptr_impl<5, Dummy>
0088     {
0089         template <typename RT, typename FP>
0090         struct impl
0091         {
0092             typedef RT result_type;
0093             impl(FP fp_)
0094                 : fp(fp_) {}
0095             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
0096             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4) const
0097             {
0098                 return fp(a0 , a1 , a2 , a3 , a4);
0099             }
0100             FP fp;
0101         };
0102     };
0103
0104
0105
0106
0107
0108
0109
0110     template <typename Dummy>
0111     struct function_ptr_impl<6, Dummy>
0112     {
0113         template <typename RT, typename FP>
0114         struct impl
0115         {
0116             typedef RT result_type;
0117             impl(FP fp_)
0118                 : fp(fp_) {}
0119             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
0120             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5) const
0121             {
0122                 return fp(a0 , a1 , a2 , a3 , a4 , a5);
0123             }
0124             FP fp;
0125         };
0126     };
0127
0128
0129
0130
0131
0132
0133
0134     template <typename Dummy>
0135     struct function_ptr_impl<7, Dummy>
0136     {
0137         template <typename RT, typename FP>
0138         struct impl
0139         {
0140             typedef RT result_type;
0141             impl(FP fp_)
0142                 : fp(fp_) {}
0143             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
0144             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6) const
0145             {
0146                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6);
0147             }
0148             FP fp;
0149         };
0150     };
0151
0152
0153
0154
0155
0156
0157
0158     template <typename Dummy>
0159     struct function_ptr_impl<8, Dummy>
0160     {
0161         template <typename RT, typename FP>
0162         struct impl
0163         {
0164             typedef RT result_type;
0165             impl(FP fp_)
0166                 : fp(fp_) {}
0167             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
0168             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7) const
0169             {
0170                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
0171             }
0172             FP fp;
0173         };
0174     };
0175
0176
0177
0178
0179
0180
0181
0182     template <typename Dummy>
0183     struct function_ptr_impl<9, Dummy>
0184     {
0185         template <typename RT, typename FP>
0186         struct impl
0187         {
0188             typedef RT result_type;
0189             impl(FP fp_)
0190                 : fp(fp_) {}
0191             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
0192             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8) const
0193             {
0194                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
0195             }
0196             FP fp;
0197         };
0198     };
0199
0200
0201
0202
0203
0204
0205
0206     template <typename Dummy>
0207     struct function_ptr_impl<10, Dummy>
0208     {
0209         template <typename RT, typename FP>
0210         struct impl
0211         {
0212             typedef RT result_type;
0213             impl(FP fp_)
0214                 : fp(fp_) {}
0215             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
0216             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9) const
0217             {
0218                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
0219             }
0220             FP fp;
0221         };
0222     };