ceph/src/boost/libs/bind/include/boost/bind/protect.hpp

   1 #ifndef BOOST_BIND_PROTECT_HPP_INCLUDED
   2 #define BOOST_BIND_PROTECT_HPP_INCLUDED
   3
   4 //
   5 //  protect.hpp
   6 //
   7 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
   8 //  Copyright (c) 2009 Steven Watanabe
   9 //
  10 // Distributed under the Boost Software License, Version 1.0. (See
  11 // accompanying file LICENSE_1_0.txt or copy at
  12 // http://www.boost.org/LICENSE_1_0.txt)
  13 //
  14
  15 #include <boost/config.hpp>
  16 #include <boost/detail/workaround.hpp>
  17
  18 namespace boost
  19 {
  20
  21 namespace _bi
  22 {
  23
  24 template<class F> class protected_bind_t
  25 {
  26 public:
  27
  28     typedef typename F::result_type result_type;
  29
  30     explicit protected_bind_t(F f): f_(f)
  31     {
  32     }
  33
  34     result_type operator()()
  35     {
  36         return f_();
  37     }
  38
  39     result_type operator()() const
  40     {
  41         return f_();
  42     }
  43
  44     template<class A1> result_type operator()(A1 & a1)
  45     {
  46         return f_(a1);
  47     }
  48
  49     template<class A1> result_type operator()(A1 & a1) const
  50     {
  51         return f_(a1);
  52     }
  53
  54
  55 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
  56  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
  57
  58     template<class A1> result_type operator()(const A1 & a1)
  59     {
  60         return f_(a1);
  61     }
  62
  63     template<class A1> result_type operator()(const A1 & a1) const
  64     {
  65         return f_(a1);
  66     }
  67
  68 #endif
  69
  70     template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
  71     {
  72         return f_(a1, a2);
  73     }
  74
  75     template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
  76     {
  77         return f_(a1, a2);
  78     }
  79
  80 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
  81  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
  82
  83     template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2)
  84     {
  85         return f_(a1, a2);
  86     }
  87
  88     template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2) const
  89     {
  90         return f_(a1, a2);
  91     }
  92
  93     template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2)
  94     {
  95         return f_(a1, a2);
  96     }
  97
  98     template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2) const
  99     {
 100         return f_(a1, a2);
 101     }
 102
 103     template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2)
 104     {
 105         return f_(a1, a2);
 106     }
 107
 108     template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2) const
 109     {
 110         return f_(a1, a2);
 111     }
 112
 113 #endif
 114
 115     template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
 116     {
 117         return f_(a1, a2, a3);
 118     }
 119
 120     template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) const
 121     {
 122         return f_(a1, a2, a3);
 123     }
 124
 125 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
 126  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 127
 128     template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3)
 129     {
 130         return f_(a1, a2, a3);
 131     }
 132
 133     template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3) const
 134     {
 135         return f_(a1, a2, a3);
 136     }
 137
 138 #endif
 139
 140     template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)
 141     {
 142         return f_(a1, a2, a3, a4);
 143     }
 144
 145     template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
 146     {
 147         return f_(a1, a2, a3, a4);
 148     }
 149
 150 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
 151  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 152
 153     template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4)
 154     {
 155         return f_(a1, a2, a3, a4);
 156     }
 157
 158     template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4) const
 159     {
 160         return f_(a1, a2, a3, a4);
 161     }
 162
 163 #endif
 164
 165     template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)
 166     {
 167         return f_(a1, a2, a3, a4, a5);
 168     }
 169
 170     template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
 171     {
 172         return f_(a1, a2, a3, a4, a5);
 173     }
 174
 175 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
 176  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 177
 178     template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5)
 179     {
 180         return f_(a1, a2, a3, a4, a5);
 181     }
 182
 183     template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5) const
 184     {
 185         return f_(a1, a2, a3, a4, a5);
 186     }
 187
 188 #endif
 189
 190     template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6)
 191     {
 192         return f_(a1, a2, a3, a4, a5, a6);
 193     }
 194
 195     template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
 196     {
 197         return f_(a1, a2, a3, a4, a5, a6);
 198     }
 199
 200 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
 201  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 202
 203     template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6)
 204     {
 205         return f_(a1, a2, a3, a4, a5, a6);
 206     }
 207
 208     template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6) const
 209     {
 210         return f_(a1, a2, a3, a4, a5, a6);
 211     }
 212
 213 #endif
 214
 215     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7)
 216     {
 217         return f_(a1, a2, a3, a4, a5, a6, a7);
 218     }
 219
 220     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
 221     {
 222         return f_(a1, a2, a3, a4, a5, a6, a7);
 223     }
 224
 225 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
 226  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 227
 228     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7)
 229     {
 230         return f_(a1, a2, a3, a4, a5, a6, a7);
 231     }
 232
 233     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7) const
 234     {
 235         return f_(a1, a2, a3, a4, a5, a6, a7);
 236     }
 237
 238 #endif
 239
 240     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8)
 241     {
 242         return f_(a1, a2, a3, a4, a5, a6, a7, a8);
 243     }
 244
 245     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
 246     {
 247         return f_(a1, a2, a3, a4, a5, a6, a7, a8);
 248     }
 249
 250 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
 251  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 252
 253     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8)
 254     {
 255         return f_(a1, a2, a3, a4, a5, a6, a7, a8);
 256     }
 257
 258     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(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
 259     {
 260         return f_(a1, a2, a3, a4, a5, a6, a7, a8);
 261     }
 262
 263 #endif
 264
 265     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9)
 266     {
 267         return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);
 268     }
 269
 270     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
 271     {
 272         return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);
 273     }
 274
 275 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
 276  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 277
 278     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9)
 279     {
 280         return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);
 281     }
 282
 283     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9) const
 284     {
 285         return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);
 286     }
 287
 288 #endif
 289
 290 private:
 291
 292     F f_;
 293 };
 294
 295 } // namespace _bi
 296
 297 template<class F> _bi::protected_bind_t<F> protect(F f)
 298 {
 299     return _bi::protected_bind_t<F>(f);
 300 }
 301
 302 } // namespace boost
 303
 304 #endif // #ifndef BOOST_BIND_PROTECT_HPP_INCLUDED