1// This file was GENERATED by command:
2//     pump.py bind.h.pump
3// DO NOT EDIT BY HAND!!!
4
5/*
6 *  Copyright 2012 The WebRTC Project Authors. All rights reserved.
7 *
8 *  Use of this source code is governed by a BSD-style license
9 *  that can be found in the LICENSE file in the root of the source
10 *  tree. An additional intellectual property rights grant can be found
11 *  in the file PATENTS.  All contributing project authors may
12 *  be found in the AUTHORS file in the root of the source tree.
13 */
14
15// To generate bind.h from bind.h.pump, execute:
16// /home/build/google3/third_party/gtest/scripts/pump.py bind.h.pump
17
18// Bind() is an overloaded function that converts method calls into function
19// objects (aka functors). It captures any arguments to the method by value
20// when Bind is called, producing a stateful, nullary function object. Care
21// should be taken about the lifetime of objects captured by Bind(); the
22// returned functor knows nothing about the lifetime of the method's object or
23// any arguments passed by pointer, and calling the functor with a destroyed
24// object will surely do bad things.
25//
26// Example usage:
27//   struct Foo {
28//     int Test1() { return 42; }
29//     int Test2() const { return 52; }
30//     int Test3(int x) { return x*x; }
31//     float Test4(int x, float y) { return x + y; }
32//   };
33//
34//   int main() {
35//     Foo foo;
36//     cout << rtc::Bind(&Foo::Test1, &foo)() << endl;
37//     cout << rtc::Bind(&Foo::Test2, &foo)() << endl;
38//     cout << rtc::Bind(&Foo::Test3, &foo, 3)() << endl;
39//     cout << rtc::Bind(&Foo::Test4, &foo, 7, 8.5f)() << endl;
40//   }
41
42#ifndef WEBRTC_BASE_BIND_H_
43#define WEBRTC_BASE_BIND_H_
44
45#define NONAME
46
47namespace rtc {
48namespace detail {
49// This is needed because the template parameters in Bind can't be resolved
50// if they're used both as parameters of the function pointer type and as
51// parameters to Bind itself: the function pointer parameters are exact
52// matches to the function prototype, but the parameters to bind have
53// references stripped. This trick allows the compiler to dictate the Bind
54// parameter types rather than deduce them.
55template <class T> struct identity { typedef T type; };
56}  // namespace detail
57
58template <class ObjectT, class MethodT, class R>
59class MethodFunctor0 {
60 public:
61  MethodFunctor0(MethodT method, ObjectT* object)
62      : method_(method), object_(object) {}
63  R operator()() const {
64    return (object_->*method_)(); }
65 private:
66  MethodT method_;
67  ObjectT* object_;
68};
69
70template <class FunctorT, class R>
71class Functor0 {
72 public:
73  explicit Functor0(const FunctorT& functor)
74      : functor_(functor) {}
75  R operator()() const {
76    return functor_(); }
77 private:
78  FunctorT functor_;
79};
80
81
82#define FP_T(x) R (ObjectT::*x)()
83
84template <class ObjectT, class R>
85MethodFunctor0<ObjectT, FP_T(NONAME), R>
86Bind(FP_T(method), ObjectT* object) {
87  return MethodFunctor0<ObjectT, FP_T(NONAME), R>(
88      method, object);
89}
90
91#undef FP_T
92#define FP_T(x) R (ObjectT::*x)() const
93
94template <class ObjectT, class R>
95MethodFunctor0<const ObjectT, FP_T(NONAME), R>
96Bind(FP_T(method), const ObjectT* object) {
97  return MethodFunctor0<const ObjectT, FP_T(NONAME), R>(
98      method, object);
99}
100
101#undef FP_T
102#define FP_T(x) R (*x)()
103
104template <class R>
105Functor0<FP_T(NONAME), R>
106Bind(FP_T(function)) {
107  return Functor0<FP_T(NONAME), R>(
108      function);
109}
110
111#undef FP_T
112
113template <class ObjectT, class MethodT, class R,
114          class P1>
115class MethodFunctor1 {
116 public:
117  MethodFunctor1(MethodT method, ObjectT* object,
118                 P1 p1)
119      : method_(method), object_(object),
120      p1_(p1) {}
121  R operator()() const {
122    return (object_->*method_)(p1_); }
123 private:
124  MethodT method_;
125  ObjectT* object_;
126  P1 p1_;
127};
128
129template <class FunctorT, class R,
130          class P1>
131class Functor1 {
132 public:
133  Functor1(const FunctorT& functor, P1 p1)
134      : functor_(functor),
135      p1_(p1) {}
136  R operator()() const {
137    return functor_(p1_); }
138 private:
139  FunctorT functor_;
140  P1 p1_;
141};
142
143
144#define FP_T(x) R (ObjectT::*x)(P1)
145
146template <class ObjectT, class R,
147          class P1>
148MethodFunctor1<ObjectT, FP_T(NONAME), R, P1>
149Bind(FP_T(method), ObjectT* object,
150     typename detail::identity<P1>::type p1) {
151  return MethodFunctor1<ObjectT, FP_T(NONAME), R, P1>(
152      method, object, p1);
153}
154
155#undef FP_T
156#define FP_T(x) R (ObjectT::*x)(P1) const
157
158template <class ObjectT, class R,
159          class P1>
160MethodFunctor1<const ObjectT, FP_T(NONAME), R, P1>
161Bind(FP_T(method), const ObjectT* object,
162     typename detail::identity<P1>::type p1) {
163  return MethodFunctor1<const ObjectT, FP_T(NONAME), R, P1>(
164      method, object, p1);
165}
166
167#undef FP_T
168#define FP_T(x) R (*x)(P1)
169
170template <class R,
171          class P1>
172Functor1<FP_T(NONAME), R, P1>
173Bind(FP_T(function),
174     typename detail::identity<P1>::type p1) {
175  return Functor1<FP_T(NONAME), R, P1>(
176      function, p1);
177}
178
179#undef FP_T
180
181template <class ObjectT, class MethodT, class R,
182          class P1,
183          class P2>
184class MethodFunctor2 {
185 public:
186  MethodFunctor2(MethodT method, ObjectT* object,
187                 P1 p1,
188                 P2 p2)
189      : method_(method), object_(object),
190      p1_(p1),
191      p2_(p2) {}
192  R operator()() const {
193    return (object_->*method_)(p1_, p2_); }
194 private:
195  MethodT method_;
196  ObjectT* object_;
197  P1 p1_;
198  P2 p2_;
199};
200
201template <class FunctorT, class R,
202          class P1,
203          class P2>
204class Functor2 {
205 public:
206  Functor2(const FunctorT& functor, P1 p1, P2 p2)
207      : functor_(functor),
208      p1_(p1),
209      p2_(p2) {}
210  R operator()() const {
211    return functor_(p1_, p2_); }
212 private:
213  FunctorT functor_;
214  P1 p1_;
215  P2 p2_;
216};
217
218
219#define FP_T(x) R (ObjectT::*x)(P1, P2)
220
221template <class ObjectT, class R,
222          class P1,
223          class P2>
224MethodFunctor2<ObjectT, FP_T(NONAME), R, P1, P2>
225Bind(FP_T(method), ObjectT* object,
226     typename detail::identity<P1>::type p1,
227     typename detail::identity<P2>::type p2) {
228  return MethodFunctor2<ObjectT, FP_T(NONAME), R, P1, P2>(
229      method, object, p1, p2);
230}
231
232#undef FP_T
233#define FP_T(x) R (ObjectT::*x)(P1, P2) const
234
235template <class ObjectT, class R,
236          class P1,
237          class P2>
238MethodFunctor2<const ObjectT, FP_T(NONAME), R, P1, P2>
239Bind(FP_T(method), const ObjectT* object,
240     typename detail::identity<P1>::type p1,
241     typename detail::identity<P2>::type p2) {
242  return MethodFunctor2<const ObjectT, FP_T(NONAME), R, P1, P2>(
243      method, object, p1, p2);
244}
245
246#undef FP_T
247#define FP_T(x) R (*x)(P1, P2)
248
249template <class R,
250          class P1,
251          class P2>
252Functor2<FP_T(NONAME), R, P1, P2>
253Bind(FP_T(function),
254     typename detail::identity<P1>::type p1,
255     typename detail::identity<P2>::type p2) {
256  return Functor2<FP_T(NONAME), R, P1, P2>(
257      function, p1, p2);
258}
259
260#undef FP_T
261
262template <class ObjectT, class MethodT, class R,
263          class P1,
264          class P2,
265          class P3>
266class MethodFunctor3 {
267 public:
268  MethodFunctor3(MethodT method, ObjectT* object,
269                 P1 p1,
270                 P2 p2,
271                 P3 p3)
272      : method_(method), object_(object),
273      p1_(p1),
274      p2_(p2),
275      p3_(p3) {}
276  R operator()() const {
277    return (object_->*method_)(p1_, p2_, p3_); }
278 private:
279  MethodT method_;
280  ObjectT* object_;
281  P1 p1_;
282  P2 p2_;
283  P3 p3_;
284};
285
286template <class FunctorT, class R,
287          class P1,
288          class P2,
289          class P3>
290class Functor3 {
291 public:
292  Functor3(const FunctorT& functor, P1 p1, P2 p2, P3 p3)
293      : functor_(functor),
294      p1_(p1),
295      p2_(p2),
296      p3_(p3) {}
297  R operator()() const {
298    return functor_(p1_, p2_, p3_); }
299 private:
300  FunctorT functor_;
301  P1 p1_;
302  P2 p2_;
303  P3 p3_;
304};
305
306
307#define FP_T(x) R (ObjectT::*x)(P1, P2, P3)
308
309template <class ObjectT, class R,
310          class P1,
311          class P2,
312          class P3>
313MethodFunctor3<ObjectT, FP_T(NONAME), R, P1, P2, P3>
314Bind(FP_T(method), ObjectT* object,
315     typename detail::identity<P1>::type p1,
316     typename detail::identity<P2>::type p2,
317     typename detail::identity<P3>::type p3) {
318  return MethodFunctor3<ObjectT, FP_T(NONAME), R, P1, P2, P3>(
319      method, object, p1, p2, p3);
320}
321
322#undef FP_T
323#define FP_T(x) R (ObjectT::*x)(P1, P2, P3) const
324
325template <class ObjectT, class R,
326          class P1,
327          class P2,
328          class P3>
329MethodFunctor3<const ObjectT, FP_T(NONAME), R, P1, P2, P3>
330Bind(FP_T(method), const ObjectT* object,
331     typename detail::identity<P1>::type p1,
332     typename detail::identity<P2>::type p2,
333     typename detail::identity<P3>::type p3) {
334  return MethodFunctor3<const ObjectT, FP_T(NONAME), R, P1, P2, P3>(
335      method, object, p1, p2, p3);
336}
337
338#undef FP_T
339#define FP_T(x) R (*x)(P1, P2, P3)
340
341template <class R,
342          class P1,
343          class P2,
344          class P3>
345Functor3<FP_T(NONAME), R, P1, P2, P3>
346Bind(FP_T(function),
347     typename detail::identity<P1>::type p1,
348     typename detail::identity<P2>::type p2,
349     typename detail::identity<P3>::type p3) {
350  return Functor3<FP_T(NONAME), R, P1, P2, P3>(
351      function, p1, p2, p3);
352}
353
354#undef FP_T
355
356template <class ObjectT, class MethodT, class R,
357          class P1,
358          class P2,
359          class P3,
360          class P4>
361class MethodFunctor4 {
362 public:
363  MethodFunctor4(MethodT method, ObjectT* object,
364                 P1 p1,
365                 P2 p2,
366                 P3 p3,
367                 P4 p4)
368      : method_(method), object_(object),
369      p1_(p1),
370      p2_(p2),
371      p3_(p3),
372      p4_(p4) {}
373  R operator()() const {
374    return (object_->*method_)(p1_, p2_, p3_, p4_); }
375 private:
376  MethodT method_;
377  ObjectT* object_;
378  P1 p1_;
379  P2 p2_;
380  P3 p3_;
381  P4 p4_;
382};
383
384template <class FunctorT, class R,
385          class P1,
386          class P2,
387          class P3,
388          class P4>
389class Functor4 {
390 public:
391  Functor4(const FunctorT& functor, P1 p1, P2 p2, P3 p3, P4 p4)
392      : functor_(functor),
393      p1_(p1),
394      p2_(p2),
395      p3_(p3),
396      p4_(p4) {}
397  R operator()() const {
398    return functor_(p1_, p2_, p3_, p4_); }
399 private:
400  FunctorT functor_;
401  P1 p1_;
402  P2 p2_;
403  P3 p3_;
404  P4 p4_;
405};
406
407
408#define FP_T(x) R (ObjectT::*x)(P1, P2, P3, P4)
409
410template <class ObjectT, class R,
411          class P1,
412          class P2,
413          class P3,
414          class P4>
415MethodFunctor4<ObjectT, FP_T(NONAME), R, P1, P2, P3, P4>
416Bind(FP_T(method), ObjectT* object,
417     typename detail::identity<P1>::type p1,
418     typename detail::identity<P2>::type p2,
419     typename detail::identity<P3>::type p3,
420     typename detail::identity<P4>::type p4) {
421  return MethodFunctor4<ObjectT, FP_T(NONAME), R, P1, P2, P3, P4>(
422      method, object, p1, p2, p3, p4);
423}
424
425#undef FP_T
426#define FP_T(x) R (ObjectT::*x)(P1, P2, P3, P4) const
427
428template <class ObjectT, class R,
429          class P1,
430          class P2,
431          class P3,
432          class P4>
433MethodFunctor4<const ObjectT, FP_T(NONAME), R, P1, P2, P3, P4>
434Bind(FP_T(method), const ObjectT* object,
435     typename detail::identity<P1>::type p1,
436     typename detail::identity<P2>::type p2,
437     typename detail::identity<P3>::type p3,
438     typename detail::identity<P4>::type p4) {
439  return MethodFunctor4<const ObjectT, FP_T(NONAME), R, P1, P2, P3, P4>(
440      method, object, p1, p2, p3, p4);
441}
442
443#undef FP_T
444#define FP_T(x) R (*x)(P1, P2, P3, P4)
445
446template <class R,
447          class P1,
448          class P2,
449          class P3,
450          class P4>
451Functor4<FP_T(NONAME), R, P1, P2, P3, P4>
452Bind(FP_T(function),
453     typename detail::identity<P1>::type p1,
454     typename detail::identity<P2>::type p2,
455     typename detail::identity<P3>::type p3,
456     typename detail::identity<P4>::type p4) {
457  return Functor4<FP_T(NONAME), R, P1, P2, P3, P4>(
458      function, p1, p2, p3, p4);
459}
460
461#undef FP_T
462
463template <class ObjectT, class MethodT, class R,
464          class P1,
465          class P2,
466          class P3,
467          class P4,
468          class P5>
469class MethodFunctor5 {
470 public:
471  MethodFunctor5(MethodT method, ObjectT* object,
472                 P1 p1,
473                 P2 p2,
474                 P3 p3,
475                 P4 p4,
476                 P5 p5)
477      : method_(method), object_(object),
478      p1_(p1),
479      p2_(p2),
480      p3_(p3),
481      p4_(p4),
482      p5_(p5) {}
483  R operator()() const {
484    return (object_->*method_)(p1_, p2_, p3_, p4_, p5_); }
485 private:
486  MethodT method_;
487  ObjectT* object_;
488  P1 p1_;
489  P2 p2_;
490  P3 p3_;
491  P4 p4_;
492  P5 p5_;
493};
494
495template <class FunctorT, class R,
496          class P1,
497          class P2,
498          class P3,
499          class P4,
500          class P5>
501class Functor5 {
502 public:
503  Functor5(const FunctorT& functor, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
504      : functor_(functor),
505      p1_(p1),
506      p2_(p2),
507      p3_(p3),
508      p4_(p4),
509      p5_(p5) {}
510  R operator()() const {
511    return functor_(p1_, p2_, p3_, p4_, p5_); }
512 private:
513  FunctorT functor_;
514  P1 p1_;
515  P2 p2_;
516  P3 p3_;
517  P4 p4_;
518  P5 p5_;
519};
520
521
522#define FP_T(x) R (ObjectT::*x)(P1, P2, P3, P4, P5)
523
524template <class ObjectT, class R,
525          class P1,
526          class P2,
527          class P3,
528          class P4,
529          class P5>
530MethodFunctor5<ObjectT, FP_T(NONAME), R, P1, P2, P3, P4, P5>
531Bind(FP_T(method), ObjectT* object,
532     typename detail::identity<P1>::type p1,
533     typename detail::identity<P2>::type p2,
534     typename detail::identity<P3>::type p3,
535     typename detail::identity<P4>::type p4,
536     typename detail::identity<P5>::type p5) {
537  return MethodFunctor5<ObjectT, FP_T(NONAME), R, P1, P2, P3, P4, P5>(
538      method, object, p1, p2, p3, p4, p5);
539}
540
541#undef FP_T
542#define FP_T(x) R (ObjectT::*x)(P1, P2, P3, P4, P5) const
543
544template <class ObjectT, class R,
545          class P1,
546          class P2,
547          class P3,
548          class P4,
549          class P5>
550MethodFunctor5<const ObjectT, FP_T(NONAME), R, P1, P2, P3, P4, P5>
551Bind(FP_T(method), const ObjectT* object,
552     typename detail::identity<P1>::type p1,
553     typename detail::identity<P2>::type p2,
554     typename detail::identity<P3>::type p3,
555     typename detail::identity<P4>::type p4,
556     typename detail::identity<P5>::type p5) {
557  return MethodFunctor5<const ObjectT, FP_T(NONAME), R, P1, P2, P3, P4, P5>(
558      method, object, p1, p2, p3, p4, p5);
559}
560
561#undef FP_T
562#define FP_T(x) R (*x)(P1, P2, P3, P4, P5)
563
564template <class R,
565          class P1,
566          class P2,
567          class P3,
568          class P4,
569          class P5>
570Functor5<FP_T(NONAME), R, P1, P2, P3, P4, P5>
571Bind(FP_T(function),
572     typename detail::identity<P1>::type p1,
573     typename detail::identity<P2>::type p2,
574     typename detail::identity<P3>::type p3,
575     typename detail::identity<P4>::type p4,
576     typename detail::identity<P5>::type p5) {
577  return Functor5<FP_T(NONAME), R, P1, P2, P3, P4, P5>(
578      function, p1, p2, p3, p4, p5);
579}
580
581#undef FP_T
582
583}  // namespace rtc
584
585#undef NONAME
586
587#endif  // WEBRTC_BASE_BIND_H_
588