1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef BASE_CALLBACK_OLD_H_ 6 #define BASE_CALLBACK_OLD_H_ 7 #pragma once 8 9 #include "base/memory/raw_scoped_refptr_mismatch_checker.h" 10 #include "base/tuple.h" 11 12 // Callback -------------------------------------------------------------------- 13 // 14 // A Callback is like a Task but with unbound parameters. It is basically an 15 // object-oriented function pointer. 16 // 17 // Callbacks are designed to work with Tuples. A set of helper functions and 18 // classes is provided to hide the Tuple details from the consumer. Client 19 // code will generally work with the CallbackRunner base class, which merely 20 // provides a Run method and is returned by the New* functions. This allows 21 // users to not care which type of class implements the callback, only that it 22 // has a certain number and type of arguments. 23 // 24 // The implementation of this is done by CallbackImpl, which inherits 25 // CallbackStorage to store the data. This allows the storage of the data 26 // (requiring the class type T) to be hidden from users, who will want to call 27 // this regardless of the implementor's type T. 28 // 29 // Note that callbacks currently have no facility for cancelling or abandoning 30 // them. We currently handle this at a higher level for cases where this is 31 // necessary. The pointer in a callback must remain valid until the callback 32 // is made. 33 // 34 // Like Task, the callback executor is responsible for deleting the callback 35 // pointer once the callback has executed. 36 // 37 // Example client usage: 38 // void Object::DoStuff(int, string); 39 // Callback2<int, string>::Type* callback = 40 // NewCallback(obj, &Object::DoStuff); 41 // callback->Run(5, string("hello")); 42 // delete callback; 43 // or, equivalently, using tuples directly: 44 // CallbackRunner<Tuple2<int, string> >* callback = 45 // NewCallback(obj, &Object::DoStuff); 46 // callback->RunWithParams(MakeTuple(5, string("hello"))); 47 // 48 // There is also a 0-args version that returns a value. Example: 49 // int Object::GetNextInt(); 50 // CallbackWithReturnValue<int>::Type* callback = 51 // NewCallbackWithReturnValue(obj, &Object::GetNextInt); 52 // int next_int = callback->Run(); 53 // delete callback; 54 55 // Base for all Callbacks that handles storage of the pointers. 56 template <class T, typename Method> 57 class CallbackStorage { 58 public: 59 CallbackStorage(T* obj, Method meth) : obj_(obj), meth_(meth) { 60 } 61 62 protected: 63 T* obj_; 64 Method meth_; 65 }; 66 67 // Interface that is exposed to the consumer, that does the actual calling 68 // of the method. 69 template <typename Params> 70 class CallbackRunner { 71 public: 72 typedef Params TupleType; 73 74 virtual ~CallbackRunner() {} 75 virtual void RunWithParams(const Params& params) = 0; 76 77 // Convenience functions so callers don't have to deal with Tuples. 78 inline void Run() { 79 RunWithParams(Tuple0()); 80 } 81 82 template <typename Arg1> 83 inline void Run(const Arg1& a) { 84 RunWithParams(Params(a)); 85 } 86 87 template <typename Arg1, typename Arg2> 88 inline void Run(const Arg1& a, const Arg2& b) { 89 RunWithParams(Params(a, b)); 90 } 91 92 template <typename Arg1, typename Arg2, typename Arg3> 93 inline void Run(const Arg1& a, const Arg2& b, const Arg3& c) { 94 RunWithParams(Params(a, b, c)); 95 } 96 97 template <typename Arg1, typename Arg2, typename Arg3, typename Arg4> 98 inline void Run(const Arg1& a, const Arg2& b, const Arg3& c, const Arg4& d) { 99 RunWithParams(Params(a, b, c, d)); 100 } 101 102 template <typename Arg1, typename Arg2, typename Arg3, 103 typename Arg4, typename Arg5> 104 inline void Run(const Arg1& a, const Arg2& b, const Arg3& c, 105 const Arg4& d, const Arg5& e) { 106 RunWithParams(Params(a, b, c, d, e)); 107 } 108 }; 109 110 template <class T, typename Method, typename Params> 111 class CallbackImpl : public CallbackStorage<T, Method>, 112 public CallbackRunner<Params> { 113 public: 114 CallbackImpl(T* obj, Method meth) : CallbackStorage<T, Method>(obj, meth) { 115 } 116 virtual void RunWithParams(const Params& params) { 117 // use "this->" to force C++ to look inside our templatized base class; see 118 // Effective C++, 3rd Ed, item 43, p210 for details. 119 DispatchToMethod(this->obj_, this->meth_, params); 120 } 121 }; 122 123 // 0-arg implementation 124 struct Callback0 { 125 typedef CallbackRunner<Tuple0> Type; 126 }; 127 128 template <class T> 129 typename Callback0::Type* NewCallback(T* object, void (T::*method)()) { 130 return new CallbackImpl<T, void (T::*)(), Tuple0 >(object, method); 131 } 132 133 // 1-arg implementation 134 template <typename Arg1> 135 struct Callback1 { 136 typedef CallbackRunner<Tuple1<Arg1> > Type; 137 }; 138 139 template <class T, typename Arg1> 140 typename Callback1<Arg1>::Type* NewCallback(T* object, 141 void (T::*method)(Arg1)) { 142 return new CallbackImpl<T, void (T::*)(Arg1), Tuple1<Arg1> >(object, method); 143 } 144 145 // 2-arg implementation 146 template <typename Arg1, typename Arg2> 147 struct Callback2 { 148 typedef CallbackRunner<Tuple2<Arg1, Arg2> > Type; 149 }; 150 151 template <class T, typename Arg1, typename Arg2> 152 typename Callback2<Arg1, Arg2>::Type* NewCallback( 153 T* object, 154 void (T::*method)(Arg1, Arg2)) { 155 return new CallbackImpl<T, void (T::*)(Arg1, Arg2), 156 Tuple2<Arg1, Arg2> >(object, method); 157 } 158 159 // 3-arg implementation 160 template <typename Arg1, typename Arg2, typename Arg3> 161 struct Callback3 { 162 typedef CallbackRunner<Tuple3<Arg1, Arg2, Arg3> > Type; 163 }; 164 165 template <class T, typename Arg1, typename Arg2, typename Arg3> 166 typename Callback3<Arg1, Arg2, Arg3>::Type* NewCallback( 167 T* object, 168 void (T::*method)(Arg1, Arg2, Arg3)) { 169 return new CallbackImpl<T, void (T::*)(Arg1, Arg2, Arg3), 170 Tuple3<Arg1, Arg2, Arg3> >(object, method); 171 } 172 173 // 4-arg implementation 174 template <typename Arg1, typename Arg2, typename Arg3, typename Arg4> 175 struct Callback4 { 176 typedef CallbackRunner<Tuple4<Arg1, Arg2, Arg3, Arg4> > Type; 177 }; 178 179 template <class T, typename Arg1, typename Arg2, typename Arg3, typename Arg4> 180 typename Callback4<Arg1, Arg2, Arg3, Arg4>::Type* NewCallback( 181 T* object, 182 void (T::*method)(Arg1, Arg2, Arg3, Arg4)) { 183 return new CallbackImpl<T, void (T::*)(Arg1, Arg2, Arg3, Arg4), 184 Tuple4<Arg1, Arg2, Arg3, Arg4> >(object, method); 185 } 186 187 // 5-arg implementation 188 template <typename Arg1, typename Arg2, typename Arg3, 189 typename Arg4, typename Arg5> 190 struct Callback5 { 191 typedef CallbackRunner<Tuple5<Arg1, Arg2, Arg3, Arg4, Arg5> > Type; 192 }; 193 194 template <class T, typename Arg1, typename Arg2, 195 typename Arg3, typename Arg4, typename Arg5> 196 typename Callback5<Arg1, Arg2, Arg3, Arg4, Arg5>::Type* NewCallback( 197 T* object, 198 void (T::*method)(Arg1, Arg2, Arg3, Arg4, Arg5)) { 199 return new CallbackImpl<T, void (T::*)(Arg1, Arg2, Arg3, Arg4, Arg5), 200 Tuple5<Arg1, Arg2, Arg3, Arg4, Arg5> >(object, method); 201 } 202 203 // An UnboundMethod is a wrapper for a method where the actual object is 204 // provided at Run dispatch time. 205 template <class T, class Method, class Params> 206 class UnboundMethod { 207 public: 208 UnboundMethod(Method m, const Params& p) : m_(m), p_(p) { 209 COMPILE_ASSERT( 210 (base::internal::ParamsUseScopedRefptrCorrectly<Params>::value), 211 badunboundmethodparams); 212 } 213 void Run(T* obj) const { 214 DispatchToMethod(obj, m_, p_); 215 } 216 private: 217 Method m_; 218 Params p_; 219 }; 220 221 // Return value implementation with no args. 222 template <typename ReturnValue> 223 struct CallbackWithReturnValue { 224 class Type { 225 public: 226 virtual ~Type() {} 227 virtual ReturnValue Run() = 0; 228 }; 229 }; 230 231 template <class T, typename Method, typename ReturnValue> 232 class CallbackWithReturnValueImpl 233 : public CallbackStorage<T, Method>, 234 public CallbackWithReturnValue<ReturnValue>::Type { 235 public: 236 CallbackWithReturnValueImpl(T* obj, Method meth) 237 : CallbackStorage<T, Method>(obj, meth) {} 238 239 virtual ReturnValue Run() { 240 return (this->obj_->*(this->meth_))(); 241 } 242 243 protected: 244 virtual ~CallbackWithReturnValueImpl() {} 245 }; 246 247 template <class T, typename ReturnValue> 248 typename CallbackWithReturnValue<ReturnValue>::Type* 249 NewCallbackWithReturnValue(T* object, ReturnValue (T::*method)()) { 250 return new CallbackWithReturnValueImpl<T, ReturnValue (T::*)(), ReturnValue>( 251 object, method); 252 } 253 254 #endif // BASE_CALLBACK_OLD_H_ 255
