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

   1 #ifndef BOOST_BIND_MAKE_ADAPTABLE_HPP_INCLUDED
   2 #define BOOST_BIND_MAKE_ADAPTABLE_HPP_INCLUDED
   3
   4 //
   5 //  make_adaptable.hpp
   6 //
   7 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
   8 //
   9 // Distributed under the Boost Software License, Version 1.0. (See
  10 // accompanying file LICENSE_1_0.txt or copy at
  11 // http://www.boost.org/LICENSE_1_0.txt)
  12 //
  13
  14 namespace boost
  15 {
  16
  17 namespace _bi
  18 {
  19
  20 template<class R, class F> class af0
  21 {
  22 public:
  23
  24     typedef R result_type;
  25
  26     explicit af0(F f): f_(f)
  27     {
  28     }
  29
  30     result_type operator()()
  31     {
  32         return f_();
  33     }
  34
  35     result_type operator()() const
  36     {
  37         return f_();
  38     }
  39
  40 private:
  41
  42     F f_;
  43 };
  44
  45 template<class R, class A1, class F> class af1
  46 {
  47 public:
  48
  49     typedef R result_type;
  50     typedef A1 argument_type;
  51     typedef A1 arg1_type;
  52
  53     explicit af1(F f): f_(f)
  54     {
  55     }
  56
  57     result_type operator()(A1 a1)
  58     {
  59         return f_(a1);
  60     }
  61
  62     result_type operator()(A1 a1) const
  63     {
  64         return f_(a1);
  65     }
  66
  67 private:
  68
  69     F f_;
  70 };
  71
  72 template<class R, class A1, class A2, class F> class af2
  73 {
  74 public:
  75
  76     typedef R result_type;
  77     typedef A1 first_argument_type;
  78     typedef A2 second_argument_type;
  79     typedef A1 arg1_type;
  80     typedef A2 arg2_type;
  81
  82     explicit af2(F f): f_(f)
  83     {
  84     }
  85
  86     result_type operator()(A1 a1, A2 a2)
  87     {
  88         return f_(a1, a2);
  89     }
  90
  91     result_type operator()(A1 a1, A2 a2) const
  92     {
  93         return f_(a1, a2);
  94     }
  95
  96 private:
  97
  98     F f_;
  99 };
 100
 101 template<class R, class A1, class A2, class A3, class F> class af3
 102 {
 103 public:
 104
 105     typedef R result_type;
 106     typedef A1 arg1_type;
 107     typedef A2 arg2_type;
 108     typedef A3 arg3_type;
 109
 110     explicit af3(F f): f_(f)
 111     {
 112     }
 113
 114     result_type operator()(A1 a1, A2 a2, A3 a3)
 115     {
 116         return f_(a1, a2, a3);
 117     }
 118
 119     result_type operator()(A1 a1, A2 a2, A3 a3) const
 120     {
 121         return f_(a1, a2, a3);
 122     }
 123
 124 private:
 125
 126     F f_;
 127 };
 128
 129 template<class R, class A1, class A2, class A3, class A4, class F> class af4
 130 {
 131 public:
 132
 133     typedef R result_type;
 134     typedef A1 arg1_type;
 135     typedef A2 arg2_type;
 136     typedef A3 arg3_type;
 137     typedef A4 arg4_type;
 138
 139     explicit af4(F f): f_(f)
 140     {
 141     }
 142
 143     result_type operator()(A1 a1, A2 a2, A3 a3, A4 a4)
 144     {
 145         return f_(a1, a2, a3, a4);
 146     }
 147
 148     result_type operator()(A1 a1, A2 a2, A3 a3, A4 a4) const
 149     {
 150         return f_(a1, a2, a3, a4);
 151     }
 152
 153 private:
 154
 155     F f_;
 156 };
 157
 158 } // namespace _bi
 159
 160 template<class R, class F> _bi::af0<R, F> make_adaptable(F f)
 161 {
 162     return _bi::af0<R, F>(f);
 163 }
 164
 165 template<class R, class A1, class F> _bi::af1<R, A1, F> make_adaptable(F f)
 166 {
 167     return _bi::af1<R, A1, F>(f);
 168 }
 169
 170 template<class R, class A1, class A2, class F> _bi::af2<R, A1, A2, F> make_adaptable(F f)
 171 {
 172     return _bi::af2<R, A1, A2, F>(f);
 173 }
 174
 175 template<class R, class A1, class A2, class A3, class F> _bi::af3<R, A1, A2, A3, F> make_adaptable(F f)
 176 {
 177     return _bi::af3<R, A1, A2, A3, F>(f);
 178 }
 179
 180 template<class R, class A1, class A2, class A3, class A4, class F> _bi::af4<R, A1, A2, A3, A4, F> make_adaptable(F f)
 181 {
 182     return _bi::af4<R, A1, A2, A3, A4, F>(f);
 183 }
 184
 185 } // namespace boost
 186
 187 #endif // #ifndef BOOST_BIND_MAKE_ADAPTABLE_HPP_INCLUDED