1// This file was GENERATED by command:
2//     pump.py callback.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 callback.h from callback.h.pump, execute:
16// /home/build/google3/third_party/gtest/scripts/pump.py callback.h.pump
17
18// Callbacks are callable object containers. They can hold a function pointer
19// or a function object and behave like a value type. Internally, data is
20// reference-counted, making copies and pass-by-value inexpensive.
21//
22// Callbacks are typed using template arguments.  The format is:
23//   CallbackN<ReturnType, ParamType1, ..., ParamTypeN>
24// where N is the number of arguments supplied to the callable object.
25// Callbacks are invoked using operator(), just like a function or a function
26// object. Default-constructed callbacks are "empty," and executing an empty
27// callback does nothing. A callback can be made empty by assigning it from
28// a default-constructed callback.
29//
30// Callbacks are similar in purpose to std::function (which isn't available on
31// all platforms we support) and a lightweight alternative to sigslots. Since
32// they effectively hide the type of the object they call, they're useful in
33// breaking dependencies between objects that need to interact with one another.
34// Notably, they can hold the results of Bind(), std::bind*, etc, without
35// needing
36// to know the resulting object type of those calls.
37//
38// Sigslots, on the other hand, provide a fuller feature set, such as multiple
39// subscriptions to a signal, optional thread-safety, and lifetime tracking of
40// slots. When these features are needed, choose sigslots.
41//
42// Example:
43//   int sqr(int x) { return x * x; }
44//   struct AddK {
45//     int k;
46//     int operator()(int x) const { return x + k; }
47//   } add_k = {5};
48//
49//   Callback1<int, int> my_callback;
50//   cout << my_callback.empty() << endl;  // true
51//
52//   my_callback = Callback1<int, int>(&sqr);
53//   cout << my_callback.empty() << endl;  // false
54//   cout << my_callback(3) << endl;  // 9
55//
56//   my_callback = Callback1<int, int>(add_k);
57//   cout << my_callback(10) << endl;  // 15
58//
59//   my_callback = Callback1<int, int>();
60//   cout << my_callback.empty() << endl;  // true
61
62#ifndef WEBRTC_BASE_CALLBACK_H_
63#define WEBRTC_BASE_CALLBACK_H_
64
65#include "webrtc/base/logging.h"
66#include "webrtc/base/refcount.h"
67#include "webrtc/base/scoped_ref_ptr.h"
68
69namespace rtc {
70
71template <class R>
72class Callback0 {
73 public:
74  // Default copy operations are appropriate for this class.
75  Callback0() {}
76  template <class T> Callback0(const T& functor)
77      : helper_(new RefCountedObject< HelperImpl<T> >(functor)) {}
78  R operator()() {
79    if (empty())
80      return R();
81    return helper_->Run();
82  }
83  bool empty() const { return !helper_; }
84
85 private:
86  struct Helper : RefCountInterface {
87    virtual ~Helper() {}
88    virtual R Run() = 0;
89  };
90  template <class T> struct HelperImpl : Helper {
91    explicit HelperImpl(const T& functor) : functor_(functor) {}
92    virtual R Run() {
93      return functor_();
94    }
95    T functor_;
96  };
97  scoped_refptr<Helper> helper_;
98};
99
100template <class R,
101          class P1>
102class Callback1 {
103 public:
104  // Default copy operations are appropriate for this class.
105  Callback1() {}
106  template <class T> Callback1(const T& functor)
107      : helper_(new RefCountedObject< HelperImpl<T> >(functor)) {}
108  R operator()(P1 p1) {
109    if (empty())
110      return R();
111    return helper_->Run(p1);
112  }
113  bool empty() const { return !helper_; }
114
115 private:
116  struct Helper : RefCountInterface {
117    virtual ~Helper() {}
118    virtual R Run(P1 p1) = 0;
119  };
120  template <class T> struct HelperImpl : Helper {
121    explicit HelperImpl(const T& functor) : functor_(functor) {}
122    virtual R Run(P1 p1) {
123      return functor_(p1);
124    }
125    T functor_;
126  };
127  scoped_refptr<Helper> helper_;
128};
129
130template <class R,
131          class P1,
132          class P2>
133class Callback2 {
134 public:
135  // Default copy operations are appropriate for this class.
136  Callback2() {}
137  template <class T> Callback2(const T& functor)
138      : helper_(new RefCountedObject< HelperImpl<T> >(functor)) {}
139  R operator()(P1 p1, P2 p2) {
140    if (empty())
141      return R();
142    return helper_->Run(p1, p2);
143  }
144  bool empty() const { return !helper_; }
145
146 private:
147  struct Helper : RefCountInterface {
148    virtual ~Helper() {}
149    virtual R Run(P1 p1, P2 p2) = 0;
150  };
151  template <class T> struct HelperImpl : Helper {
152    explicit HelperImpl(const T& functor) : functor_(functor) {}
153    virtual R Run(P1 p1, P2 p2) {
154      return functor_(p1, p2);
155    }
156    T functor_;
157  };
158  scoped_refptr<Helper> helper_;
159};
160
161template <class R,
162          class P1,
163          class P2,
164          class P3>
165class Callback3 {
166 public:
167  // Default copy operations are appropriate for this class.
168  Callback3() {}
169  template <class T> Callback3(const T& functor)
170      : helper_(new RefCountedObject< HelperImpl<T> >(functor)) {}
171  R operator()(P1 p1, P2 p2, P3 p3) {
172    if (empty())
173      return R();
174    return helper_->Run(p1, p2, p3);
175  }
176  bool empty() const { return !helper_; }
177
178 private:
179  struct Helper : RefCountInterface {
180    virtual ~Helper() {}
181    virtual R Run(P1 p1, P2 p2, P3 p3) = 0;
182  };
183  template <class T> struct HelperImpl : Helper {
184    explicit HelperImpl(const T& functor) : functor_(functor) {}
185    virtual R Run(P1 p1, P2 p2, P3 p3) {
186      return functor_(p1, p2, p3);
187    }
188    T functor_;
189  };
190  scoped_refptr<Helper> helper_;
191};
192
193template <class R,
194          class P1,
195          class P2,
196          class P3,
197          class P4>
198class Callback4 {
199 public:
200  // Default copy operations are appropriate for this class.
201  Callback4() {}
202  template <class T> Callback4(const T& functor)
203      : helper_(new RefCountedObject< HelperImpl<T> >(functor)) {}
204  R operator()(P1 p1, P2 p2, P3 p3, P4 p4) {
205    if (empty())
206      return R();
207    return helper_->Run(p1, p2, p3, p4);
208  }
209  bool empty() const { return !helper_; }
210
211 private:
212  struct Helper : RefCountInterface {
213    virtual ~Helper() {}
214    virtual R Run(P1 p1, P2 p2, P3 p3, P4 p4) = 0;
215  };
216  template <class T> struct HelperImpl : Helper {
217    explicit HelperImpl(const T& functor) : functor_(functor) {}
218    virtual R Run(P1 p1, P2 p2, P3 p3, P4 p4) {
219      return functor_(p1, p2, p3, p4);
220    }
221    T functor_;
222  };
223  scoped_refptr<Helper> helper_;
224};
225
226template <class R,
227          class P1,
228          class P2,
229          class P3,
230          class P4,
231          class P5>
232class Callback5 {
233 public:
234  // Default copy operations are appropriate for this class.
235  Callback5() {}
236  template <class T> Callback5(const T& functor)
237      : helper_(new RefCountedObject< HelperImpl<T> >(functor)) {}
238  R operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) {
239    if (empty())
240      return R();
241    return helper_->Run(p1, p2, p3, p4, p5);
242  }
243  bool empty() const { return !helper_; }
244
245 private:
246  struct Helper : RefCountInterface {
247    virtual ~Helper() {}
248    virtual R Run(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) = 0;
249  };
250  template <class T> struct HelperImpl : Helper {
251    explicit HelperImpl(const T& functor) : functor_(functor) {}
252    virtual R Run(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) {
253      return functor_(p1, p2, p3, p4, p5);
254    }
255    T functor_;
256  };
257  scoped_refptr<Helper> helper_;
258};
259}  // namespace rtc
260
261#endif  // WEBRTC_BASE_CALLBACK_H_
262