ceph/src/boost/libs/phoenix/include/boost/phoenix/operator/detail/cpp03/preprocessed/mem_fun_ptr_gen_10.hpp

   1 /*==============================================================================
   2     Copyright (c) 2001-2010 Joel de Guzman
   3     Copyright (c) 2010 Thomas Heller
   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     namespace detail {
   9         template <typename Object, typename MemPtr>
  10         struct mem_fun_ptr_gen
  11         {
  12             mem_fun_ptr_gen(Object const& obj_, MemPtr ptr_)
  13               : obj(obj_)
  14               , ptr(ptr_)
  15             {}
  16             typename phoenix::expression::mem_fun_ptr<Object, MemPtr>::type const
  17             operator()() const
  18             {
  19                 return phoenix::expression::mem_fun_ptr<Object, MemPtr>::make(obj, ptr);
  20             }
  21
  22
  23
  24
  25
  26
  27
  28             template <typename A0>
  29             typename phoenix::expression::mem_fun_ptr<
  30                 Object
  31               , MemPtr
  32               , A0
  33             >::type const
  34             operator()(A0 const& a0) const
  35             {
  36                 return phoenix::expression::mem_fun_ptr<
  37                     Object
  38                   , MemPtr
  39                   , A0
  40                 >::make(obj, ptr, a0);
  41             }
  42
  43
  44
  45
  46
  47
  48
  49             template <typename A0 , typename A1>
  50             typename phoenix::expression::mem_fun_ptr<
  51                 Object
  52               , MemPtr
  53               , A0 , A1
  54             >::type const
  55             operator()(A0 const& a0 , A1 const& a1) const
  56             {
  57                 return phoenix::expression::mem_fun_ptr<
  58                     Object
  59                   , MemPtr
  60                   , A0 , A1
  61                 >::make(obj, ptr, a0 , a1);
  62             }
  63
  64
  65
  66
  67
  68
  69
  70             template <typename A0 , typename A1 , typename A2>
  71             typename phoenix::expression::mem_fun_ptr<
  72                 Object
  73               , MemPtr
  74               , A0 , A1 , A2
  75             >::type const
  76             operator()(A0 const& a0 , A1 const& a1 , A2 const& a2) const
  77             {
  78                 return phoenix::expression::mem_fun_ptr<
  79                     Object
  80                   , MemPtr
  81                   , A0 , A1 , A2
  82                 >::make(obj, ptr, a0 , a1 , a2);
  83             }
  84
  85
  86
  87
  88
  89
  90
  91             template <typename A0 , typename A1 , typename A2 , typename A3>
  92             typename phoenix::expression::mem_fun_ptr<
  93                 Object
  94               , MemPtr
  95               , A0 , A1 , A2 , A3
  96             >::type const
  97             operator()(A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3) const
  98             {
  99                 return phoenix::expression::mem_fun_ptr<
 100                     Object
 101                   , MemPtr
 102                   , A0 , A1 , A2 , A3
 103                 >::make(obj, ptr, a0 , a1 , a2 , a3);
 104             }
 105
 106
 107
 108
 109
 110
 111
 112             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
 113             typename phoenix::expression::mem_fun_ptr<
 114                 Object
 115               , MemPtr
 116               , A0 , A1 , A2 , A3 , A4
 117             >::type const
 118             operator()(A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4) const
 119             {
 120                 return phoenix::expression::mem_fun_ptr<
 121                     Object
 122                   , MemPtr
 123                   , A0 , A1 , A2 , A3 , A4
 124                 >::make(obj, ptr, a0 , a1 , a2 , a3 , a4);
 125             }
 126
 127
 128
 129
 130
 131
 132
 133             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
 134             typename phoenix::expression::mem_fun_ptr<
 135                 Object
 136               , MemPtr
 137               , A0 , A1 , A2 , A3 , A4 , A5
 138             >::type const
 139             operator()(A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5) const
 140             {
 141                 return phoenix::expression::mem_fun_ptr<
 142                     Object
 143                   , MemPtr
 144                   , A0 , A1 , A2 , A3 , A4 , A5
 145                 >::make(obj, ptr, a0 , a1 , a2 , a3 , a4 , a5);
 146             }
 147
 148
 149
 150
 151
 152
 153
 154             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
 155             typename phoenix::expression::mem_fun_ptr<
 156                 Object
 157               , MemPtr
 158               , A0 , A1 , A2 , A3 , A4 , A5 , A6
 159             >::type const
 160             operator()(A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6) const
 161             {
 162                 return phoenix::expression::mem_fun_ptr<
 163                     Object
 164                   , MemPtr
 165                   , A0 , A1 , A2 , A3 , A4 , A5 , A6
 166                 >::make(obj, ptr, a0 , a1 , a2 , a3 , a4 , a5 , a6);
 167             }
 168
 169
 170
 171
 172
 173
 174
 175             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
 176             typename phoenix::expression::mem_fun_ptr<
 177                 Object
 178               , MemPtr
 179               , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
 180             >::type const
 181             operator()(A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7) const
 182             {
 183                 return phoenix::expression::mem_fun_ptr<
 184                     Object
 185                   , MemPtr
 186                   , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
 187                 >::make(obj, ptr, a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
 188             }
 189
 190
 191
 192
 193
 194
 195
 196             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
 197             typename phoenix::expression::mem_fun_ptr<
 198                 Object
 199               , MemPtr
 200               , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
 201             >::type const
 202             operator()(A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8) const
 203             {
 204                 return phoenix::expression::mem_fun_ptr<
 205                     Object
 206                   , MemPtr
 207                   , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
 208                 >::make(obj, ptr, a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
 209             }
 210             Object const& obj;
 211             MemPtr ptr;
 212         };
 213         struct make_mem_fun_ptr_gen
 214             : proto::callable
 215         {
 216             template<typename Sig>
 217             struct result;
 218             template<typename This, typename Object, typename MemPtr>
 219             struct result<This(Object, MemPtr)>
 220             {
 221                 typedef
 222                     mem_fun_ptr_gen<
 223                         typename remove_const<typename remove_reference<Object>::type>::type
 224                       , typename remove_const<typename remove_reference<MemPtr>::type>::type
 225                     >
 226                 type;
 227             };
 228             template<typename Object, typename MemPtr>
 229             mem_fun_ptr_gen<Object, MemPtr> operator()(Object const & obj, MemPtr ptr) const
 230             {
 231                 return mem_fun_ptr_gen<Object, MemPtr>(obj, ptr);
 232             }
 233         };
 234     }