src/third_party/libjingle/source/talk/base/bind.h

   1 // This file was GENERATED by command:
   2 //     pump.py bind.h.pump
   3 // DO NOT EDIT BY HAND!!!
   4
   5 /*
   6  * libjingle
   7  * Copyright 2012 Google Inc.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions are met:
  11  *
  12  *  1. Redistributions of source code must retain the above copyright notice,
  13  *     this list of conditions and the following disclaimer.
  14  *  2. Redistributions in binary form must reproduce the above copyright notice,
  15  *     this list of conditions and the following disclaimer in the documentation
  16  *     and/or other materials provided with the distribution.
  17  *  3. The name of the author may not be used to endorse or promote products
  18  *     derived from this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  21  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  22  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  23  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  25  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  26  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  27  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  28  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  29  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 // To generate bind.h from bind.h.pump, execute:
  33 // /home/build/google3/third_party/gtest/scripts/pump.py bind.h.pump
  34
  35 // Bind() is an overloaded function that converts method calls into function
  36 // objects (aka functors). It captures any arguments to the method by value
  37 // when Bind is called, producing a stateful, nullary function object. Care
  38 // should be taken about the lifetime of objects captured by Bind(); the
  39 // returned functor knows nothing about the lifetime of the method's object or
  40 // any arguments passed by pointer, and calling the functor with a destroyed
  41 // object will surely do bad things.
  42 //
  43 // Example usage:
  44 //   struct Foo {
  45 //     int Test1() { return 42; }
  46 //     int Test2() const { return 52; }
  47 //     int Test3(int x) { return x*x; }
  48 //     float Test4(int x, float y) { return x + y; }
  49 //   };
  50 //
  51 //   int main() {
  52 //     Foo foo;
  53 //     cout << talk_base::Bind(&Foo::Test1, &foo)() << endl;
  54 //     cout << talk_base::Bind(&Foo::Test2, &foo)() << endl;
  55 //     cout << talk_base::Bind(&Foo::Test3, &foo, 3)() << endl;
  56 //     cout << talk_base::Bind(&Foo::Test4, &foo, 7, 8.5f)() << endl;
  57 //   }
  58
  59 #ifndef TALK_BASE_BIND_H_
  60 #define TALK_BASE_BIND_H_
  61
  62 #define NONAME
  63
  64 namespace talk_base {
  65 namespace detail {
  66 // This is needed because the template parameters in Bind can't be resolved
  67 // if they're used both as parameters of the function pointer type and as
  68 // parameters to Bind itself: the function pointer parameters are exact
  69 // matches to the function prototype, but the parameters to bind have
  70 // references stripped. This trick allows the compiler to dictate the Bind
  71 // parameter types rather than deduce them.
  72 template <class T> struct identity { typedef T type; };
  73 }  // namespace detail
  74
  75 template <class ObjectT, class MethodT, class R>
  76 class MethodFunctor0 {
  77  public:
  78   MethodFunctor0(MethodT method, ObjectT* object)
  79       : method_(method), object_(object) {}
  80   R operator()() const {
  81     return (object_->*method_)(); }
  82  private:
  83   MethodT method_;
  84   ObjectT* object_;
  85 };
  86
  87 #define FP_T(x) R (ObjectT::*x)()
  88
  89 template <class ObjectT, class R>
  90 MethodFunctor0<ObjectT, FP_T(NONAME), R>
  91 Bind(FP_T(method), ObjectT* object) {
  92   return MethodFunctor0<ObjectT, FP_T(NONAME), R>(
  93       method, object);
  94 }
  95
  96 #undef FP_T
  97 #define FP_T(x) R (ObjectT::*x)() const
  98
  99 template <class ObjectT, class R>
 100 MethodFunctor0<const ObjectT, FP_T(NONAME), R>
 101 Bind(FP_T(method), const ObjectT* object) {
 102   return MethodFunctor0<const ObjectT, FP_T(NONAME), R>(
 103       method, object);
 104 }
 105
 106 #undef FP_T
 107
 108 template <class ObjectT, class MethodT, class R,
 109           class P1>
 110 class MethodFunctor1 {
 111  public:
 112   MethodFunctor1(MethodT method, ObjectT* object,
 113                  P1 p1)
 114       : method_(method), object_(object),
 115       p1_(p1) {}
 116   R operator()() const {
 117     return (object_->*method_)(p1_); }
 118  private:
 119   MethodT method_;
 120   ObjectT* object_;
 121   P1 p1_;
 122 };
 123
 124 #define FP_T(x) R (ObjectT::*x)(P1)
 125
 126 template <class ObjectT, class R,
 127           class P1>
 128 MethodFunctor1<ObjectT, FP_T(NONAME), R, P1>
 129 Bind(FP_T(method), ObjectT* object,
 130      typename detail::identity<P1>::type p1) {
 131   return MethodFunctor1<ObjectT, FP_T(NONAME), R, P1>(
 132       method, object, p1);
 133 }
 134
 135 #undef FP_T
 136 #define FP_T(x) R (ObjectT::*x)(P1) const
 137
 138 template <class ObjectT, class R,
 139           class P1>
 140 MethodFunctor1<const ObjectT, FP_T(NONAME), R, P1>
 141 Bind(FP_T(method), const ObjectT* object,
 142      typename detail::identity<P1>::type p1) {
 143   return MethodFunctor1<const ObjectT, FP_T(NONAME), R, P1>(
 144       method, object, p1);
 145 }
 146
 147 #undef FP_T
 148
 149 template <class ObjectT, class MethodT, class R,
 150           class P1,
 151           class P2>
 152 class MethodFunctor2 {
 153  public:
 154   MethodFunctor2(MethodT method, ObjectT* object,
 155                  P1 p1,
 156                  P2 p2)
 157       : method_(method), object_(object),
 158       p1_(p1),
 159       p2_(p2) {}
 160   R operator()() const {
 161     return (object_->*method_)(p1_, p2_); }
 162  private:
 163   MethodT method_;
 164   ObjectT* object_;
 165   P1 p1_;
 166   P2 p2_;
 167 };
 168
 169 #define FP_T(x) R (ObjectT::*x)(P1, P2)
 170
 171 template <class ObjectT, class R,
 172           class P1,
 173           class P2>
 174 MethodFunctor2<ObjectT, FP_T(NONAME), R, P1, P2>
 175 Bind(FP_T(method), ObjectT* object,
 176      typename detail::identity<P1>::type p1,
 177      typename detail::identity<P2>::type p2) {
 178   return MethodFunctor2<ObjectT, FP_T(NONAME), R, P1, P2>(
 179       method, object, p1, p2);
 180 }
 181
 182 #undef FP_T
 183 #define FP_T(x) R (ObjectT::*x)(P1, P2) const
 184
 185 template <class ObjectT, class R,
 186           class P1,
 187           class P2>
 188 MethodFunctor2<const ObjectT, FP_T(NONAME), R, P1, P2>
 189 Bind(FP_T(method), const ObjectT* object,
 190      typename detail::identity<P1>::type p1,
 191      typename detail::identity<P2>::type p2) {
 192   return MethodFunctor2<const ObjectT, FP_T(NONAME), R, P1, P2>(
 193       method, object, p1, p2);
 194 }
 195
 196 #undef FP_T
 197
 198 template <class ObjectT, class MethodT, class R,
 199           class P1,
 200           class P2,
 201           class P3>
 202 class MethodFunctor3 {
 203  public:
 204   MethodFunctor3(MethodT method, ObjectT* object,
 205                  P1 p1,
 206                  P2 p2,
 207                  P3 p3)
 208       : method_(method), object_(object),
 209       p1_(p1),
 210       p2_(p2),
 211       p3_(p3) {}
 212   R operator()() const {
 213     return (object_->*method_)(p1_, p2_, p3_); }
 214  private:
 215   MethodT method_;
 216   ObjectT* object_;
 217   P1 p1_;
 218   P2 p2_;
 219   P3 p3_;
 220 };
 221
 222 #define FP_T(x) R (ObjectT::*x)(P1, P2, P3)
 223
 224 template <class ObjectT, class R,
 225           class P1,
 226           class P2,
 227           class P3>
 228 MethodFunctor3<ObjectT, FP_T(NONAME), R, P1, P2, P3>
 229 Bind(FP_T(method), ObjectT* object,
 230      typename detail::identity<P1>::type p1,
 231      typename detail::identity<P2>::type p2,
 232      typename detail::identity<P3>::type p3) {
 233   return MethodFunctor3<ObjectT, FP_T(NONAME), R, P1, P2, P3>(
 234       method, object, p1, p2, p3);
 235 }
 236
 237 #undef FP_T
 238 #define FP_T(x) R (ObjectT::*x)(P1, P2, P3) const
 239
 240 template <class ObjectT, class R,
 241           class P1,
 242           class P2,
 243           class P3>
 244 MethodFunctor3<const ObjectT, FP_T(NONAME), R, P1, P2, P3>
 245 Bind(FP_T(method), const ObjectT* object,
 246      typename detail::identity<P1>::type p1,
 247      typename detail::identity<P2>::type p2,
 248      typename detail::identity<P3>::type p3) {
 249   return MethodFunctor3<const ObjectT, FP_T(NONAME), R, P1, P2, P3>(
 250       method, object, p1, p2, p3);
 251 }
 252
 253 #undef FP_T
 254
 255 template <class ObjectT, class MethodT, class R,
 256           class P1,
 257           class P2,
 258           class P3,
 259           class P4>
 260 class MethodFunctor4 {
 261  public:
 262   MethodFunctor4(MethodT method, ObjectT* object,
 263                  P1 p1,
 264                  P2 p2,
 265                  P3 p3,
 266                  P4 p4)
 267       : method_(method), object_(object),
 268       p1_(p1),
 269       p2_(p2),
 270       p3_(p3),
 271       p4_(p4) {}
 272   R operator()() const {
 273     return (object_->*method_)(p1_, p2_, p3_, p4_); }
 274  private:
 275   MethodT method_;
 276   ObjectT* object_;
 277   P1 p1_;
 278   P2 p2_;
 279   P3 p3_;
 280   P4 p4_;
 281 };
 282
 283 #define FP_T(x) R (ObjectT::*x)(P1, P2, P3, P4)
 284
 285 template <class ObjectT, class R,
 286           class P1,
 287           class P2,
 288           class P3,
 289           class P4>
 290 MethodFunctor4<ObjectT, FP_T(NONAME), R, P1, P2, P3, P4>
 291 Bind(FP_T(method), ObjectT* object,
 292      typename detail::identity<P1>::type p1,
 293      typename detail::identity<P2>::type p2,
 294      typename detail::identity<P3>::type p3,
 295      typename detail::identity<P4>::type p4) {
 296   return MethodFunctor4<ObjectT, FP_T(NONAME), R, P1, P2, P3, P4>(
 297       method, object, p1, p2, p3, p4);
 298 }
 299
 300 #undef FP_T
 301 #define FP_T(x) R (ObjectT::*x)(P1, P2, P3, P4) const
 302
 303 template <class ObjectT, class R,
 304           class P1,
 305           class P2,
 306           class P3,
 307           class P4>
 308 MethodFunctor4<const ObjectT, FP_T(NONAME), R, P1, P2, P3, P4>
 309 Bind(FP_T(method), const ObjectT* object,
 310      typename detail::identity<P1>::type p1,
 311      typename detail::identity<P2>::type p2,
 312      typename detail::identity<P3>::type p3,
 313      typename detail::identity<P4>::type p4) {
 314   return MethodFunctor4<const ObjectT, FP_T(NONAME), R, P1, P2, P3, P4>(
 315       method, object, p1, p2, p3, p4);
 316 }
 317
 318 #undef FP_T
 319
 320 template <class ObjectT, class MethodT, class R,
 321           class P1,
 322           class P2,
 323           class P3,
 324           class P4,
 325           class P5>
 326 class MethodFunctor5 {
 327  public:
 328   MethodFunctor5(MethodT method, ObjectT* object,
 329                  P1 p1,
 330                  P2 p2,
 331                  P3 p3,
 332                  P4 p4,
 333                  P5 p5)
 334       : method_(method), object_(object),
 335       p1_(p1),
 336       p2_(p2),
 337       p3_(p3),
 338       p4_(p4),
 339       p5_(p5) {}
 340   R operator()() const {
 341     return (object_->*method_)(p1_, p2_, p3_, p4_, p5_); }
 342  private:
 343   MethodT method_;
 344   ObjectT* object_;
 345   P1 p1_;
 346   P2 p2_;
 347   P3 p3_;
 348   P4 p4_;
 349   P5 p5_;
 350 };
 351
 352 #define FP_T(x) R (ObjectT::*x)(P1, P2, P3, P4, P5)
 353
 354 template <class ObjectT, class R,
 355           class P1,
 356           class P2,
 357           class P3,
 358           class P4,
 359           class P5>
 360 MethodFunctor5<ObjectT, FP_T(NONAME), R, P1, P2, P3, P4, P5>
 361 Bind(FP_T(method), ObjectT* object,
 362      typename detail::identity<P1>::type p1,
 363      typename detail::identity<P2>::type p2,
 364      typename detail::identity<P3>::type p3,
 365      typename detail::identity<P4>::type p4,
 366      typename detail::identity<P5>::type p5) {
 367   return MethodFunctor5<ObjectT, FP_T(NONAME), R, P1, P2, P3, P4, P5>(
 368       method, object, p1, p2, p3, p4, p5);
 369 }
 370
 371 #undef FP_T
 372 #define FP_T(x) R (ObjectT::*x)(P1, P2, P3, P4, P5) const
 373
 374 template <class ObjectT, class R,
 375           class P1,
 376           class P2,
 377           class P3,
 378           class P4,
 379           class P5>
 380 MethodFunctor5<const ObjectT, FP_T(NONAME), R, P1, P2, P3, P4, P5>
 381 Bind(FP_T(method), const ObjectT* object,
 382      typename detail::identity<P1>::type p1,
 383      typename detail::identity<P2>::type p2,
 384      typename detail::identity<P3>::type p3,
 385      typename detail::identity<P4>::type p4,
 386      typename detail::identity<P5>::type p5) {
 387   return MethodFunctor5<const ObjectT, FP_T(NONAME), R, P1, P2, P3, P4, P5>(
 388       method, object, p1, p2, p3, p4, p5);
 389 }
 390
 391 #undef FP_T
 392
 393 }  // namespace talk_base
 394
 395 #undef NONAME
 396
 397 #endif  // TALK_BASE_BIND_H_