ceph/src/boost/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 2002, 2020 Peter Dimov
   8 // Copyright 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/config/workaround.hpp>
  17 #include <utility>
  18
  19 namespace boost
  20 {
  21
  22 namespace _bi
  23 {
  24
  25 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_DECLTYPE)
  26
  27 template<class T> struct protect_make_void
  28 {
  29     typedef void type;
  30 };
  31
  32 template<class F, class E = void> struct protect_result_type
  33 {
  34 };
  35
  36 template<class F> struct protect_result_type< F, typename protect_make_void<typename F::result_type>::type >
  37 {
  38     typedef typename F::result_type result_type;
  39 };
  40
  41 template<class F> class protected_bind_t: public protect_result_type<F>
  42 {
  43 private:
  44
  45     F f_;
  46
  47 public:
  48
  49     explicit protected_bind_t( F f ): f_( f )
  50     {
  51     }
  52
  53     template<class... A> auto operator()( A&&... a ) -> decltype( f_( std::forward<A>(a)... ) )
  54     {
  55         return f_( std::forward<A>(a)... );
  56     }
  57
  58     template<class... A> auto operator()( A&&... a ) const -> decltype( f_( std::forward<A>(a)... ) )
  59     {
  60         return f_( std::forward<A>(a)... );
  61     }
  62 };
  63
  64 #else
  65
  66 template<class F> class protected_bind_t
  67 {
  68 private:
  69
  70     F f_;
  71
  72 public:
  73
  74     typedef typename F::result_type result_type;
  75
  76     explicit protected_bind_t(F f): f_(f)
  77     {
  78     }
  79
  80     result_type operator()()
  81     {
  82         return f_();
  83     }
  84
  85     result_type operator()() const
  86     {
  87         return f_();
  88     }
  89
  90     template<class A1> result_type operator()(A1 & a1)
  91     {
  92         return f_(a1);
  93     }
  94
  95     template<class A1> result_type operator()(A1 & a1) const
  96     {
  97         return f_(a1);
  98     }
  99
 100
 101 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
 102  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 103
 104     template<class A1> result_type operator()(const A1 & a1)
 105     {
 106         return f_(a1);
 107     }
 108
 109     template<class A1> result_type operator()(const A1 & a1) const
 110     {
 111         return f_(a1);
 112     }
 113
 114 #endif
 115
 116     template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
 117     {
 118         return f_(a1, a2);
 119     }
 120
 121     template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
 122     {
 123         return f_(a1, a2);
 124     }
 125
 126 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
 127  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 128
 129     template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2)
 130     {
 131         return f_(a1, a2);
 132     }
 133
 134     template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2) const
 135     {
 136         return f_(a1, a2);
 137     }
 138
 139     template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2)
 140     {
 141         return f_(a1, a2);
 142     }
 143
 144     template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2) const
 145     {
 146         return f_(a1, a2);
 147     }
 148
 149     template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2)
 150     {
 151         return f_(a1, a2);
 152     }
 153
 154     template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2) const
 155     {
 156         return f_(a1, a2);
 157     }
 158
 159 #endif
 160
 161     template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
 162     {
 163         return f_(a1, a2, a3);
 164     }
 165
 166     template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) const
 167     {
 168         return f_(a1, a2, a3);
 169     }
 170
 171 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
 172  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 173
 174     template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3)
 175     {
 176         return f_(a1, a2, a3);
 177     }
 178
 179     template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3) const
 180     {
 181         return f_(a1, a2, a3);
 182     }
 183
 184 #endif
 185
 186     template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)
 187     {
 188         return f_(a1, a2, a3, a4);
 189     }
 190
 191     template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
 192     {
 193         return f_(a1, a2, a3, a4);
 194     }
 195
 196 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
 197  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 198
 199     template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4)
 200     {
 201         return f_(a1, a2, a3, a4);
 202     }
 203
 204     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
 205     {
 206         return f_(a1, a2, a3, a4);
 207     }
 208
 209 #endif
 210
 211     template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)
 212     {
 213         return f_(a1, a2, a3, a4, a5);
 214     }
 215
 216     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
 217     {
 218         return f_(a1, a2, a3, a4, a5);
 219     }
 220
 221 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
 222  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 223
 224     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)
 225     {
 226         return f_(a1, a2, a3, a4, a5);
 227     }
 228
 229     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
 230     {
 231         return f_(a1, a2, a3, a4, a5);
 232     }
 233
 234 #endif
 235
 236     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)
 237     {
 238         return f_(a1, a2, a3, a4, a5, a6);
 239     }
 240
 241     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
 242     {
 243         return f_(a1, a2, a3, a4, a5, a6);
 244     }
 245
 246 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
 247  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 248
 249     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)
 250     {
 251         return f_(a1, a2, a3, a4, a5, a6);
 252     }
 253
 254     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
 255     {
 256         return f_(a1, a2, a3, a4, a5, a6);
 257     }
 258
 259 #endif
 260
 261     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)
 262     {
 263         return f_(a1, a2, a3, a4, a5, a6, a7);
 264     }
 265
 266     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
 267     {
 268         return f_(a1, a2, a3, a4, a5, a6, a7);
 269     }
 270
 271 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
 272  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 273
 274     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)
 275     {
 276         return f_(a1, a2, a3, a4, a5, a6, a7);
 277     }
 278
 279     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
 280     {
 281         return f_(a1, a2, a3, a4, a5, a6, a7);
 282     }
 283
 284 #endif
 285
 286     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)
 287     {
 288         return f_(a1, a2, a3, a4, a5, a6, a7, a8);
 289     }
 290
 291     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
 292     {
 293         return f_(a1, a2, a3, a4, a5, a6, a7, a8);
 294     }
 295
 296 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
 297  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 298
 299     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)
 300     {
 301         return f_(a1, a2, a3, a4, a5, a6, a7, a8);
 302     }
 303
 304     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
 305     {
 306         return f_(a1, a2, a3, a4, a5, a6, a7, a8);
 307     }
 308
 309 #endif
 310
 311     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)
 312     {
 313         return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);
 314     }
 315
 316     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
 317     {
 318         return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);
 319     }
 320
 321 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
 322  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 323
 324     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)
 325     {
 326         return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);
 327     }
 328
 329     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
 330     {
 331         return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);
 332     }
 333
 334 #endif
 335 };
 336
 337 #endif
 338
 339 } // namespace _bi
 340
 341 template<class F> _bi::protected_bind_t<F> protect(F f)
 342 {
 343     return _bi::protected_bind_t<F>(f);
 344 }
 345
 346 } // namespace boost
 347
 348 #endif // #ifndef BOOST_BIND_PROTECT_HPP_INCLUDED