1// This file was GENERATED by command: 2// pump.py callback.h.pump 3// DO NOT EDIT BY HAND!!! 4 5 6// Copyright (c) 2012 The Chromium Authors. All rights reserved. 7// Use of this source code is governed by a BSD-style license that can be 8// found in the LICENSE file. 9 10#ifndef BASE_CALLBACK_H_ 11#define BASE_CALLBACK_H_ 12 13#include "base/callback_forward.h" 14#include "base/callback_internal.h" 15#include "base/template_util.h" 16 17// NOTE: Header files that do not require the full definition of Callback or 18// Closure should #include "base/callback_forward.h" instead of this file. 19 20// ----------------------------------------------------------------------------- 21// Introduction 22// ----------------------------------------------------------------------------- 23// 24// The templated Callback class is a generalized function object. Together 25// with the Bind() function in bind.h, they provide a type-safe method for 26// performing partial application of functions. 27// 28// Partial application (or "currying") is the process of binding a subset of 29// a function's arguments to produce another function that takes fewer 30// arguments. This can be used to pass around a unit of delayed execution, 31// much like lexical closures are used in other languages. For example, it 32// is used in Chromium code to schedule tasks on different MessageLoops. 33// 34// A callback with no unbound input parameters (base::Callback<void(void)>) 35// is called a base::Closure. Note that this is NOT the same as what other 36// languages refer to as a closure -- it does not retain a reference to its 37// enclosing environment. 38// 39// MEMORY MANAGEMENT AND PASSING 40// 41// The Callback objects themselves should be passed by const-reference, and 42// stored by copy. They internally store their state via a refcounted class 43// and thus do not need to be deleted. 44// 45// The reason to pass via a const-reference is to avoid unnecessary 46// AddRef/Release pairs to the internal state. 47// 48// 49// ----------------------------------------------------------------------------- 50// Quick reference for basic stuff 51// ----------------------------------------------------------------------------- 52// 53// BINDING A BARE FUNCTION 54// 55// int Return5() { return 5; } 56// base::Callback<int(void)> func_cb = base::Bind(&Return5); 57// LOG(INFO) << func_cb.Run(); // Prints 5. 58// 59// BINDING A CLASS METHOD 60// 61// The first argument to bind is the member function to call, the second is 62// the object on which to call it. 63// 64// class Ref : public base::RefCountedThreadSafe<Ref> { 65// public: 66// int Foo() { return 3; } 67// void PrintBye() { LOG(INFO) << "bye."; } 68// }; 69// scoped_refptr<Ref> ref = new Ref(); 70// base::Callback<void(void)> ref_cb = base::Bind(&Ref::Foo, ref); 71// LOG(INFO) << ref_cb.Run(); // Prints out 3. 72// 73// By default the object must support RefCounted or you will get a compiler 74// error. If you're passing between threads, be sure it's 75// RefCountedThreadSafe! See "Advanced binding of member functions" below if 76// you don't want to use reference counting. 77// 78// RUNNING A CALLBACK 79// 80// Callbacks can be run with their "Run" method, which has the same 81// signature as the template argument to the callback. 82// 83// void DoSomething(const base::Callback<void(int, std::string)>& callback) { 84// callback.Run(5, "hello"); 85// } 86// 87// Callbacks can be run more than once (they don't get deleted or marked when 88// run). However, this precludes using base::Passed (see below). 89// 90// void DoSomething(const base::Callback<double(double)>& callback) { 91// double myresult = callback.Run(3.14159); 92// myresult += callback.Run(2.71828); 93// } 94// 95// PASSING UNBOUND INPUT PARAMETERS 96// 97// Unbound parameters are specified at the time a callback is Run(). They are 98// specified in the Callback template type: 99// 100// void MyFunc(int i, const std::string& str) {} 101// base::Callback<void(int, const std::string&)> cb = base::Bind(&MyFunc); 102// cb.Run(23, "hello, world"); 103// 104// PASSING BOUND INPUT PARAMETERS 105// 106// Bound parameters are specified when you create thee callback as arguments 107// to Bind(). They will be passed to the function and the Run()ner of the 108// callback doesn't see those values or even know that the function it's 109// calling. 110// 111// void MyFunc(int i, const std::string& str) {} 112// base::Callback<void(void)> cb = base::Bind(&MyFunc, 23, "hello world"); 113// cb.Run(); 114// 115// A callback with no unbound input parameters (base::Callback<void(void)>) 116// is called a base::Closure. So we could have also written: 117// 118// base::Closure cb = base::Bind(&MyFunc, 23, "hello world"); 119// 120// When calling member functions, bound parameters just go after the object 121// pointer. 122// 123// base::Closure cb = base::Bind(&MyClass::MyFunc, this, 23, "hello world"); 124// 125// PARTIAL BINDING OF PARAMETERS 126// 127// You can specify some parameters when you create the callback, and specify 128// the rest when you execute the callback. 129// 130// void MyFunc(int i, const std::string& str) {} 131// base::Callback<void(const std::string&)> cb = base::Bind(&MyFunc, 23); 132// cb.Run("hello world"); 133// 134// When calling a function bound parameters are first, followed by unbound 135// parameters. 136// 137// 138// ----------------------------------------------------------------------------- 139// Quick reference for advanced binding 140// ----------------------------------------------------------------------------- 141// 142// BINDING A CLASS METHOD WITH WEAK POINTERS 143// 144// base::Bind(&MyClass::Foo, GetWeakPtr()); 145// 146// The callback will not be run if the object has already been destroyed. 147// DANGER: weak pointers are not threadsafe, so don't use this 148// when passing between threads! 149// 150// BINDING A CLASS METHOD WITH MANUAL LIFETIME MANAGEMENT 151// 152// base::Bind(&MyClass::Foo, base::Unretained(this)); 153// 154// This disables all lifetime management on the object. You're responsible 155// for making sure the object is alive at the time of the call. You break it, 156// you own it! 157// 158// BINDING A CLASS METHOD AND HAVING THE CALLBACK OWN THE CLASS 159// 160// MyClass* myclass = new MyClass; 161// base::Bind(&MyClass::Foo, base::Owned(myclass)); 162// 163// The object will be deleted when the callback is destroyed, even if it's 164// not run (like if you post a task during shutdown). Potentially useful for 165// "fire and forget" cases. 166// 167// IGNORING RETURN VALUES 168// 169// Sometimes you want to call a function that returns a value in a callback 170// that doesn't expect a return value. 171// 172// int DoSomething(int arg) { cout << arg << endl; } 173// base::Callback<void<int>) cb = 174// base::Bind(base::IgnoreResult(&DoSomething)); 175// 176// 177// ----------------------------------------------------------------------------- 178// Quick reference for binding parameters to Bind() 179// ----------------------------------------------------------------------------- 180// 181// Bound parameters are specified as arguments to Bind() and are passed to the 182// function. A callback with no parameters or no unbound parameters is called a 183// Closure (base::Callback<void(void)> and base::Closure are the same thing). 184// 185// PASSING PARAMETERS OWNED BY THE CALLBACK 186// 187// void Foo(int* arg) { cout << *arg << endl; } 188// int* pn = new int(1); 189// base::Closure foo_callback = base::Bind(&foo, base::Owned(pn)); 190// 191// The parameter will be deleted when the callback is destroyed, even if it's 192// not run (like if you post a task during shutdown). 193// 194// PASSING PARAMETERS AS A scoped_ptr 195// 196// void TakesOwnership(scoped_ptr<Foo> arg) {} 197// scoped_ptr<Foo> f(new Foo); 198// // f becomes null during the following call. 199// base::Closure cb = base::Bind(&TakesOwnership, base::Passed(&f)); 200// 201// Ownership of the parameter will be with the callback until the it is run, 202// when ownership is passed to the callback function. This means the callback 203// can only be run once. If the callback is never run, it will delete the 204// object when it's destroyed. 205// 206// PASSING PARAMETERS AS A scoped_refptr 207// 208// void TakesOneRef(scoped_refptr<Foo> arg) {} 209// scoped_refptr<Foo> f(new Foo) 210// base::Closure cb = base::Bind(&TakesOneRef, f); 211// 212// This should "just work." The closure will take a reference as long as it 213// is alive, and another reference will be taken for the called function. 214// 215// PASSING PARAMETERS BY REFERENCE 216// 217// Const references are *copied* unless ConstRef is used. Example: 218// 219// void foo(const int& arg) { printf("%d %p\n", arg, &arg); } 220// int n = 1; 221// base::Closure has_copy = base::Bind(&foo, n); 222// base::Closure has_ref = base::Bind(&foo, base::ConstRef(n)); 223// n = 2; 224// foo(n); // Prints "2 0xaaaaaaaaaaaa" 225// has_copy.Run(); // Prints "1 0xbbbbbbbbbbbb" 226// has_ref.Run(); // Prints "2 0xaaaaaaaaaaaa" 227// 228// Normally parameters are copied in the closure. DANGER: ConstRef stores a 229// const reference instead, referencing the original parameter. This means 230// that you must ensure the object outlives the callback! 231// 232// 233// ----------------------------------------------------------------------------- 234// Implementation notes 235// ----------------------------------------------------------------------------- 236// 237// WHERE IS THIS DESIGN FROM: 238// 239// The design Callback and Bind is heavily influenced by C++'s 240// tr1::function/tr1::bind, and by the "Google Callback" system used inside 241// Google. 242// 243// 244// HOW THE IMPLEMENTATION WORKS: 245// 246// There are three main components to the system: 247// 1) The Callback classes. 248// 2) The Bind() functions. 249// 3) The arguments wrappers (e.g., Unretained() and ConstRef()). 250// 251// The Callback classes represent a generic function pointer. Internally, 252// it stores a refcounted piece of state that represents the target function 253// and all its bound parameters. Each Callback specialization has a templated 254// constructor that takes an BindState<>*. In the context of the constructor, 255// the static type of this BindState<> pointer uniquely identifies the 256// function it is representing, all its bound parameters, and a Run() method 257// that is capable of invoking the target. 258// 259// Callback's constructor takes the BindState<>* that has the full static type 260// and erases the target function type as well as the types of the bound 261// parameters. It does this by storing a pointer to the specific Run() 262// function, and upcasting the state of BindState<>* to a 263// BindStateBase*. This is safe as long as this BindStateBase pointer 264// is only used with the stored Run() pointer. 265// 266// To BindState<> objects are created inside the Bind() functions. 267// These functions, along with a set of internal templates, are responsible for 268// 269// - Unwrapping the function signature into return type, and parameters 270// - Determining the number of parameters that are bound 271// - Creating the BindState storing the bound parameters 272// - Performing compile-time asserts to avoid error-prone behavior 273// - Returning an Callback<> with an arity matching the number of unbound 274// parameters and that knows the correct refcounting semantics for the 275// target object if we are binding a method. 276// 277// The Bind functions do the above using type-inference, and template 278// specializations. 279// 280// By default Bind() will store copies of all bound parameters, and attempt 281// to refcount a target object if the function being bound is a class method. 282// These copies are created even if the function takes parameters as const 283// references. (Binding to non-const references is forbidden, see bind.h.) 284// 285// To change this behavior, we introduce a set of argument wrappers 286// (e.g., Unretained(), and ConstRef()). These are simple container templates 287// that are passed by value, and wrap a pointer to argument. See the 288// file-level comment in base/bind_helpers.h for more info. 289// 290// These types are passed to the Unwrap() functions, and the MaybeRefcount() 291// functions respectively to modify the behavior of Bind(). The Unwrap() 292// and MaybeRefcount() functions change behavior by doing partial 293// specialization based on whether or not a parameter is a wrapper type. 294// 295// ConstRef() is similar to tr1::cref. Unretained() is specific to Chromium. 296// 297// 298// WHY NOT TR1 FUNCTION/BIND? 299// 300// Direct use of tr1::function and tr1::bind was considered, but ultimately 301// rejected because of the number of copy constructors invocations involved 302// in the binding of arguments during construction, and the forwarding of 303// arguments during invocation. These copies will no longer be an issue in 304// C++0x because C++0x will support rvalue reference allowing for the compiler 305// to avoid these copies. However, waiting for C++0x is not an option. 306// 307// Measured with valgrind on gcc version 4.4.3 (Ubuntu 4.4.3-4ubuntu5), the 308// tr1::bind call itself will invoke a non-trivial copy constructor three times 309// for each bound parameter. Also, each when passing a tr1::function, each 310// bound argument will be copied again. 311// 312// In addition to the copies taken at binding and invocation, copying a 313// tr1::function causes a copy to be made of all the bound parameters and 314// state. 315// 316// Furthermore, in Chromium, it is desirable for the Callback to take a 317// reference on a target object when representing a class method call. This 318// is not supported by tr1. 319// 320// Lastly, tr1::function and tr1::bind has a more general and flexible API. 321// This includes things like argument reordering by use of 322// tr1::bind::placeholder, support for non-const reference parameters, and some 323// limited amount of subtyping of the tr1::function object (e.g., 324// tr1::function<int(int)> is convertible to tr1::function<void(int)>). 325// 326// These are not features that are required in Chromium. Some of them, such as 327// allowing for reference parameters, and subtyping of functions, may actually 328// become a source of errors. Removing support for these features actually 329// allows for a simpler implementation, and a terser Currying API. 330// 331// 332// WHY NOT GOOGLE CALLBACKS? 333// 334// The Google callback system also does not support refcounting. Furthermore, 335// its implementation has a number of strange edge cases with respect to type 336// conversion of its arguments. In particular, the argument's constness must 337// at times match exactly the function signature, or the type-inference might 338// break. Given the above, writing a custom solution was easier. 339// 340// 341// MISSING FUNCTIONALITY 342// - Invoking the return of Bind. Bind(&foo).Run() does not work; 343// - Binding arrays to functions that take a non-const pointer. 344// Example: 345// void Foo(const char* ptr); 346// void Bar(char* ptr); 347// Bind(&Foo, "test"); 348// Bind(&Bar, "test"); // This fails because ptr is not const. 349 350namespace base { 351 352// First, we forward declare the Callback class template. This informs the 353// compiler that the template only has 1 type parameter which is the function 354// signature that the Callback is representing. 355// 356// After this, create template specializations for 0-7 parameters. Note that 357// even though the template typelist grows, the specialization still 358// only has one type: the function signature. 359// 360// If you are thinking of forward declaring Callback in your own header file, 361// please include "base/callback_forward.h" instead. 362template <typename Sig> 363class Callback; 364 365namespace internal { 366template <typename Runnable, typename RunType, typename BoundArgsType> 367struct BindState; 368} // namespace internal 369 370template <typename R> 371class Callback<R(void)> : public internal::CallbackBase { 372 public: 373 typedef R(RunType)(); 374 375 Callback() : CallbackBase(NULL) { } 376 377 // Note that this constructor CANNOT be explicit, and that Bind() CANNOT 378 // return the exact Callback<> type. See base/bind.h for details. 379 template <typename Runnable, typename BindRunType, typename BoundArgsType> 380 Callback(internal::BindState<Runnable, BindRunType, 381 BoundArgsType>* bind_state) 382 : CallbackBase(bind_state) { 383 384 // Force the assignment to a local variable of PolymorphicInvoke 385 // so the compiler will typecheck that the passed in Run() method has 386 // the correct type. 387 PolymorphicInvoke invoke_func = 388 &internal::BindState<Runnable, BindRunType, BoundArgsType> 389 ::InvokerType::Run; 390 polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func); 391 } 392 393 bool Equals(const Callback& other) const { 394 return CallbackBase::Equals(other); 395 } 396 397 R Run() const { 398 PolymorphicInvoke f = 399 reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_); 400 401 return f(bind_state_.get()); 402 } 403 404 private: 405 typedef R(*PolymorphicInvoke)( 406 internal::BindStateBase*); 407 408}; 409 410template <typename R, typename A1> 411class Callback<R(A1)> : public internal::CallbackBase { 412 public: 413 typedef R(RunType)(A1); 414 415 Callback() : CallbackBase(NULL) { } 416 417 // Note that this constructor CANNOT be explicit, and that Bind() CANNOT 418 // return the exact Callback<> type. See base/bind.h for details. 419 template <typename Runnable, typename BindRunType, typename BoundArgsType> 420 Callback(internal::BindState<Runnable, BindRunType, 421 BoundArgsType>* bind_state) 422 : CallbackBase(bind_state) { 423 424 // Force the assignment to a local variable of PolymorphicInvoke 425 // so the compiler will typecheck that the passed in Run() method has 426 // the correct type. 427 PolymorphicInvoke invoke_func = 428 &internal::BindState<Runnable, BindRunType, BoundArgsType> 429 ::InvokerType::Run; 430 polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func); 431 } 432 433 bool Equals(const Callback& other) const { 434 return CallbackBase::Equals(other); 435 } 436 437 R Run(typename internal::CallbackParamTraits<A1>::ForwardType a1) const { 438 PolymorphicInvoke f = 439 reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_); 440 441 return f(bind_state_.get(), internal::CallbackForward(a1)); 442 } 443 444 private: 445 typedef R(*PolymorphicInvoke)( 446 internal::BindStateBase*, 447 typename internal::CallbackParamTraits<A1>::ForwardType); 448 449}; 450 451template <typename R, typename A1, typename A2> 452class Callback<R(A1, A2)> : public internal::CallbackBase { 453 public: 454 typedef R(RunType)(A1, A2); 455 456 Callback() : CallbackBase(NULL) { } 457 458 // Note that this constructor CANNOT be explicit, and that Bind() CANNOT 459 // return the exact Callback<> type. See base/bind.h for details. 460 template <typename Runnable, typename BindRunType, typename BoundArgsType> 461 Callback(internal::BindState<Runnable, BindRunType, 462 BoundArgsType>* bind_state) 463 : CallbackBase(bind_state) { 464 465 // Force the assignment to a local variable of PolymorphicInvoke 466 // so the compiler will typecheck that the passed in Run() method has 467 // the correct type. 468 PolymorphicInvoke invoke_func = 469 &internal::BindState<Runnable, BindRunType, BoundArgsType> 470 ::InvokerType::Run; 471 polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func); 472 } 473 474 bool Equals(const Callback& other) const { 475 return CallbackBase::Equals(other); 476 } 477 478 R Run(typename internal::CallbackParamTraits<A1>::ForwardType a1, 479 typename internal::CallbackParamTraits<A2>::ForwardType a2) const { 480 PolymorphicInvoke f = 481 reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_); 482 483 return f(bind_state_.get(), internal::CallbackForward(a1), 484 internal::CallbackForward(a2)); 485 } 486 487 private: 488 typedef R(*PolymorphicInvoke)( 489 internal::BindStateBase*, 490 typename internal::CallbackParamTraits<A1>::ForwardType, 491 typename internal::CallbackParamTraits<A2>::ForwardType); 492 493}; 494 495template <typename R, typename A1, typename A2, typename A3> 496class Callback<R(A1, A2, A3)> : public internal::CallbackBase { 497 public: 498 typedef R(RunType)(A1, A2, A3); 499 500 Callback() : CallbackBase(NULL) { } 501 502 // Note that this constructor CANNOT be explicit, and that Bind() CANNOT 503 // return the exact Callback<> type. See base/bind.h for details. 504 template <typename Runnable, typename BindRunType, typename BoundArgsType> 505 Callback(internal::BindState<Runnable, BindRunType, 506 BoundArgsType>* bind_state) 507 : CallbackBase(bind_state) { 508 509 // Force the assignment to a local variable of PolymorphicInvoke 510 // so the compiler will typecheck that the passed in Run() method has 511 // the correct type. 512 PolymorphicInvoke invoke_func = 513 &internal::BindState<Runnable, BindRunType, BoundArgsType> 514 ::InvokerType::Run; 515 polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func); 516 } 517 518 bool Equals(const Callback& other) const { 519 return CallbackBase::Equals(other); 520 } 521 522 R Run(typename internal::CallbackParamTraits<A1>::ForwardType a1, 523 typename internal::CallbackParamTraits<A2>::ForwardType a2, 524 typename internal::CallbackParamTraits<A3>::ForwardType a3) const { 525 PolymorphicInvoke f = 526 reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_); 527 528 return f(bind_state_.get(), internal::CallbackForward(a1), 529 internal::CallbackForward(a2), 530 internal::CallbackForward(a3)); 531 } 532 533 private: 534 typedef R(*PolymorphicInvoke)( 535 internal::BindStateBase*, 536 typename internal::CallbackParamTraits<A1>::ForwardType, 537 typename internal::CallbackParamTraits<A2>::ForwardType, 538 typename internal::CallbackParamTraits<A3>::ForwardType); 539 540}; 541 542template <typename R, typename A1, typename A2, typename A3, typename A4> 543class Callback<R(A1, A2, A3, A4)> : public internal::CallbackBase { 544 public: 545 typedef R(RunType)(A1, A2, A3, A4); 546 547 Callback() : CallbackBase(NULL) { } 548 549 // Note that this constructor CANNOT be explicit, and that Bind() CANNOT 550 // return the exact Callback<> type. See base/bind.h for details. 551 template <typename Runnable, typename BindRunType, typename BoundArgsType> 552 Callback(internal::BindState<Runnable, BindRunType, 553 BoundArgsType>* bind_state) 554 : CallbackBase(bind_state) { 555 556 // Force the assignment to a local variable of PolymorphicInvoke 557 // so the compiler will typecheck that the passed in Run() method has 558 // the correct type. 559 PolymorphicInvoke invoke_func = 560 &internal::BindState<Runnable, BindRunType, BoundArgsType> 561 ::InvokerType::Run; 562 polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func); 563 } 564 565 bool Equals(const Callback& other) const { 566 return CallbackBase::Equals(other); 567 } 568 569 R Run(typename internal::CallbackParamTraits<A1>::ForwardType a1, 570 typename internal::CallbackParamTraits<A2>::ForwardType a2, 571 typename internal::CallbackParamTraits<A3>::ForwardType a3, 572 typename internal::CallbackParamTraits<A4>::ForwardType a4) const { 573 PolymorphicInvoke f = 574 reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_); 575 576 return f(bind_state_.get(), internal::CallbackForward(a1), 577 internal::CallbackForward(a2), 578 internal::CallbackForward(a3), 579 internal::CallbackForward(a4)); 580 } 581 582 private: 583 typedef R(*PolymorphicInvoke)( 584 internal::BindStateBase*, 585 typename internal::CallbackParamTraits<A1>::ForwardType, 586 typename internal::CallbackParamTraits<A2>::ForwardType, 587 typename internal::CallbackParamTraits<A3>::ForwardType, 588 typename internal::CallbackParamTraits<A4>::ForwardType); 589 590}; 591 592template <typename R, typename A1, typename A2, typename A3, typename A4, 593 typename A5> 594class Callback<R(A1, A2, A3, A4, A5)> : public internal::CallbackBase { 595 public: 596 typedef R(RunType)(A1, A2, A3, A4, A5); 597 598 Callback() : CallbackBase(NULL) { } 599 600 // Note that this constructor CANNOT be explicit, and that Bind() CANNOT 601 // return the exact Callback<> type. See base/bind.h for details. 602 template <typename Runnable, typename BindRunType, typename BoundArgsType> 603 Callback(internal::BindState<Runnable, BindRunType, 604 BoundArgsType>* bind_state) 605 : CallbackBase(bind_state) { 606 607 // Force the assignment to a local variable of PolymorphicInvoke 608 // so the compiler will typecheck that the passed in Run() method has 609 // the correct type. 610 PolymorphicInvoke invoke_func = 611 &internal::BindState<Runnable, BindRunType, BoundArgsType> 612 ::InvokerType::Run; 613 polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func); 614 } 615 616 bool Equals(const Callback& other) const { 617 return CallbackBase::Equals(other); 618 } 619 620 R Run(typename internal::CallbackParamTraits<A1>::ForwardType a1, 621 typename internal::CallbackParamTraits<A2>::ForwardType a2, 622 typename internal::CallbackParamTraits<A3>::ForwardType a3, 623 typename internal::CallbackParamTraits<A4>::ForwardType a4, 624 typename internal::CallbackParamTraits<A5>::ForwardType a5) const { 625 PolymorphicInvoke f = 626 reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_); 627 628 return f(bind_state_.get(), internal::CallbackForward(a1), 629 internal::CallbackForward(a2), 630 internal::CallbackForward(a3), 631 internal::CallbackForward(a4), 632 internal::CallbackForward(a5)); 633 } 634 635 private: 636 typedef R(*PolymorphicInvoke)( 637 internal::BindStateBase*, 638 typename internal::CallbackParamTraits<A1>::ForwardType, 639 typename internal::CallbackParamTraits<A2>::ForwardType, 640 typename internal::CallbackParamTraits<A3>::ForwardType, 641 typename internal::CallbackParamTraits<A4>::ForwardType, 642 typename internal::CallbackParamTraits<A5>::ForwardType); 643 644}; 645 646template <typename R, typename A1, typename A2, typename A3, typename A4, 647 typename A5, typename A6> 648class Callback<R(A1, A2, A3, A4, A5, A6)> : public internal::CallbackBase { 649 public: 650 typedef R(RunType)(A1, A2, A3, A4, A5, A6); 651 652 Callback() : CallbackBase(NULL) { } 653 654 // Note that this constructor CANNOT be explicit, and that Bind() CANNOT 655 // return the exact Callback<> type. See base/bind.h for details. 656 template <typename Runnable, typename BindRunType, typename BoundArgsType> 657 Callback(internal::BindState<Runnable, BindRunType, 658 BoundArgsType>* bind_state) 659 : CallbackBase(bind_state) { 660 661 // Force the assignment to a local variable of PolymorphicInvoke 662 // so the compiler will typecheck that the passed in Run() method has 663 // the correct type. 664 PolymorphicInvoke invoke_func = 665 &internal::BindState<Runnable, BindRunType, BoundArgsType> 666 ::InvokerType::Run; 667 polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func); 668 } 669 670 bool Equals(const Callback& other) const { 671 return CallbackBase::Equals(other); 672 } 673 674 R Run(typename internal::CallbackParamTraits<A1>::ForwardType a1, 675 typename internal::CallbackParamTraits<A2>::ForwardType a2, 676 typename internal::CallbackParamTraits<A3>::ForwardType a3, 677 typename internal::CallbackParamTraits<A4>::ForwardType a4, 678 typename internal::CallbackParamTraits<A5>::ForwardType a5, 679 typename internal::CallbackParamTraits<A6>::ForwardType a6) const { 680 PolymorphicInvoke f = 681 reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_); 682 683 return f(bind_state_.get(), internal::CallbackForward(a1), 684 internal::CallbackForward(a2), 685 internal::CallbackForward(a3), 686 internal::CallbackForward(a4), 687 internal::CallbackForward(a5), 688 internal::CallbackForward(a6)); 689 } 690 691 private: 692 typedef R(*PolymorphicInvoke)( 693 internal::BindStateBase*, 694 typename internal::CallbackParamTraits<A1>::ForwardType, 695 typename internal::CallbackParamTraits<A2>::ForwardType, 696 typename internal::CallbackParamTraits<A3>::ForwardType, 697 typename internal::CallbackParamTraits<A4>::ForwardType, 698 typename internal::CallbackParamTraits<A5>::ForwardType, 699 typename internal::CallbackParamTraits<A6>::ForwardType); 700 701}; 702 703template <typename R, typename A1, typename A2, typename A3, typename A4, 704 typename A5, typename A6, typename A7> 705class Callback<R(A1, A2, A3, A4, A5, A6, A7)> : public internal::CallbackBase { 706 public: 707 typedef R(RunType)(A1, A2, A3, A4, A5, A6, A7); 708 709 Callback() : CallbackBase(NULL) { } 710 711 // Note that this constructor CANNOT be explicit, and that Bind() CANNOT 712 // return the exact Callback<> type. See base/bind.h for details. 713 template <typename Runnable, typename BindRunType, typename BoundArgsType> 714 Callback(internal::BindState<Runnable, BindRunType, 715 BoundArgsType>* bind_state) 716 : CallbackBase(bind_state) { 717 718 // Force the assignment to a local variable of PolymorphicInvoke 719 // so the compiler will typecheck that the passed in Run() method has 720 // the correct type. 721 PolymorphicInvoke invoke_func = 722 &internal::BindState<Runnable, BindRunType, BoundArgsType> 723 ::InvokerType::Run; 724 polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func); 725 } 726 727 bool Equals(const Callback& other) const { 728 return CallbackBase::Equals(other); 729 } 730 731 R Run(typename internal::CallbackParamTraits<A1>::ForwardType a1, 732 typename internal::CallbackParamTraits<A2>::ForwardType a2, 733 typename internal::CallbackParamTraits<A3>::ForwardType a3, 734 typename internal::CallbackParamTraits<A4>::ForwardType a4, 735 typename internal::CallbackParamTraits<A5>::ForwardType a5, 736 typename internal::CallbackParamTraits<A6>::ForwardType a6, 737 typename internal::CallbackParamTraits<A7>::ForwardType a7) const { 738 PolymorphicInvoke f = 739 reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_); 740 741 return f(bind_state_.get(), internal::CallbackForward(a1), 742 internal::CallbackForward(a2), 743 internal::CallbackForward(a3), 744 internal::CallbackForward(a4), 745 internal::CallbackForward(a5), 746 internal::CallbackForward(a6), 747 internal::CallbackForward(a7)); 748 } 749 750 private: 751 typedef R(*PolymorphicInvoke)( 752 internal::BindStateBase*, 753 typename internal::CallbackParamTraits<A1>::ForwardType, 754 typename internal::CallbackParamTraits<A2>::ForwardType, 755 typename internal::CallbackParamTraits<A3>::ForwardType, 756 typename internal::CallbackParamTraits<A4>::ForwardType, 757 typename internal::CallbackParamTraits<A5>::ForwardType, 758 typename internal::CallbackParamTraits<A6>::ForwardType, 759 typename internal::CallbackParamTraits<A7>::ForwardType); 760 761}; 762 763 764// Syntactic sugar to make Callback<void(void)> easier to declare since it 765// will be used in a lot of APIs with delayed execution. 766typedef Callback<void(void)> Closure; 767 768} // namespace base 769 770#endif // BASE_CALLBACK_H 771