ceph/src/boost/libs/phoenix/include/boost/phoenix/bind/detail/cpp03/preprocessed/function_ptr_10.hpp

   1 /*=============================================================================
   2     Copyright (c) 2001-2007 Joel de Guzman
   3
   4     Distributed under the Boost Software License, Version 1.0. (See accompanying
   5     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   6 ==============================================================================*/
   7
   8
   9
  10
  11
  12
  13
  14     template <typename Dummy>
  15     struct function_ptr_impl<2, Dummy>
  16     {
  17         template <typename RT, typename FP>
  18         struct impl
  19         {
  20             typedef RT result_type;
  21             impl(FP fp_)
  22                 : fp(fp_) {}
  23             template <typename A0 , typename A1>
  24             RT operator()(A0 & a0 , A1 & a1) const
  25             {
  26                 return fp(a0 , a1);
  27             }
  28             FP fp;
  29         };
  30     };
  31
  32
  33
  34
  35
  36
  37
  38     template <typename Dummy>
  39     struct function_ptr_impl<3, Dummy>
  40     {
  41         template <typename RT, typename FP>
  42         struct impl
  43         {
  44             typedef RT result_type;
  45             impl(FP fp_)
  46                 : fp(fp_) {}
  47             template <typename A0 , typename A1 , typename A2>
  48             RT operator()(A0 & a0 , A1 & a1 , A2 & a2) const
  49             {
  50                 return fp(a0 , a1 , a2);
  51             }
  52             FP fp;
  53         };
  54     };
  55
  56
  57
  58
  59
  60
  61
  62     template <typename Dummy>
  63     struct function_ptr_impl<4, Dummy>
  64     {
  65         template <typename RT, typename FP>
  66         struct impl
  67         {
  68             typedef RT result_type;
  69             impl(FP fp_)
  70                 : fp(fp_) {}
  71             template <typename A0 , typename A1 , typename A2 , typename A3>
  72             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3) const
  73             {
  74                 return fp(a0 , a1 , a2 , a3);
  75             }
  76             FP fp;
  77         };
  78     };
  79
  80
  81
  82
  83
  84
  85
  86     template <typename Dummy>
  87     struct function_ptr_impl<5, Dummy>
  88     {
  89         template <typename RT, typename FP>
  90         struct impl
  91         {
  92             typedef RT result_type;
  93             impl(FP fp_)
  94                 : fp(fp_) {}
  95             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
  96             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4) const
  97             {
  98                 return fp(a0 , a1 , a2 , a3 , a4);
  99             }
 100             FP fp;
 101         };
 102     };
 103
 104
 105
 106
 107
 108
 109
 110     template <typename Dummy>
 111     struct function_ptr_impl<6, Dummy>
 112     {
 113         template <typename RT, typename FP>
 114         struct impl
 115         {
 116             typedef RT result_type;
 117             impl(FP fp_)
 118                 : fp(fp_) {}
 119             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
 120             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5) const
 121             {
 122                 return fp(a0 , a1 , a2 , a3 , a4 , a5);
 123             }
 124             FP fp;
 125         };
 126     };
 127
 128
 129
 130
 131
 132
 133
 134     template <typename Dummy>
 135     struct function_ptr_impl<7, Dummy>
 136     {
 137         template <typename RT, typename FP>
 138         struct impl
 139         {
 140             typedef RT result_type;
 141             impl(FP fp_)
 142                 : fp(fp_) {}
 143             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
 144             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6) const
 145             {
 146                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6);
 147             }
 148             FP fp;
 149         };
 150     };
 151
 152
 153
 154
 155
 156
 157
 158     template <typename Dummy>
 159     struct function_ptr_impl<8, Dummy>
 160     {
 161         template <typename RT, typename FP>
 162         struct impl
 163         {
 164             typedef RT result_type;
 165             impl(FP fp_)
 166                 : fp(fp_) {}
 167             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
 168             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7) const
 169             {
 170                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
 171             }
 172             FP fp;
 173         };
 174     };
 175
 176
 177
 178
 179
 180
 181
 182     template <typename Dummy>
 183     struct function_ptr_impl<9, Dummy>
 184     {
 185         template <typename RT, typename FP>
 186         struct impl
 187         {
 188             typedef RT result_type;
 189             impl(FP fp_)
 190                 : fp(fp_) {}
 191             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
 192             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8) const
 193             {
 194                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
 195             }
 196             FP fp;
 197         };
 198     };
 199
 200
 201
 202
 203
 204
 205
 206     template <typename Dummy>
 207     struct function_ptr_impl<10, Dummy>
 208     {
 209         template <typename RT, typename FP>
 210         struct impl
 211         {
 212             typedef RT result_type;
 213             impl(FP fp_)
 214                 : fp(fp_) {}
 215             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
 216             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9) const
 217             {
 218                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
 219             }
 220             FP fp;
 221         };
 222     };