1/*
2 *  Copyright 2012 The WebRTC Project Authors. All rights reserved.
3 *
4 *  Use of this source code is governed by a BSD-style license
5 *  that can be found in the LICENSE file in the root of the source
6 *  tree. An additional intellectual property rights grant can be found
7 *  in the file PATENTS.  All contributing project authors may
8 *  be found in the AUTHORS file in the root of the source tree.
9 */
10
11// To generate callback.h from callback.h.pump, execute:
12// /home/build/google3/third_party/gtest/scripts/pump.py callback.h.pump
13
14// Callbacks are callable object containers. They can hold a function pointer
15// or a function object and behave like a value type. Internally, data is
16// reference-counted, making copies and pass-by-value inexpensive.
17//
18// Callbacks are typed using template arguments.  The format is:
19//   CallbackN<ReturnType, ParamType1, ..., ParamTypeN>
20// where N is the number of arguments supplied to the callable object.
21// Callbacks are invoked using operator(), just like a function or a function
22// object. Default-constructed callbacks are "empty," and executing an empty
23// callback does nothing. A callback can be made empty by assigning it from
24// a default-constructed callback.
25//
26// Callbacks are similar in purpose to std::function (which isn't available on
27// all platforms we support) and a lightweight alternative to sigslots. Since
28// they effectively hide the type of the object they call, they're useful in
29// breaking dependencies between objects that need to interact with one another.
30// Notably, they can hold the results of Bind(), std::bind*, etc, without needing
31// to know the resulting object type of those calls.
32//
33// Sigslots, on the other hand, provide a fuller feature set, such as multiple
34// subscriptions to a signal, optional thread-safety, and lifetime tracking of
35// slots. When these features are needed, choose sigslots.
36//
37// Example:
38//   int sqr(int x) { return x * x; }
39//   struct AddK {
40//     int k;
41//     int operator()(int x) const { return x + k; }
42//   } add_k = {5};
43//
44//   Callback1<int, int> my_callback;
45//   cout << my_callback.empty() << endl;  // true
46//
47//   my_callback = Callback1<int, int>(&sqr);
48//   cout << my_callback.empty() << endl;  // false
49//   cout << my_callback(3) << endl;  // 9
50//
51//   my_callback = Callback1<int, int>(add_k);
52//   cout << my_callback(10) << endl;  // 15
53//
54//   my_callback = Callback1<int, int>();
55//   cout << my_callback.empty() << endl;  // true
56
57#ifndef WEBRTC_BASE_CALLBACK_H_
58#define WEBRTC_BASE_CALLBACK_H_
59
60#include "webrtc/base/refcount.h"
61#include "webrtc/base/scoped_ref_ptr.h"
62
63namespace rtc {
64
65$var n = 5
66$range i 0..n
67$for i [[
68$range j 1..i
69
70template <class R$for j [[,
71          class P$j]]>
72class Callback$i {
73 public:
74  // Default copy operations are appropriate for this class.
75  Callback$i() {}
76  template <class T> Callback$i(const T& functor)
77      : helper_(new RefCountedObject< HelperImpl<T> >(functor)) {}
78  R operator()($for j , [[P$j p$j]]) {
79    if (empty())
80      return R();
81    return helper_->Run($for j , [[p$j]]);
82  }
83  bool empty() const { return !helper_; }
84
85 private:
86  struct Helper : RefCountInterface {
87    virtual ~Helper() {}
88    virtual R Run($for j , [[P$j p$j]]) = 0;
89  };
90  template <class T> struct HelperImpl : Helper {
91    explicit HelperImpl(const T& functor) : functor_(functor) {}
92    virtual R Run($for j , [[P$j p$j]]) {
93      return functor_($for j , [[p$j]]);
94    }
95    T functor_;
96  };
97  scoped_refptr<Helper> helper_;
98};
99
100]]
101}  // namespace rtc
102
103#endif  // WEBRTC_BASE_CALLBACK_H_
104