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 bind.h from bind.h.pump, execute:
12// /home/build/google3/third_party/gtest/scripts/pump.py bind.h.pump
13
14// Bind() is an overloaded function that converts method calls into function
15// objects (aka functors). The method object is captured as a scoped_refptr<> if
16// possible, and as a raw pointer otherwise. Any arguments to the method are
17// captured by value. The return value of Bind is a stateful, nullary function
18// object. Care should be taken about the lifetime of objects captured by
19// Bind(); the returned functor knows nothing about the lifetime of a non
20// ref-counted method object or any arguments passed by pointer, and calling the
21// functor with a destroyed object will surely do bad things.
22//
23// Example usage:
24//   struct Foo {
25//     int Test1() { return 42; }
26//     int Test2() const { return 52; }
27//     int Test3(int x) { return x*x; }
28//     float Test4(int x, float y) { return x + y; }
29//   };
30//
31//   int main() {
32//     Foo foo;
33//     cout << rtc::Bind(&Foo::Test1, &foo)() << endl;
34//     cout << rtc::Bind(&Foo::Test2, &foo)() << endl;
35//     cout << rtc::Bind(&Foo::Test3, &foo, 3)() << endl;
36//     cout << rtc::Bind(&Foo::Test4, &foo, 7, 8.5f)() << endl;
37//   }
38//
39// Example usage of ref counted objects:
40//   struct Bar {
41//     int AddRef();
42//     int Release();
43//
44//     void Test() {}
45//     void BindThis() {
46//       // The functor passed to AsyncInvoke() will keep this object alive.
47//       invoker.AsyncInvoke(RTC_FROM_HERE,rtc::Bind(&Bar::Test, this));
48//     }
49//   };
50//
51//   int main() {
52//     rtc::scoped_refptr<Bar> bar = new rtc::RefCountedObject<Bar>();
53//     auto functor = rtc::Bind(&Bar::Test, bar);
54//     bar = nullptr;
55//     // The functor stores an internal scoped_refptr<Bar>, so this is safe.
56//     functor();
57//   }
58//
59
60#ifndef WEBRTC_BASE_BIND_H_
61#define WEBRTC_BASE_BIND_H_
62
63#include "webrtc/base/scoped_ref_ptr.h"
64#include "webrtc/base/template_util.h"
65
66#define NONAME
67
68namespace rtc {
69namespace detail {
70// This is needed because the template parameters in Bind can't be resolved
71// if they're used both as parameters of the function pointer type and as
72// parameters to Bind itself: the function pointer parameters are exact
73// matches to the function prototype, but the parameters to bind have
74// references stripped. This trick allows the compiler to dictate the Bind
75// parameter types rather than deduce them.
76template <class T> struct identity { typedef T type; };
77
78// IsRefCounted<T>::value will be true for types that can be used in
79// rtc::scoped_refptr<T>, i.e. types that implements nullary functions AddRef()
80// and Release(), regardless of their return types. AddRef() and Release() can
81// be defined in T or any superclass of T.
82template <typename T>
83class IsRefCounted {
84  // This is a complex implementation detail done with SFINAE.
85
86  // Define types such that sizeof(Yes) != sizeof(No).
87  struct Yes { char dummy[1]; };
88  struct No { char dummy[2]; };
89  // Define two overloaded template functions with return types of different
90  // size. This way, we can use sizeof() on the return type to determine which
91  // function the compiler would have chosen. One function will be preferred
92  // over the other if it is possible to create it without compiler errors,
93  // otherwise the compiler will simply remove it, and default to the less
94  // preferred function.
95  template <typename R>
96  static Yes test(R* r, decltype(r->AddRef(), r->Release(), 42));
97  template <typename C> static No test(...);
98
99public:
100  // Trick the compiler to tell if it's possible to call AddRef() and Release().
101  static const bool value = sizeof(test<T>((T*)nullptr, 42)) == sizeof(Yes);
102};
103
104// TernaryTypeOperator is a helper class to select a type based on a static bool
105// value.
106template <bool condition, typename IfTrueT, typename IfFalseT>
107struct TernaryTypeOperator {};
108
109template <typename IfTrueT, typename IfFalseT>
110struct TernaryTypeOperator<true, IfTrueT, IfFalseT> {
111  typedef IfTrueT type;
112};
113
114template <typename IfTrueT, typename IfFalseT>
115struct TernaryTypeOperator<false, IfTrueT, IfFalseT> {
116  typedef IfFalseT type;
117};
118
119// PointerType<T>::type will be scoped_refptr<T> for ref counted types, and T*
120// otherwise.
121template <class T>
122struct PointerType {
123  typedef typename TernaryTypeOperator<IsRefCounted<T>::value,
124                                       scoped_refptr<T>,
125                                       T*>::type type;
126};
127
128}  // namespace detail
129
130$var n = 9
131$range i 0..n
132$for i [[
133$range j 1..i
134
135template <class ObjectT, class MethodT, class R$for j [[,
136          class P$j]]>
137class MethodFunctor$i {
138 public:
139  MethodFunctor$i(MethodT method, ObjectT* object$for j [[,
140                 P$j p$j]])
141      : method_(method), object_(object)$for j [[,
142      p$(j)_(p$j)]] {}
143  R operator()() const {
144    return (object_->*method_)($for j , [[p$(j)_]]); }
145 private:
146  MethodT method_;
147  typename detail::PointerType<ObjectT>::type object_;$for j [[
148
149  typename rtc::remove_reference<P$j>::type p$(j)_;]]
150
151};
152
153template <class FunctorT, class R$for j [[,
154          class P$j]]>
155class Functor$i {
156 public:
157  $if i == 0 [[explicit ]]
158Functor$i(const FunctorT& functor$for j [[, P$j p$j]])
159      : functor_(functor)$for j [[,
160      p$(j)_(p$j)]] {}
161  R operator()() const {
162    return functor_($for j , [[p$(j)_]]); }
163 private:
164  FunctorT functor_;$for j [[
165
166  typename rtc::remove_reference<P$j>::type p$(j)_;]]
167
168};
169
170
171#define FP_T(x) R (ObjectT::*x)($for j , [[P$j]])
172
173template <class ObjectT, class R$for j [[,
174          class P$j]]>
175MethodFunctor$i<ObjectT, FP_T(NONAME), R$for j [[, P$j]]>
176Bind(FP_T(method), ObjectT* object$for j [[,
177     typename detail::identity<P$j>::type p$j]]) {
178  return MethodFunctor$i<ObjectT, FP_T(NONAME), R$for j [[, P$j]]>(
179      method, object$for j [[, p$j]]);
180}
181
182#undef FP_T
183#define FP_T(x) R (ObjectT::*x)($for j , [[P$j]]) const
184
185template <class ObjectT, class R$for j [[,
186          class P$j]]>
187MethodFunctor$i<const ObjectT, FP_T(NONAME), R$for j [[, P$j]]>
188Bind(FP_T(method), const ObjectT* object$for j [[,
189     typename detail::identity<P$j>::type p$j]]) {
190  return MethodFunctor$i<const ObjectT, FP_T(NONAME), R$for j [[, P$j]]>(
191      method, object$for j [[, p$j]]);
192}
193
194#undef FP_T
195#define FP_T(x) R (ObjectT::*x)($for j , [[P$j]])
196
197template <class ObjectT, class R$for j [[,
198          class P$j]]>
199MethodFunctor$i<ObjectT, FP_T(NONAME), R$for j [[, P$j]]>
200Bind(FP_T(method), const scoped_refptr<ObjectT>& object$for j [[,
201     typename detail::identity<P$j>::type p$j]]) {
202  return MethodFunctor$i<ObjectT, FP_T(NONAME), R$for j [[, P$j]]>(
203      method, object.get()$for j [[, p$j]]);
204}
205
206#undef FP_T
207#define FP_T(x) R (*x)($for j , [[P$j]])
208
209template <class R$for j [[,
210          class P$j]]>
211Functor$i<FP_T(NONAME), R$for j [[, P$j]]>
212Bind(FP_T(function)$for j [[,
213     typename detail::identity<P$j>::type p$j]]) {
214  return Functor$i<FP_T(NONAME), R$for j [[, P$j]]>(
215      function$for j [[, p$j]]);
216}
217
218#undef FP_T
219
220]]
221
222}  // namespace rtc
223
224#undef NONAME
225
226#endif  // WEBRTC_BASE_BIND_H_
227