1// This file was GENERATED by command: 2// pump.py bind_internal.h.pump 3// DO NOT EDIT BY HAND!!! 4 5 6// Copyright (c) 2011 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_BIND_INTERNAL_H_ 11#define BASE_BIND_INTERNAL_H_ 12 13#include "base/bind_helpers.h" 14#include "base/callback_internal.h" 15#include "base/memory/raw_scoped_refptr_mismatch_checker.h" 16#include "base/memory/weak_ptr.h" 17#include "base/template_util.h" 18#include "build/build_config.h" 19 20#if defined(OS_WIN) 21#include "base/bind_internal_win.h" 22#endif 23 24namespace base { 25namespace internal { 26 27// See base/callback.h for user documentation. 28// 29// 30// CONCEPTS: 31// Runnable -- A type (really a type class) that has a single Run() method 32// and a RunType typedef that corresponds to the type of Run(). 33// A Runnable can declare that it should treated like a method 34// call by including a typedef named IsMethod. The value of 35// this typedef is NOT inspected, only the existence. When a 36// Runnable declares itself a method, Bind() will enforce special 37// refcounting + WeakPtr handling semantics for the first 38// parameter which is expected to be an object. 39// Functor -- A copyable type representing something that should be called. 40// All function pointers, Callback<>, and Runnables are functors 41// even if the invocation syntax differs. 42// RunType -- A function type (as opposed to function _pointer_ type) for 43// a Run() function. Usually just a convenience typedef. 44// (Bound)ArgsType -- A function type that is being (ab)used to store the 45// types of set of arguments. The "return" type is always 46// void here. We use this hack so that we do not need 47// a new type name for each arity of type. (eg., 48// BindState1, BindState2). This makes forward 49// declarations and friending much much easier. 50// 51// Types: 52// RunnableAdapter<> -- Wraps the various "function" pointer types into an 53// object that adheres to the Runnable interface. 54// There are |3*ARITY| RunnableAdapter types. 55// FunctionTraits<> -- Type traits that unwrap a function signature into a 56// a set of easier to use typedefs. Used mainly for 57// compile time asserts. 58// There are |ARITY| FunctionTraits types. 59// ForceVoidReturn<> -- Helper class for translating function signatures to 60// equivalent forms with a "void" return type. 61// There are |ARITY| ForceVoidReturn types. 62// FunctorTraits<> -- Type traits used determine the correct RunType and 63// RunnableType for a Functor. This is where function 64// signature adapters are applied. 65// There are |ARITY| ForceVoidReturn types. 66// MakeRunnable<> -- Takes a Functor and returns an object in the Runnable 67// type class that represents the underlying Functor. 68// There are |O(1)| MakeRunnable types. 69// InvokeHelper<> -- Take a Runnable + arguments and actully invokes it. 70// Handle the differing syntaxes needed for WeakPtr<> support, 71// and for ignoring return values. This is separate from 72// Invoker to avoid creating multiple version of Invoker<> 73// which grows at O(n^2) with the arity. 74// There are |k*ARITY| InvokeHelper types. 75// Invoker<> -- Unwraps the curried parameters and executes the Runnable. 76// There are |(ARITY^2 + ARITY)/2| Invoketypes. 77// BindState<> -- Stores the curried parameters, and is the main entry point 78// into the Bind() system, doing most of the type resolution. 79// There are ARITY BindState types. 80 81// RunnableAdapter<> 82// 83// The RunnableAdapter<> templates provide a uniform interface for invoking 84// a function pointer, method pointer, or const method pointer. The adapter 85// exposes a Run() method with an appropriate signature. Using this wrapper 86// allows for writing code that supports all three pointer types without 87// undue repetition. Without it, a lot of code would need to be repeated 3 88// times. 89// 90// For method pointers and const method pointers the first argument to Run() 91// is considered to be the received of the method. This is similar to STL's 92// mem_fun(). 93// 94// This class also exposes a RunType typedef that is the function type of the 95// Run() function. 96// 97// If and only if the wrapper contains a method or const method pointer, an 98// IsMethod typedef is exposed. The existence of this typedef (NOT the value) 99// marks that the wrapper should be considered a method wrapper. 100 101template <typename Functor> 102class RunnableAdapter; 103 104// Function: Arity 0. 105template <typename R> 106class RunnableAdapter<R(*)()> { 107 public: 108 typedef R (RunType)(); 109 110 explicit RunnableAdapter(R(*function)()) 111 : function_(function) { 112 } 113 114 R Run() { 115 return function_(); 116 } 117 118 private: 119 R (*function_)(); 120}; 121 122// Method: Arity 0. 123template <typename R, typename T> 124class RunnableAdapter<R(T::*)()> { 125 public: 126 typedef R (RunType)(T*); 127 typedef true_type IsMethod; 128 129 explicit RunnableAdapter(R(T::*method)()) 130 : method_(method) { 131 } 132 133 R Run(T* object) { 134 return (object->*method_)(); 135 } 136 137 private: 138 R (T::*method_)(); 139}; 140 141// Const Method: Arity 0. 142template <typename R, typename T> 143class RunnableAdapter<R(T::*)() const> { 144 public: 145 typedef R (RunType)(const T*); 146 typedef true_type IsMethod; 147 148 explicit RunnableAdapter(R(T::*method)() const) 149 : method_(method) { 150 } 151 152 R Run(const T* object) { 153 return (object->*method_)(); 154 } 155 156 private: 157 R (T::*method_)() const; 158}; 159 160// Function: Arity 1. 161template <typename R, typename A1> 162class RunnableAdapter<R(*)(A1)> { 163 public: 164 typedef R (RunType)(A1); 165 166 explicit RunnableAdapter(R(*function)(A1)) 167 : function_(function) { 168 } 169 170 R Run(typename CallbackParamTraits<A1>::ForwardType a1) { 171 return function_(CallbackForward(a1)); 172 } 173 174 private: 175 R (*function_)(A1); 176}; 177 178// Method: Arity 1. 179template <typename R, typename T, typename A1> 180class RunnableAdapter<R(T::*)(A1)> { 181 public: 182 typedef R (RunType)(T*, A1); 183 typedef true_type IsMethod; 184 185 explicit RunnableAdapter(R(T::*method)(A1)) 186 : method_(method) { 187 } 188 189 R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1) { 190 return (object->*method_)(CallbackForward(a1)); 191 } 192 193 private: 194 R (T::*method_)(A1); 195}; 196 197// Const Method: Arity 1. 198template <typename R, typename T, typename A1> 199class RunnableAdapter<R(T::*)(A1) const> { 200 public: 201 typedef R (RunType)(const T*, A1); 202 typedef true_type IsMethod; 203 204 explicit RunnableAdapter(R(T::*method)(A1) const) 205 : method_(method) { 206 } 207 208 R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1) { 209 return (object->*method_)(CallbackForward(a1)); 210 } 211 212 private: 213 R (T::*method_)(A1) const; 214}; 215 216// Function: Arity 2. 217template <typename R, typename A1, typename A2> 218class RunnableAdapter<R(*)(A1, A2)> { 219 public: 220 typedef R (RunType)(A1, A2); 221 222 explicit RunnableAdapter(R(*function)(A1, A2)) 223 : function_(function) { 224 } 225 226 R Run(typename CallbackParamTraits<A1>::ForwardType a1, 227 typename CallbackParamTraits<A2>::ForwardType a2) { 228 return function_(CallbackForward(a1), CallbackForward(a2)); 229 } 230 231 private: 232 R (*function_)(A1, A2); 233}; 234 235// Method: Arity 2. 236template <typename R, typename T, typename A1, typename A2> 237class RunnableAdapter<R(T::*)(A1, A2)> { 238 public: 239 typedef R (RunType)(T*, A1, A2); 240 typedef true_type IsMethod; 241 242 explicit RunnableAdapter(R(T::*method)(A1, A2)) 243 : method_(method) { 244 } 245 246 R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1, 247 typename CallbackParamTraits<A2>::ForwardType a2) { 248 return (object->*method_)(CallbackForward(a1), CallbackForward(a2)); 249 } 250 251 private: 252 R (T::*method_)(A1, A2); 253}; 254 255// Const Method: Arity 2. 256template <typename R, typename T, typename A1, typename A2> 257class RunnableAdapter<R(T::*)(A1, A2) const> { 258 public: 259 typedef R (RunType)(const T*, A1, A2); 260 typedef true_type IsMethod; 261 262 explicit RunnableAdapter(R(T::*method)(A1, A2) const) 263 : method_(method) { 264 } 265 266 R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1, 267 typename CallbackParamTraits<A2>::ForwardType a2) { 268 return (object->*method_)(CallbackForward(a1), CallbackForward(a2)); 269 } 270 271 private: 272 R (T::*method_)(A1, A2) const; 273}; 274 275// Function: Arity 3. 276template <typename R, typename A1, typename A2, typename A3> 277class RunnableAdapter<R(*)(A1, A2, A3)> { 278 public: 279 typedef R (RunType)(A1, A2, A3); 280 281 explicit RunnableAdapter(R(*function)(A1, A2, A3)) 282 : function_(function) { 283 } 284 285 R Run(typename CallbackParamTraits<A1>::ForwardType a1, 286 typename CallbackParamTraits<A2>::ForwardType a2, 287 typename CallbackParamTraits<A3>::ForwardType a3) { 288 return function_(CallbackForward(a1), CallbackForward(a2), 289 CallbackForward(a3)); 290 } 291 292 private: 293 R (*function_)(A1, A2, A3); 294}; 295 296// Method: Arity 3. 297template <typename R, typename T, typename A1, typename A2, typename A3> 298class RunnableAdapter<R(T::*)(A1, A2, A3)> { 299 public: 300 typedef R (RunType)(T*, A1, A2, A3); 301 typedef true_type IsMethod; 302 303 explicit RunnableAdapter(R(T::*method)(A1, A2, A3)) 304 : method_(method) { 305 } 306 307 R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1, 308 typename CallbackParamTraits<A2>::ForwardType a2, 309 typename CallbackParamTraits<A3>::ForwardType a3) { 310 return (object->*method_)(CallbackForward(a1), CallbackForward(a2), 311 CallbackForward(a3)); 312 } 313 314 private: 315 R (T::*method_)(A1, A2, A3); 316}; 317 318// Const Method: Arity 3. 319template <typename R, typename T, typename A1, typename A2, typename A3> 320class RunnableAdapter<R(T::*)(A1, A2, A3) const> { 321 public: 322 typedef R (RunType)(const T*, A1, A2, A3); 323 typedef true_type IsMethod; 324 325 explicit RunnableAdapter(R(T::*method)(A1, A2, A3) const) 326 : method_(method) { 327 } 328 329 R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1, 330 typename CallbackParamTraits<A2>::ForwardType a2, 331 typename CallbackParamTraits<A3>::ForwardType a3) { 332 return (object->*method_)(CallbackForward(a1), CallbackForward(a2), 333 CallbackForward(a3)); 334 } 335 336 private: 337 R (T::*method_)(A1, A2, A3) const; 338}; 339 340// Function: Arity 4. 341template <typename R, typename A1, typename A2, typename A3, typename A4> 342class RunnableAdapter<R(*)(A1, A2, A3, A4)> { 343 public: 344 typedef R (RunType)(A1, A2, A3, A4); 345 346 explicit RunnableAdapter(R(*function)(A1, A2, A3, A4)) 347 : function_(function) { 348 } 349 350 R Run(typename CallbackParamTraits<A1>::ForwardType a1, 351 typename CallbackParamTraits<A2>::ForwardType a2, 352 typename CallbackParamTraits<A3>::ForwardType a3, 353 typename CallbackParamTraits<A4>::ForwardType a4) { 354 return function_(CallbackForward(a1), CallbackForward(a2), 355 CallbackForward(a3), CallbackForward(a4)); 356 } 357 358 private: 359 R (*function_)(A1, A2, A3, A4); 360}; 361 362// Method: Arity 4. 363template <typename R, typename T, typename A1, typename A2, typename A3, 364 typename A4> 365class RunnableAdapter<R(T::*)(A1, A2, A3, A4)> { 366 public: 367 typedef R (RunType)(T*, A1, A2, A3, A4); 368 typedef true_type IsMethod; 369 370 explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4)) 371 : method_(method) { 372 } 373 374 R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1, 375 typename CallbackParamTraits<A2>::ForwardType a2, 376 typename CallbackParamTraits<A3>::ForwardType a3, 377 typename CallbackParamTraits<A4>::ForwardType a4) { 378 return (object->*method_)(CallbackForward(a1), CallbackForward(a2), 379 CallbackForward(a3), CallbackForward(a4)); 380 } 381 382 private: 383 R (T::*method_)(A1, A2, A3, A4); 384}; 385 386// Const Method: Arity 4. 387template <typename R, typename T, typename A1, typename A2, typename A3, 388 typename A4> 389class RunnableAdapter<R(T::*)(A1, A2, A3, A4) const> { 390 public: 391 typedef R (RunType)(const T*, A1, A2, A3, A4); 392 typedef true_type IsMethod; 393 394 explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4) const) 395 : method_(method) { 396 } 397 398 R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1, 399 typename CallbackParamTraits<A2>::ForwardType a2, 400 typename CallbackParamTraits<A3>::ForwardType a3, 401 typename CallbackParamTraits<A4>::ForwardType a4) { 402 return (object->*method_)(CallbackForward(a1), CallbackForward(a2), 403 CallbackForward(a3), CallbackForward(a4)); 404 } 405 406 private: 407 R (T::*method_)(A1, A2, A3, A4) const; 408}; 409 410// Function: Arity 5. 411template <typename R, typename A1, typename A2, typename A3, typename A4, 412 typename A5> 413class RunnableAdapter<R(*)(A1, A2, A3, A4, A5)> { 414 public: 415 typedef R (RunType)(A1, A2, A3, A4, A5); 416 417 explicit RunnableAdapter(R(*function)(A1, A2, A3, A4, A5)) 418 : function_(function) { 419 } 420 421 R Run(typename CallbackParamTraits<A1>::ForwardType a1, 422 typename CallbackParamTraits<A2>::ForwardType a2, 423 typename CallbackParamTraits<A3>::ForwardType a3, 424 typename CallbackParamTraits<A4>::ForwardType a4, 425 typename CallbackParamTraits<A5>::ForwardType a5) { 426 return function_(CallbackForward(a1), CallbackForward(a2), 427 CallbackForward(a3), CallbackForward(a4), CallbackForward(a5)); 428 } 429 430 private: 431 R (*function_)(A1, A2, A3, A4, A5); 432}; 433 434// Method: Arity 5. 435template <typename R, typename T, typename A1, typename A2, typename A3, 436 typename A4, typename A5> 437class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5)> { 438 public: 439 typedef R (RunType)(T*, A1, A2, A3, A4, A5); 440 typedef true_type IsMethod; 441 442 explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5)) 443 : method_(method) { 444 } 445 446 R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1, 447 typename CallbackParamTraits<A2>::ForwardType a2, 448 typename CallbackParamTraits<A3>::ForwardType a3, 449 typename CallbackParamTraits<A4>::ForwardType a4, 450 typename CallbackParamTraits<A5>::ForwardType a5) { 451 return (object->*method_)(CallbackForward(a1), CallbackForward(a2), 452 CallbackForward(a3), CallbackForward(a4), CallbackForward(a5)); 453 } 454 455 private: 456 R (T::*method_)(A1, A2, A3, A4, A5); 457}; 458 459// Const Method: Arity 5. 460template <typename R, typename T, typename A1, typename A2, typename A3, 461 typename A4, typename A5> 462class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5) const> { 463 public: 464 typedef R (RunType)(const T*, A1, A2, A3, A4, A5); 465 typedef true_type IsMethod; 466 467 explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5) const) 468 : method_(method) { 469 } 470 471 R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1, 472 typename CallbackParamTraits<A2>::ForwardType a2, 473 typename CallbackParamTraits<A3>::ForwardType a3, 474 typename CallbackParamTraits<A4>::ForwardType a4, 475 typename CallbackParamTraits<A5>::ForwardType a5) { 476 return (object->*method_)(CallbackForward(a1), CallbackForward(a2), 477 CallbackForward(a3), CallbackForward(a4), CallbackForward(a5)); 478 } 479 480 private: 481 R (T::*method_)(A1, A2, A3, A4, A5) const; 482}; 483 484// Function: Arity 6. 485template <typename R, typename A1, typename A2, typename A3, typename A4, 486 typename A5, typename A6> 487class RunnableAdapter<R(*)(A1, A2, A3, A4, A5, A6)> { 488 public: 489 typedef R (RunType)(A1, A2, A3, A4, A5, A6); 490 491 explicit RunnableAdapter(R(*function)(A1, A2, A3, A4, A5, A6)) 492 : function_(function) { 493 } 494 495 R Run(typename CallbackParamTraits<A1>::ForwardType a1, 496 typename CallbackParamTraits<A2>::ForwardType a2, 497 typename CallbackParamTraits<A3>::ForwardType a3, 498 typename CallbackParamTraits<A4>::ForwardType a4, 499 typename CallbackParamTraits<A5>::ForwardType a5, 500 typename CallbackParamTraits<A6>::ForwardType a6) { 501 return function_(CallbackForward(a1), CallbackForward(a2), 502 CallbackForward(a3), CallbackForward(a4), CallbackForward(a5), 503 CallbackForward(a6)); 504 } 505 506 private: 507 R (*function_)(A1, A2, A3, A4, A5, A6); 508}; 509 510// Method: Arity 6. 511template <typename R, typename T, typename A1, typename A2, typename A3, 512 typename A4, typename A5, typename A6> 513class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5, A6)> { 514 public: 515 typedef R (RunType)(T*, A1, A2, A3, A4, A5, A6); 516 typedef true_type IsMethod; 517 518 explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5, A6)) 519 : method_(method) { 520 } 521 522 R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1, 523 typename CallbackParamTraits<A2>::ForwardType a2, 524 typename CallbackParamTraits<A3>::ForwardType a3, 525 typename CallbackParamTraits<A4>::ForwardType a4, 526 typename CallbackParamTraits<A5>::ForwardType a5, 527 typename CallbackParamTraits<A6>::ForwardType a6) { 528 return (object->*method_)(CallbackForward(a1), CallbackForward(a2), 529 CallbackForward(a3), CallbackForward(a4), CallbackForward(a5), 530 CallbackForward(a6)); 531 } 532 533 private: 534 R (T::*method_)(A1, A2, A3, A4, A5, A6); 535}; 536 537// Const Method: Arity 6. 538template <typename R, typename T, typename A1, typename A2, typename A3, 539 typename A4, typename A5, typename A6> 540class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5, A6) const> { 541 public: 542 typedef R (RunType)(const T*, A1, A2, A3, A4, A5, A6); 543 typedef true_type IsMethod; 544 545 explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5, A6) const) 546 : method_(method) { 547 } 548 549 R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1, 550 typename CallbackParamTraits<A2>::ForwardType a2, 551 typename CallbackParamTraits<A3>::ForwardType a3, 552 typename CallbackParamTraits<A4>::ForwardType a4, 553 typename CallbackParamTraits<A5>::ForwardType a5, 554 typename CallbackParamTraits<A6>::ForwardType a6) { 555 return (object->*method_)(CallbackForward(a1), CallbackForward(a2), 556 CallbackForward(a3), CallbackForward(a4), CallbackForward(a5), 557 CallbackForward(a6)); 558 } 559 560 private: 561 R (T::*method_)(A1, A2, A3, A4, A5, A6) const; 562}; 563 564// Function: Arity 7. 565template <typename R, typename A1, typename A2, typename A3, typename A4, 566 typename A5, typename A6, typename A7> 567class RunnableAdapter<R(*)(A1, A2, A3, A4, A5, A6, A7)> { 568 public: 569 typedef R (RunType)(A1, A2, A3, A4, A5, A6, A7); 570 571 explicit RunnableAdapter(R(*function)(A1, A2, A3, A4, A5, A6, A7)) 572 : function_(function) { 573 } 574 575 R Run(typename CallbackParamTraits<A1>::ForwardType a1, 576 typename CallbackParamTraits<A2>::ForwardType a2, 577 typename CallbackParamTraits<A3>::ForwardType a3, 578 typename CallbackParamTraits<A4>::ForwardType a4, 579 typename CallbackParamTraits<A5>::ForwardType a5, 580 typename CallbackParamTraits<A6>::ForwardType a6, 581 typename CallbackParamTraits<A7>::ForwardType a7) { 582 return function_(CallbackForward(a1), CallbackForward(a2), 583 CallbackForward(a3), CallbackForward(a4), CallbackForward(a5), 584 CallbackForward(a6), CallbackForward(a7)); 585 } 586 587 private: 588 R (*function_)(A1, A2, A3, A4, A5, A6, A7); 589}; 590 591// Method: Arity 7. 592template <typename R, typename T, typename A1, typename A2, typename A3, 593 typename A4, typename A5, typename A6, typename A7> 594class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5, A6, A7)> { 595 public: 596 typedef R (RunType)(T*, A1, A2, A3, A4, A5, A6, A7); 597 typedef true_type IsMethod; 598 599 explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5, A6, A7)) 600 : method_(method) { 601 } 602 603 R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1, 604 typename CallbackParamTraits<A2>::ForwardType a2, 605 typename CallbackParamTraits<A3>::ForwardType a3, 606 typename CallbackParamTraits<A4>::ForwardType a4, 607 typename CallbackParamTraits<A5>::ForwardType a5, 608 typename CallbackParamTraits<A6>::ForwardType a6, 609 typename CallbackParamTraits<A7>::ForwardType a7) { 610 return (object->*method_)(CallbackForward(a1), CallbackForward(a2), 611 CallbackForward(a3), CallbackForward(a4), CallbackForward(a5), 612 CallbackForward(a6), CallbackForward(a7)); 613 } 614 615 private: 616 R (T::*method_)(A1, A2, A3, A4, A5, A6, A7); 617}; 618 619// Const Method: Arity 7. 620template <typename R, typename T, typename A1, typename A2, typename A3, 621 typename A4, typename A5, typename A6, typename A7> 622class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5, A6, A7) const> { 623 public: 624 typedef R (RunType)(const T*, A1, A2, A3, A4, A5, A6, A7); 625 typedef true_type IsMethod; 626 627 explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5, A6, A7) const) 628 : method_(method) { 629 } 630 631 R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1, 632 typename CallbackParamTraits<A2>::ForwardType a2, 633 typename CallbackParamTraits<A3>::ForwardType a3, 634 typename CallbackParamTraits<A4>::ForwardType a4, 635 typename CallbackParamTraits<A5>::ForwardType a5, 636 typename CallbackParamTraits<A6>::ForwardType a6, 637 typename CallbackParamTraits<A7>::ForwardType a7) { 638 return (object->*method_)(CallbackForward(a1), CallbackForward(a2), 639 CallbackForward(a3), CallbackForward(a4), CallbackForward(a5), 640 CallbackForward(a6), CallbackForward(a7)); 641 } 642 643 private: 644 R (T::*method_)(A1, A2, A3, A4, A5, A6, A7) const; 645}; 646 647 648// FunctionTraits<> 649// 650// Breaks a function signature apart into typedefs for easier introspection. 651template <typename Sig> 652struct FunctionTraits; 653 654template <typename R> 655struct FunctionTraits<R()> { 656 typedef R ReturnType; 657}; 658 659template <typename R, typename A1> 660struct FunctionTraits<R(A1)> { 661 typedef R ReturnType; 662 typedef A1 A1Type; 663}; 664 665template <typename R, typename A1, typename A2> 666struct FunctionTraits<R(A1, A2)> { 667 typedef R ReturnType; 668 typedef A1 A1Type; 669 typedef A2 A2Type; 670}; 671 672template <typename R, typename A1, typename A2, typename A3> 673struct FunctionTraits<R(A1, A2, A3)> { 674 typedef R ReturnType; 675 typedef A1 A1Type; 676 typedef A2 A2Type; 677 typedef A3 A3Type; 678}; 679 680template <typename R, typename A1, typename A2, typename A3, typename A4> 681struct FunctionTraits<R(A1, A2, A3, A4)> { 682 typedef R ReturnType; 683 typedef A1 A1Type; 684 typedef A2 A2Type; 685 typedef A3 A3Type; 686 typedef A4 A4Type; 687}; 688 689template <typename R, typename A1, typename A2, typename A3, typename A4, 690 typename A5> 691struct FunctionTraits<R(A1, A2, A3, A4, A5)> { 692 typedef R ReturnType; 693 typedef A1 A1Type; 694 typedef A2 A2Type; 695 typedef A3 A3Type; 696 typedef A4 A4Type; 697 typedef A5 A5Type; 698}; 699 700template <typename R, typename A1, typename A2, typename A3, typename A4, 701 typename A5, typename A6> 702struct FunctionTraits<R(A1, A2, A3, A4, A5, A6)> { 703 typedef R ReturnType; 704 typedef A1 A1Type; 705 typedef A2 A2Type; 706 typedef A3 A3Type; 707 typedef A4 A4Type; 708 typedef A5 A5Type; 709 typedef A6 A6Type; 710}; 711 712template <typename R, typename A1, typename A2, typename A3, typename A4, 713 typename A5, typename A6, typename A7> 714struct FunctionTraits<R(A1, A2, A3, A4, A5, A6, A7)> { 715 typedef R ReturnType; 716 typedef A1 A1Type; 717 typedef A2 A2Type; 718 typedef A3 A3Type; 719 typedef A4 A4Type; 720 typedef A5 A5Type; 721 typedef A6 A6Type; 722 typedef A7 A7Type; 723}; 724 725 726// ForceVoidReturn<> 727// 728// Set of templates that support forcing the function return type to void. 729template <typename Sig> 730struct ForceVoidReturn; 731 732template <typename R> 733struct ForceVoidReturn<R()> { 734 typedef void(RunType)(); 735}; 736 737template <typename R, typename A1> 738struct ForceVoidReturn<R(A1)> { 739 typedef void(RunType)(A1); 740}; 741 742template <typename R, typename A1, typename A2> 743struct ForceVoidReturn<R(A1, A2)> { 744 typedef void(RunType)(A1, A2); 745}; 746 747template <typename R, typename A1, typename A2, typename A3> 748struct ForceVoidReturn<R(A1, A2, A3)> { 749 typedef void(RunType)(A1, A2, A3); 750}; 751 752template <typename R, typename A1, typename A2, typename A3, typename A4> 753struct ForceVoidReturn<R(A1, A2, A3, A4)> { 754 typedef void(RunType)(A1, A2, A3, A4); 755}; 756 757template <typename R, typename A1, typename A2, typename A3, typename A4, 758 typename A5> 759struct ForceVoidReturn<R(A1, A2, A3, A4, A5)> { 760 typedef void(RunType)(A1, A2, A3, A4, A5); 761}; 762 763template <typename R, typename A1, typename A2, typename A3, typename A4, 764 typename A5, typename A6> 765struct ForceVoidReturn<R(A1, A2, A3, A4, A5, A6)> { 766 typedef void(RunType)(A1, A2, A3, A4, A5, A6); 767}; 768 769template <typename R, typename A1, typename A2, typename A3, typename A4, 770 typename A5, typename A6, typename A7> 771struct ForceVoidReturn<R(A1, A2, A3, A4, A5, A6, A7)> { 772 typedef void(RunType)(A1, A2, A3, A4, A5, A6, A7); 773}; 774 775 776// FunctorTraits<> 777// 778// See description at top of file. 779template <typename T> 780struct FunctorTraits { 781 typedef RunnableAdapter<T> RunnableType; 782 typedef typename RunnableType::RunType RunType; 783}; 784 785template <typename T> 786struct FunctorTraits<IgnoreResultHelper<T> > { 787 typedef typename FunctorTraits<T>::RunnableType RunnableType; 788 typedef typename ForceVoidReturn< 789 typename RunnableType::RunType>::RunType RunType; 790}; 791 792template <typename T> 793struct FunctorTraits<Callback<T> > { 794 typedef Callback<T> RunnableType; 795 typedef typename Callback<T>::RunType RunType; 796}; 797 798 799// MakeRunnable<> 800// 801// Converts a passed in functor to a RunnableType using type inference. 802 803template <typename T> 804typename FunctorTraits<T>::RunnableType MakeRunnable(const T& t) { 805 return RunnableAdapter<T>(t); 806} 807 808template <typename T> 809typename FunctorTraits<T>::RunnableType 810MakeRunnable(const IgnoreResultHelper<T>& t) { 811 return MakeRunnable(t.functor_); 812} 813 814template <typename T> 815const typename FunctorTraits<Callback<T> >::RunnableType& 816MakeRunnable(const Callback<T>& t) { 817 DCHECK(!t.is_null()); 818 return t; 819} 820 821 822// InvokeHelper<> 823// 824// There are 3 logical InvokeHelper<> specializations: normal, void-return, 825// WeakCalls. 826// 827// The normal type just calls the underlying runnable. 828// 829// We need a InvokeHelper to handle void return types in order to support 830// IgnoreResult(). Normally, if the Runnable's RunType had a void return, 831// the template system would just accept "return functor.Run()" ignoring 832// the fact that a void function is being used with return. This piece of 833// sugar breaks though when the Runnable's RunType is not void. Thus, we 834// need a partial specialization to change the syntax to drop the "return" 835// from the invocation call. 836// 837// WeakCalls similarly need special syntax that is applied to the first 838// argument to check if they should no-op themselves. 839template <bool IsWeakCall, typename ReturnType, typename Runnable, 840 typename ArgsType> 841struct InvokeHelper; 842 843template <typename ReturnType, typename Runnable> 844struct InvokeHelper<false, ReturnType, Runnable, 845 void()> { 846 static ReturnType MakeItSo(Runnable runnable) { 847 return runnable.Run(); 848 } 849}; 850 851template <typename Runnable> 852struct InvokeHelper<false, void, Runnable, 853 void()> { 854 static void MakeItSo(Runnable runnable) { 855 runnable.Run(); 856 } 857}; 858 859template <typename ReturnType, typename Runnable,typename A1> 860struct InvokeHelper<false, ReturnType, Runnable, 861 void(A1)> { 862 static ReturnType MakeItSo(Runnable runnable, A1 a1) { 863 return runnable.Run(CallbackForward(a1)); 864 } 865}; 866 867template <typename Runnable,typename A1> 868struct InvokeHelper<false, void, Runnable, 869 void(A1)> { 870 static void MakeItSo(Runnable runnable, A1 a1) { 871 runnable.Run(CallbackForward(a1)); 872 } 873}; 874 875template <typename Runnable, typename BoundWeakPtr> 876struct InvokeHelper<true, void, Runnable, 877 void(BoundWeakPtr)> { 878 static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr) { 879 if (!weak_ptr.get()) { 880 return; 881 } 882 runnable.Run(weak_ptr.get()); 883 } 884}; 885 886template <typename ReturnType, typename Runnable,typename A1, typename A2> 887struct InvokeHelper<false, ReturnType, Runnable, 888 void(A1, A2)> { 889 static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2) { 890 return runnable.Run(CallbackForward(a1), CallbackForward(a2)); 891 } 892}; 893 894template <typename Runnable,typename A1, typename A2> 895struct InvokeHelper<false, void, Runnable, 896 void(A1, A2)> { 897 static void MakeItSo(Runnable runnable, A1 a1, A2 a2) { 898 runnable.Run(CallbackForward(a1), CallbackForward(a2)); 899 } 900}; 901 902template <typename Runnable, typename BoundWeakPtr, typename A2> 903struct InvokeHelper<true, void, Runnable, 904 void(BoundWeakPtr, A2)> { 905 static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2) { 906 if (!weak_ptr.get()) { 907 return; 908 } 909 runnable.Run(weak_ptr.get(), CallbackForward(a2)); 910 } 911}; 912 913template <typename ReturnType, typename Runnable,typename A1, typename A2, 914 typename A3> 915struct InvokeHelper<false, ReturnType, Runnable, 916 void(A1, A2, A3)> { 917 static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3) { 918 return runnable.Run(CallbackForward(a1), CallbackForward(a2), 919 CallbackForward(a3)); 920 } 921}; 922 923template <typename Runnable,typename A1, typename A2, typename A3> 924struct InvokeHelper<false, void, Runnable, 925 void(A1, A2, A3)> { 926 static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3) { 927 runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3)); 928 } 929}; 930 931template <typename Runnable, typename BoundWeakPtr, typename A2, typename A3> 932struct InvokeHelper<true, void, Runnable, 933 void(BoundWeakPtr, A2, A3)> { 934 static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2, A3 a3) { 935 if (!weak_ptr.get()) { 936 return; 937 } 938 runnable.Run(weak_ptr.get(), CallbackForward(a2), CallbackForward(a3)); 939 } 940}; 941 942template <typename ReturnType, typename Runnable,typename A1, typename A2, 943 typename A3, typename A4> 944struct InvokeHelper<false, ReturnType, Runnable, 945 void(A1, A2, A3, A4)> { 946 static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4) { 947 return runnable.Run(CallbackForward(a1), CallbackForward(a2), 948 CallbackForward(a3), CallbackForward(a4)); 949 } 950}; 951 952template <typename Runnable,typename A1, typename A2, typename A3, typename A4> 953struct InvokeHelper<false, void, Runnable, 954 void(A1, A2, A3, A4)> { 955 static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4) { 956 runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3), 957 CallbackForward(a4)); 958 } 959}; 960 961template <typename Runnable, typename BoundWeakPtr, typename A2, typename A3, 962 typename A4> 963struct InvokeHelper<true, void, Runnable, 964 void(BoundWeakPtr, A2, A3, A4)> { 965 static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2, A3 a3, 966 A4 a4) { 967 if (!weak_ptr.get()) { 968 return; 969 } 970 runnable.Run(weak_ptr.get(), CallbackForward(a2), CallbackForward(a3), 971 CallbackForward(a4)); 972 } 973}; 974 975template <typename ReturnType, typename Runnable,typename A1, typename A2, 976 typename A3, typename A4, typename A5> 977struct InvokeHelper<false, ReturnType, Runnable, 978 void(A1, A2, A3, A4, A5)> { 979 static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, 980 A5 a5) { 981 return runnable.Run(CallbackForward(a1), CallbackForward(a2), 982 CallbackForward(a3), CallbackForward(a4), CallbackForward(a5)); 983 } 984}; 985 986template <typename Runnable,typename A1, typename A2, typename A3, typename A4, 987 typename A5> 988struct InvokeHelper<false, void, Runnable, 989 void(A1, A2, A3, A4, A5)> { 990 static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { 991 runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3), 992 CallbackForward(a4), CallbackForward(a5)); 993 } 994}; 995 996template <typename Runnable, typename BoundWeakPtr, typename A2, typename A3, 997 typename A4, typename A5> 998struct InvokeHelper<true, void, Runnable, 999 void(BoundWeakPtr, A2, A3, A4, A5)> { 1000 static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2, A3 a3, 1001 A4 a4, A5 a5) { 1002 if (!weak_ptr.get()) { 1003 return; 1004 } 1005 runnable.Run(weak_ptr.get(), CallbackForward(a2), CallbackForward(a3), 1006 CallbackForward(a4), CallbackForward(a5)); 1007 } 1008}; 1009 1010template <typename ReturnType, typename Runnable,typename A1, typename A2, 1011 typename A3, typename A4, typename A5, typename A6> 1012struct InvokeHelper<false, ReturnType, Runnable, 1013 void(A1, A2, A3, A4, A5, A6)> { 1014 static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, 1015 A5 a5, A6 a6) { 1016 return runnable.Run(CallbackForward(a1), CallbackForward(a2), 1017 CallbackForward(a3), CallbackForward(a4), CallbackForward(a5), 1018 CallbackForward(a6)); 1019 } 1020}; 1021 1022template <typename Runnable,typename A1, typename A2, typename A3, typename A4, 1023 typename A5, typename A6> 1024struct InvokeHelper<false, void, Runnable, 1025 void(A1, A2, A3, A4, A5, A6)> { 1026 static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, 1027 A6 a6) { 1028 runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3), 1029 CallbackForward(a4), CallbackForward(a5), CallbackForward(a6)); 1030 } 1031}; 1032 1033template <typename Runnable, typename BoundWeakPtr, typename A2, typename A3, 1034 typename A4, typename A5, typename A6> 1035struct InvokeHelper<true, void, Runnable, 1036 void(BoundWeakPtr, A2, A3, A4, A5, A6)> { 1037 static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2, A3 a3, 1038 A4 a4, A5 a5, A6 a6) { 1039 if (!weak_ptr.get()) { 1040 return; 1041 } 1042 runnable.Run(weak_ptr.get(), CallbackForward(a2), CallbackForward(a3), 1043 CallbackForward(a4), CallbackForward(a5), CallbackForward(a6)); 1044 } 1045}; 1046 1047template <typename ReturnType, typename Runnable,typename A1, typename A2, 1048 typename A3, typename A4, typename A5, typename A6, typename A7> 1049struct InvokeHelper<false, ReturnType, Runnable, 1050 void(A1, A2, A3, A4, A5, A6, A7)> { 1051 static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, 1052 A5 a5, A6 a6, A7 a7) { 1053 return runnable.Run(CallbackForward(a1), CallbackForward(a2), 1054 CallbackForward(a3), CallbackForward(a4), CallbackForward(a5), 1055 CallbackForward(a6), CallbackForward(a7)); 1056 } 1057}; 1058 1059template <typename Runnable,typename A1, typename A2, typename A3, typename A4, 1060 typename A5, typename A6, typename A7> 1061struct InvokeHelper<false, void, Runnable, 1062 void(A1, A2, A3, A4, A5, A6, A7)> { 1063 static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, 1064 A6 a6, A7 a7) { 1065 runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3), 1066 CallbackForward(a4), CallbackForward(a5), CallbackForward(a6), 1067 CallbackForward(a7)); 1068 } 1069}; 1070 1071template <typename Runnable, typename BoundWeakPtr, typename A2, typename A3, 1072 typename A4, typename A5, typename A6, typename A7> 1073struct InvokeHelper<true, void, Runnable, 1074 void(BoundWeakPtr, A2, A3, A4, A5, A6, A7)> { 1075 static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2, A3 a3, 1076 A4 a4, A5 a5, A6 a6, A7 a7) { 1077 if (!weak_ptr.get()) { 1078 return; 1079 } 1080 runnable.Run(weak_ptr.get(), CallbackForward(a2), CallbackForward(a3), 1081 CallbackForward(a4), CallbackForward(a5), CallbackForward(a6), 1082 CallbackForward(a7)); 1083 } 1084}; 1085 1086#if !defined(_MSC_VER) 1087 1088template <typename ReturnType, typename Runnable, typename ArgsType> 1089struct InvokeHelper<true, ReturnType, Runnable, ArgsType> { 1090 // WeakCalls are only supported for functions with a void return type. 1091 // Otherwise, the function result would be undefined if the the WeakPtr<> 1092 // is invalidated. 1093 COMPILE_ASSERT(is_void<ReturnType>::value, 1094 weak_ptrs_can_only_bind_to_methods_without_return_values); 1095}; 1096 1097#endif 1098 1099// Invoker<> 1100// 1101// See description at the top of the file. 1102template <int NumBound, typename Storage, typename RunType> 1103struct Invoker; 1104 1105// Arity 0 -> 0. 1106template <typename StorageType, typename R> 1107struct Invoker<0, StorageType, R()> { 1108 typedef R(RunType)(BindStateBase*); 1109 1110 typedef R(UnboundRunType)(); 1111 1112 static R Run(BindStateBase* base) { 1113 StorageType* storage = static_cast<StorageType*>(base); 1114 1115 // Local references to make debugger stepping easier. If in a debugger, 1116 // you really want to warp ahead and step through the 1117 // InvokeHelper<>::MakeItSo() call below. 1118 1119 return InvokeHelper<StorageType::IsWeakCall::value, R, 1120 typename StorageType::RunnableType, 1121 void()> 1122 ::MakeItSo(storage->runnable_); 1123 } 1124}; 1125 1126// Arity 1 -> 1. 1127template <typename StorageType, typename R,typename X1> 1128struct Invoker<0, StorageType, R(X1)> { 1129 typedef R(RunType)(BindStateBase*, 1130 typename CallbackParamTraits<X1>::ForwardType); 1131 1132 typedef R(UnboundRunType)(X1); 1133 1134 static R Run(BindStateBase* base, 1135 typename CallbackParamTraits<X1>::ForwardType x1) { 1136 StorageType* storage = static_cast<StorageType*>(base); 1137 1138 // Local references to make debugger stepping easier. If in a debugger, 1139 // you really want to warp ahead and step through the 1140 // InvokeHelper<>::MakeItSo() call below. 1141 1142 return InvokeHelper<StorageType::IsWeakCall::value, R, 1143 typename StorageType::RunnableType, 1144 void(typename CallbackParamTraits<X1>::ForwardType x1)> 1145 ::MakeItSo(storage->runnable_, CallbackForward(x1)); 1146 } 1147}; 1148 1149// Arity 1 -> 0. 1150template <typename StorageType, typename R,typename X1> 1151struct Invoker<1, StorageType, R(X1)> { 1152 typedef R(RunType)(BindStateBase*); 1153 1154 typedef R(UnboundRunType)(); 1155 1156 static R Run(BindStateBase* base) { 1157 StorageType* storage = static_cast<StorageType*>(base); 1158 1159 // Local references to make debugger stepping easier. If in a debugger, 1160 // you really want to warp ahead and step through the 1161 // InvokeHelper<>::MakeItSo() call below. 1162 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 1163 1164 typename Bound1UnwrapTraits::ForwardType x1 = 1165 Bound1UnwrapTraits::Unwrap(storage->p1_); 1166 return InvokeHelper<StorageType::IsWeakCall::value, R, 1167 typename StorageType::RunnableType, 1168 void(typename Bound1UnwrapTraits::ForwardType)> 1169 ::MakeItSo(storage->runnable_, CallbackForward(x1)); 1170 } 1171}; 1172 1173// Arity 2 -> 2. 1174template <typename StorageType, typename R,typename X1, typename X2> 1175struct Invoker<0, StorageType, R(X1, X2)> { 1176 typedef R(RunType)(BindStateBase*, 1177 typename CallbackParamTraits<X1>::ForwardType, 1178 typename CallbackParamTraits<X2>::ForwardType); 1179 1180 typedef R(UnboundRunType)(X1, X2); 1181 1182 static R Run(BindStateBase* base, 1183 typename CallbackParamTraits<X1>::ForwardType x1, 1184 typename CallbackParamTraits<X2>::ForwardType x2) { 1185 StorageType* storage = static_cast<StorageType*>(base); 1186 1187 // Local references to make debugger stepping easier. If in a debugger, 1188 // you really want to warp ahead and step through the 1189 // InvokeHelper<>::MakeItSo() call below. 1190 1191 return InvokeHelper<StorageType::IsWeakCall::value, R, 1192 typename StorageType::RunnableType, 1193 void(typename CallbackParamTraits<X1>::ForwardType x1, 1194 typename CallbackParamTraits<X2>::ForwardType x2)> 1195 ::MakeItSo(storage->runnable_, CallbackForward(x1), 1196 CallbackForward(x2)); 1197 } 1198}; 1199 1200// Arity 2 -> 1. 1201template <typename StorageType, typename R,typename X1, typename X2> 1202struct Invoker<1, StorageType, R(X1, X2)> { 1203 typedef R(RunType)(BindStateBase*, 1204 typename CallbackParamTraits<X2>::ForwardType); 1205 1206 typedef R(UnboundRunType)(X2); 1207 1208 static R Run(BindStateBase* base, 1209 typename CallbackParamTraits<X2>::ForwardType x2) { 1210 StorageType* storage = static_cast<StorageType*>(base); 1211 1212 // Local references to make debugger stepping easier. If in a debugger, 1213 // you really want to warp ahead and step through the 1214 // InvokeHelper<>::MakeItSo() call below. 1215 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 1216 1217 typename Bound1UnwrapTraits::ForwardType x1 = 1218 Bound1UnwrapTraits::Unwrap(storage->p1_); 1219 return InvokeHelper<StorageType::IsWeakCall::value, R, 1220 typename StorageType::RunnableType, 1221 void(typename Bound1UnwrapTraits::ForwardType, 1222 typename CallbackParamTraits<X2>::ForwardType x2)> 1223 ::MakeItSo(storage->runnable_, CallbackForward(x1), 1224 CallbackForward(x2)); 1225 } 1226}; 1227 1228// Arity 2 -> 0. 1229template <typename StorageType, typename R,typename X1, typename X2> 1230struct Invoker<2, StorageType, R(X1, X2)> { 1231 typedef R(RunType)(BindStateBase*); 1232 1233 typedef R(UnboundRunType)(); 1234 1235 static R Run(BindStateBase* base) { 1236 StorageType* storage = static_cast<StorageType*>(base); 1237 1238 // Local references to make debugger stepping easier. If in a debugger, 1239 // you really want to warp ahead and step through the 1240 // InvokeHelper<>::MakeItSo() call below. 1241 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 1242 typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; 1243 1244 typename Bound1UnwrapTraits::ForwardType x1 = 1245 Bound1UnwrapTraits::Unwrap(storage->p1_); 1246 typename Bound2UnwrapTraits::ForwardType x2 = 1247 Bound2UnwrapTraits::Unwrap(storage->p2_); 1248 return InvokeHelper<StorageType::IsWeakCall::value, R, 1249 typename StorageType::RunnableType, 1250 void(typename Bound1UnwrapTraits::ForwardType, 1251 typename Bound2UnwrapTraits::ForwardType)> 1252 ::MakeItSo(storage->runnable_, CallbackForward(x1), 1253 CallbackForward(x2)); 1254 } 1255}; 1256 1257// Arity 3 -> 3. 1258template <typename StorageType, typename R,typename X1, typename X2, 1259 typename X3> 1260struct Invoker<0, StorageType, R(X1, X2, X3)> { 1261 typedef R(RunType)(BindStateBase*, 1262 typename CallbackParamTraits<X1>::ForwardType, 1263 typename CallbackParamTraits<X2>::ForwardType, 1264 typename CallbackParamTraits<X3>::ForwardType); 1265 1266 typedef R(UnboundRunType)(X1, X2, X3); 1267 1268 static R Run(BindStateBase* base, 1269 typename CallbackParamTraits<X1>::ForwardType x1, 1270 typename CallbackParamTraits<X2>::ForwardType x2, 1271 typename CallbackParamTraits<X3>::ForwardType x3) { 1272 StorageType* storage = static_cast<StorageType*>(base); 1273 1274 // Local references to make debugger stepping easier. If in a debugger, 1275 // you really want to warp ahead and step through the 1276 // InvokeHelper<>::MakeItSo() call below. 1277 1278 return InvokeHelper<StorageType::IsWeakCall::value, R, 1279 typename StorageType::RunnableType, 1280 void(typename CallbackParamTraits<X1>::ForwardType x1, 1281 typename CallbackParamTraits<X2>::ForwardType x2, 1282 typename CallbackParamTraits<X3>::ForwardType x3)> 1283 ::MakeItSo(storage->runnable_, CallbackForward(x1), 1284 CallbackForward(x2), CallbackForward(x3)); 1285 } 1286}; 1287 1288// Arity 3 -> 2. 1289template <typename StorageType, typename R,typename X1, typename X2, 1290 typename X3> 1291struct Invoker<1, StorageType, R(X1, X2, X3)> { 1292 typedef R(RunType)(BindStateBase*, 1293 typename CallbackParamTraits<X2>::ForwardType, 1294 typename CallbackParamTraits<X3>::ForwardType); 1295 1296 typedef R(UnboundRunType)(X2, X3); 1297 1298 static R Run(BindStateBase* base, 1299 typename CallbackParamTraits<X2>::ForwardType x2, 1300 typename CallbackParamTraits<X3>::ForwardType x3) { 1301 StorageType* storage = static_cast<StorageType*>(base); 1302 1303 // Local references to make debugger stepping easier. If in a debugger, 1304 // you really want to warp ahead and step through the 1305 // InvokeHelper<>::MakeItSo() call below. 1306 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 1307 1308 typename Bound1UnwrapTraits::ForwardType x1 = 1309 Bound1UnwrapTraits::Unwrap(storage->p1_); 1310 return InvokeHelper<StorageType::IsWeakCall::value, R, 1311 typename StorageType::RunnableType, 1312 void(typename Bound1UnwrapTraits::ForwardType, 1313 typename CallbackParamTraits<X2>::ForwardType x2, 1314 typename CallbackParamTraits<X3>::ForwardType x3)> 1315 ::MakeItSo(storage->runnable_, CallbackForward(x1), 1316 CallbackForward(x2), CallbackForward(x3)); 1317 } 1318}; 1319 1320// Arity 3 -> 1. 1321template <typename StorageType, typename R,typename X1, typename X2, 1322 typename X3> 1323struct Invoker<2, StorageType, R(X1, X2, X3)> { 1324 typedef R(RunType)(BindStateBase*, 1325 typename CallbackParamTraits<X3>::ForwardType); 1326 1327 typedef R(UnboundRunType)(X3); 1328 1329 static R Run(BindStateBase* base, 1330 typename CallbackParamTraits<X3>::ForwardType x3) { 1331 StorageType* storage = static_cast<StorageType*>(base); 1332 1333 // Local references to make debugger stepping easier. If in a debugger, 1334 // you really want to warp ahead and step through the 1335 // InvokeHelper<>::MakeItSo() call below. 1336 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 1337 typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; 1338 1339 typename Bound1UnwrapTraits::ForwardType x1 = 1340 Bound1UnwrapTraits::Unwrap(storage->p1_); 1341 typename Bound2UnwrapTraits::ForwardType x2 = 1342 Bound2UnwrapTraits::Unwrap(storage->p2_); 1343 return InvokeHelper<StorageType::IsWeakCall::value, R, 1344 typename StorageType::RunnableType, 1345 void(typename Bound1UnwrapTraits::ForwardType, 1346 typename Bound2UnwrapTraits::ForwardType, 1347 typename CallbackParamTraits<X3>::ForwardType x3)> 1348 ::MakeItSo(storage->runnable_, CallbackForward(x1), 1349 CallbackForward(x2), CallbackForward(x3)); 1350 } 1351}; 1352 1353// Arity 3 -> 0. 1354template <typename StorageType, typename R,typename X1, typename X2, 1355 typename X3> 1356struct Invoker<3, StorageType, R(X1, X2, X3)> { 1357 typedef R(RunType)(BindStateBase*); 1358 1359 typedef R(UnboundRunType)(); 1360 1361 static R Run(BindStateBase* base) { 1362 StorageType* storage = static_cast<StorageType*>(base); 1363 1364 // Local references to make debugger stepping easier. If in a debugger, 1365 // you really want to warp ahead and step through the 1366 // InvokeHelper<>::MakeItSo() call below. 1367 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 1368 typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; 1369 typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; 1370 1371 typename Bound1UnwrapTraits::ForwardType x1 = 1372 Bound1UnwrapTraits::Unwrap(storage->p1_); 1373 typename Bound2UnwrapTraits::ForwardType x2 = 1374 Bound2UnwrapTraits::Unwrap(storage->p2_); 1375 typename Bound3UnwrapTraits::ForwardType x3 = 1376 Bound3UnwrapTraits::Unwrap(storage->p3_); 1377 return InvokeHelper<StorageType::IsWeakCall::value, R, 1378 typename StorageType::RunnableType, 1379 void(typename Bound1UnwrapTraits::ForwardType, 1380 typename Bound2UnwrapTraits::ForwardType, 1381 typename Bound3UnwrapTraits::ForwardType)> 1382 ::MakeItSo(storage->runnable_, CallbackForward(x1), 1383 CallbackForward(x2), CallbackForward(x3)); 1384 } 1385}; 1386 1387// Arity 4 -> 4. 1388template <typename StorageType, typename R,typename X1, typename X2, 1389 typename X3, typename X4> 1390struct Invoker<0, StorageType, R(X1, X2, X3, X4)> { 1391 typedef R(RunType)(BindStateBase*, 1392 typename CallbackParamTraits<X1>::ForwardType, 1393 typename CallbackParamTraits<X2>::ForwardType, 1394 typename CallbackParamTraits<X3>::ForwardType, 1395 typename CallbackParamTraits<X4>::ForwardType); 1396 1397 typedef R(UnboundRunType)(X1, X2, X3, X4); 1398 1399 static R Run(BindStateBase* base, 1400 typename CallbackParamTraits<X1>::ForwardType x1, 1401 typename CallbackParamTraits<X2>::ForwardType x2, 1402 typename CallbackParamTraits<X3>::ForwardType x3, 1403 typename CallbackParamTraits<X4>::ForwardType x4) { 1404 StorageType* storage = static_cast<StorageType*>(base); 1405 1406 // Local references to make debugger stepping easier. If in a debugger, 1407 // you really want to warp ahead and step through the 1408 // InvokeHelper<>::MakeItSo() call below. 1409 1410 return InvokeHelper<StorageType::IsWeakCall::value, R, 1411 typename StorageType::RunnableType, 1412 void(typename CallbackParamTraits<X1>::ForwardType x1, 1413 typename CallbackParamTraits<X2>::ForwardType x2, 1414 typename CallbackParamTraits<X3>::ForwardType x3, 1415 typename CallbackParamTraits<X4>::ForwardType x4)> 1416 ::MakeItSo(storage->runnable_, CallbackForward(x1), 1417 CallbackForward(x2), CallbackForward(x3), 1418 CallbackForward(x4)); 1419 } 1420}; 1421 1422// Arity 4 -> 3. 1423template <typename StorageType, typename R,typename X1, typename X2, 1424 typename X3, typename X4> 1425struct Invoker<1, StorageType, R(X1, X2, X3, X4)> { 1426 typedef R(RunType)(BindStateBase*, 1427 typename CallbackParamTraits<X2>::ForwardType, 1428 typename CallbackParamTraits<X3>::ForwardType, 1429 typename CallbackParamTraits<X4>::ForwardType); 1430 1431 typedef R(UnboundRunType)(X2, X3, X4); 1432 1433 static R Run(BindStateBase* base, 1434 typename CallbackParamTraits<X2>::ForwardType x2, 1435 typename CallbackParamTraits<X3>::ForwardType x3, 1436 typename CallbackParamTraits<X4>::ForwardType x4) { 1437 StorageType* storage = static_cast<StorageType*>(base); 1438 1439 // Local references to make debugger stepping easier. If in a debugger, 1440 // you really want to warp ahead and step through the 1441 // InvokeHelper<>::MakeItSo() call below. 1442 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 1443 1444 typename Bound1UnwrapTraits::ForwardType x1 = 1445 Bound1UnwrapTraits::Unwrap(storage->p1_); 1446 return InvokeHelper<StorageType::IsWeakCall::value, R, 1447 typename StorageType::RunnableType, 1448 void(typename Bound1UnwrapTraits::ForwardType, 1449 typename CallbackParamTraits<X2>::ForwardType x2, 1450 typename CallbackParamTraits<X3>::ForwardType x3, 1451 typename CallbackParamTraits<X4>::ForwardType x4)> 1452 ::MakeItSo(storage->runnable_, CallbackForward(x1), 1453 CallbackForward(x2), CallbackForward(x3), 1454 CallbackForward(x4)); 1455 } 1456}; 1457 1458// Arity 4 -> 2. 1459template <typename StorageType, typename R,typename X1, typename X2, 1460 typename X3, typename X4> 1461struct Invoker<2, StorageType, R(X1, X2, X3, X4)> { 1462 typedef R(RunType)(BindStateBase*, 1463 typename CallbackParamTraits<X3>::ForwardType, 1464 typename CallbackParamTraits<X4>::ForwardType); 1465 1466 typedef R(UnboundRunType)(X3, X4); 1467 1468 static R Run(BindStateBase* base, 1469 typename CallbackParamTraits<X3>::ForwardType x3, 1470 typename CallbackParamTraits<X4>::ForwardType x4) { 1471 StorageType* storage = static_cast<StorageType*>(base); 1472 1473 // Local references to make debugger stepping easier. If in a debugger, 1474 // you really want to warp ahead and step through the 1475 // InvokeHelper<>::MakeItSo() call below. 1476 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 1477 typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; 1478 1479 typename Bound1UnwrapTraits::ForwardType x1 = 1480 Bound1UnwrapTraits::Unwrap(storage->p1_); 1481 typename Bound2UnwrapTraits::ForwardType x2 = 1482 Bound2UnwrapTraits::Unwrap(storage->p2_); 1483 return InvokeHelper<StorageType::IsWeakCall::value, R, 1484 typename StorageType::RunnableType, 1485 void(typename Bound1UnwrapTraits::ForwardType, 1486 typename Bound2UnwrapTraits::ForwardType, 1487 typename CallbackParamTraits<X3>::ForwardType x3, 1488 typename CallbackParamTraits<X4>::ForwardType x4)> 1489 ::MakeItSo(storage->runnable_, CallbackForward(x1), 1490 CallbackForward(x2), CallbackForward(x3), 1491 CallbackForward(x4)); 1492 } 1493}; 1494 1495// Arity 4 -> 1. 1496template <typename StorageType, typename R,typename X1, typename X2, 1497 typename X3, typename X4> 1498struct Invoker<3, StorageType, R(X1, X2, X3, X4)> { 1499 typedef R(RunType)(BindStateBase*, 1500 typename CallbackParamTraits<X4>::ForwardType); 1501 1502 typedef R(UnboundRunType)(X4); 1503 1504 static R Run(BindStateBase* base, 1505 typename CallbackParamTraits<X4>::ForwardType x4) { 1506 StorageType* storage = static_cast<StorageType*>(base); 1507 1508 // Local references to make debugger stepping easier. If in a debugger, 1509 // you really want to warp ahead and step through the 1510 // InvokeHelper<>::MakeItSo() call below. 1511 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 1512 typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; 1513 typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; 1514 1515 typename Bound1UnwrapTraits::ForwardType x1 = 1516 Bound1UnwrapTraits::Unwrap(storage->p1_); 1517 typename Bound2UnwrapTraits::ForwardType x2 = 1518 Bound2UnwrapTraits::Unwrap(storage->p2_); 1519 typename Bound3UnwrapTraits::ForwardType x3 = 1520 Bound3UnwrapTraits::Unwrap(storage->p3_); 1521 return InvokeHelper<StorageType::IsWeakCall::value, R, 1522 typename StorageType::RunnableType, 1523 void(typename Bound1UnwrapTraits::ForwardType, 1524 typename Bound2UnwrapTraits::ForwardType, 1525 typename Bound3UnwrapTraits::ForwardType, 1526 typename CallbackParamTraits<X4>::ForwardType x4)> 1527 ::MakeItSo(storage->runnable_, CallbackForward(x1), 1528 CallbackForward(x2), CallbackForward(x3), 1529 CallbackForward(x4)); 1530 } 1531}; 1532 1533// Arity 4 -> 0. 1534template <typename StorageType, typename R,typename X1, typename X2, 1535 typename X3, typename X4> 1536struct Invoker<4, StorageType, R(X1, X2, X3, X4)> { 1537 typedef R(RunType)(BindStateBase*); 1538 1539 typedef R(UnboundRunType)(); 1540 1541 static R Run(BindStateBase* base) { 1542 StorageType* storage = static_cast<StorageType*>(base); 1543 1544 // Local references to make debugger stepping easier. If in a debugger, 1545 // you really want to warp ahead and step through the 1546 // InvokeHelper<>::MakeItSo() call below. 1547 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 1548 typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; 1549 typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; 1550 typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits; 1551 1552 typename Bound1UnwrapTraits::ForwardType x1 = 1553 Bound1UnwrapTraits::Unwrap(storage->p1_); 1554 typename Bound2UnwrapTraits::ForwardType x2 = 1555 Bound2UnwrapTraits::Unwrap(storage->p2_); 1556 typename Bound3UnwrapTraits::ForwardType x3 = 1557 Bound3UnwrapTraits::Unwrap(storage->p3_); 1558 typename Bound4UnwrapTraits::ForwardType x4 = 1559 Bound4UnwrapTraits::Unwrap(storage->p4_); 1560 return InvokeHelper<StorageType::IsWeakCall::value, R, 1561 typename StorageType::RunnableType, 1562 void(typename Bound1UnwrapTraits::ForwardType, 1563 typename Bound2UnwrapTraits::ForwardType, 1564 typename Bound3UnwrapTraits::ForwardType, 1565 typename Bound4UnwrapTraits::ForwardType)> 1566 ::MakeItSo(storage->runnable_, CallbackForward(x1), 1567 CallbackForward(x2), CallbackForward(x3), 1568 CallbackForward(x4)); 1569 } 1570}; 1571 1572// Arity 5 -> 5. 1573template <typename StorageType, typename R,typename X1, typename X2, 1574 typename X3, typename X4, typename X5> 1575struct Invoker<0, StorageType, R(X1, X2, X3, X4, X5)> { 1576 typedef R(RunType)(BindStateBase*, 1577 typename CallbackParamTraits<X1>::ForwardType, 1578 typename CallbackParamTraits<X2>::ForwardType, 1579 typename CallbackParamTraits<X3>::ForwardType, 1580 typename CallbackParamTraits<X4>::ForwardType, 1581 typename CallbackParamTraits<X5>::ForwardType); 1582 1583 typedef R(UnboundRunType)(X1, X2, X3, X4, X5); 1584 1585 static R Run(BindStateBase* base, 1586 typename CallbackParamTraits<X1>::ForwardType x1, 1587 typename CallbackParamTraits<X2>::ForwardType x2, 1588 typename CallbackParamTraits<X3>::ForwardType x3, 1589 typename CallbackParamTraits<X4>::ForwardType x4, 1590 typename CallbackParamTraits<X5>::ForwardType x5) { 1591 StorageType* storage = static_cast<StorageType*>(base); 1592 1593 // Local references to make debugger stepping easier. If in a debugger, 1594 // you really want to warp ahead and step through the 1595 // InvokeHelper<>::MakeItSo() call below. 1596 1597 return InvokeHelper<StorageType::IsWeakCall::value, R, 1598 typename StorageType::RunnableType, 1599 void(typename CallbackParamTraits<X1>::ForwardType x1, 1600 typename CallbackParamTraits<X2>::ForwardType x2, 1601 typename CallbackParamTraits<X3>::ForwardType x3, 1602 typename CallbackParamTraits<X4>::ForwardType x4, 1603 typename CallbackParamTraits<X5>::ForwardType x5)> 1604 ::MakeItSo(storage->runnable_, CallbackForward(x1), 1605 CallbackForward(x2), CallbackForward(x3), 1606 CallbackForward(x4), CallbackForward(x5)); 1607 } 1608}; 1609 1610// Arity 5 -> 4. 1611template <typename StorageType, typename R,typename X1, typename X2, 1612 typename X3, typename X4, typename X5> 1613struct Invoker<1, StorageType, R(X1, X2, X3, X4, X5)> { 1614 typedef R(RunType)(BindStateBase*, 1615 typename CallbackParamTraits<X2>::ForwardType, 1616 typename CallbackParamTraits<X3>::ForwardType, 1617 typename CallbackParamTraits<X4>::ForwardType, 1618 typename CallbackParamTraits<X5>::ForwardType); 1619 1620 typedef R(UnboundRunType)(X2, X3, X4, X5); 1621 1622 static R Run(BindStateBase* base, 1623 typename CallbackParamTraits<X2>::ForwardType x2, 1624 typename CallbackParamTraits<X3>::ForwardType x3, 1625 typename CallbackParamTraits<X4>::ForwardType x4, 1626 typename CallbackParamTraits<X5>::ForwardType x5) { 1627 StorageType* storage = static_cast<StorageType*>(base); 1628 1629 // Local references to make debugger stepping easier. If in a debugger, 1630 // you really want to warp ahead and step through the 1631 // InvokeHelper<>::MakeItSo() call below. 1632 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 1633 1634 typename Bound1UnwrapTraits::ForwardType x1 = 1635 Bound1UnwrapTraits::Unwrap(storage->p1_); 1636 return InvokeHelper<StorageType::IsWeakCall::value, R, 1637 typename StorageType::RunnableType, 1638 void(typename Bound1UnwrapTraits::ForwardType, 1639 typename CallbackParamTraits<X2>::ForwardType x2, 1640 typename CallbackParamTraits<X3>::ForwardType x3, 1641 typename CallbackParamTraits<X4>::ForwardType x4, 1642 typename CallbackParamTraits<X5>::ForwardType x5)> 1643 ::MakeItSo(storage->runnable_, CallbackForward(x1), 1644 CallbackForward(x2), CallbackForward(x3), 1645 CallbackForward(x4), CallbackForward(x5)); 1646 } 1647}; 1648 1649// Arity 5 -> 3. 1650template <typename StorageType, typename R,typename X1, typename X2, 1651 typename X3, typename X4, typename X5> 1652struct Invoker<2, StorageType, R(X1, X2, X3, X4, X5)> { 1653 typedef R(RunType)(BindStateBase*, 1654 typename CallbackParamTraits<X3>::ForwardType, 1655 typename CallbackParamTraits<X4>::ForwardType, 1656 typename CallbackParamTraits<X5>::ForwardType); 1657 1658 typedef R(UnboundRunType)(X3, X4, X5); 1659 1660 static R Run(BindStateBase* base, 1661 typename CallbackParamTraits<X3>::ForwardType x3, 1662 typename CallbackParamTraits<X4>::ForwardType x4, 1663 typename CallbackParamTraits<X5>::ForwardType x5) { 1664 StorageType* storage = static_cast<StorageType*>(base); 1665 1666 // Local references to make debugger stepping easier. If in a debugger, 1667 // you really want to warp ahead and step through the 1668 // InvokeHelper<>::MakeItSo() call below. 1669 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 1670 typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; 1671 1672 typename Bound1UnwrapTraits::ForwardType x1 = 1673 Bound1UnwrapTraits::Unwrap(storage->p1_); 1674 typename Bound2UnwrapTraits::ForwardType x2 = 1675 Bound2UnwrapTraits::Unwrap(storage->p2_); 1676 return InvokeHelper<StorageType::IsWeakCall::value, R, 1677 typename StorageType::RunnableType, 1678 void(typename Bound1UnwrapTraits::ForwardType, 1679 typename Bound2UnwrapTraits::ForwardType, 1680 typename CallbackParamTraits<X3>::ForwardType x3, 1681 typename CallbackParamTraits<X4>::ForwardType x4, 1682 typename CallbackParamTraits<X5>::ForwardType x5)> 1683 ::MakeItSo(storage->runnable_, CallbackForward(x1), 1684 CallbackForward(x2), CallbackForward(x3), 1685 CallbackForward(x4), CallbackForward(x5)); 1686 } 1687}; 1688 1689// Arity 5 -> 2. 1690template <typename StorageType, typename R,typename X1, typename X2, 1691 typename X3, typename X4, typename X5> 1692struct Invoker<3, StorageType, R(X1, X2, X3, X4, X5)> { 1693 typedef R(RunType)(BindStateBase*, 1694 typename CallbackParamTraits<X4>::ForwardType, 1695 typename CallbackParamTraits<X5>::ForwardType); 1696 1697 typedef R(UnboundRunType)(X4, X5); 1698 1699 static R Run(BindStateBase* base, 1700 typename CallbackParamTraits<X4>::ForwardType x4, 1701 typename CallbackParamTraits<X5>::ForwardType x5) { 1702 StorageType* storage = static_cast<StorageType*>(base); 1703 1704 // Local references to make debugger stepping easier. If in a debugger, 1705 // you really want to warp ahead and step through the 1706 // InvokeHelper<>::MakeItSo() call below. 1707 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 1708 typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; 1709 typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; 1710 1711 typename Bound1UnwrapTraits::ForwardType x1 = 1712 Bound1UnwrapTraits::Unwrap(storage->p1_); 1713 typename Bound2UnwrapTraits::ForwardType x2 = 1714 Bound2UnwrapTraits::Unwrap(storage->p2_); 1715 typename Bound3UnwrapTraits::ForwardType x3 = 1716 Bound3UnwrapTraits::Unwrap(storage->p3_); 1717 return InvokeHelper<StorageType::IsWeakCall::value, R, 1718 typename StorageType::RunnableType, 1719 void(typename Bound1UnwrapTraits::ForwardType, 1720 typename Bound2UnwrapTraits::ForwardType, 1721 typename Bound3UnwrapTraits::ForwardType, 1722 typename CallbackParamTraits<X4>::ForwardType x4, 1723 typename CallbackParamTraits<X5>::ForwardType x5)> 1724 ::MakeItSo(storage->runnable_, CallbackForward(x1), 1725 CallbackForward(x2), CallbackForward(x3), 1726 CallbackForward(x4), CallbackForward(x5)); 1727 } 1728}; 1729 1730// Arity 5 -> 1. 1731template <typename StorageType, typename R,typename X1, typename X2, 1732 typename X3, typename X4, typename X5> 1733struct Invoker<4, StorageType, R(X1, X2, X3, X4, X5)> { 1734 typedef R(RunType)(BindStateBase*, 1735 typename CallbackParamTraits<X5>::ForwardType); 1736 1737 typedef R(UnboundRunType)(X5); 1738 1739 static R Run(BindStateBase* base, 1740 typename CallbackParamTraits<X5>::ForwardType x5) { 1741 StorageType* storage = static_cast<StorageType*>(base); 1742 1743 // Local references to make debugger stepping easier. If in a debugger, 1744 // you really want to warp ahead and step through the 1745 // InvokeHelper<>::MakeItSo() call below. 1746 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 1747 typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; 1748 typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; 1749 typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits; 1750 1751 typename Bound1UnwrapTraits::ForwardType x1 = 1752 Bound1UnwrapTraits::Unwrap(storage->p1_); 1753 typename Bound2UnwrapTraits::ForwardType x2 = 1754 Bound2UnwrapTraits::Unwrap(storage->p2_); 1755 typename Bound3UnwrapTraits::ForwardType x3 = 1756 Bound3UnwrapTraits::Unwrap(storage->p3_); 1757 typename Bound4UnwrapTraits::ForwardType x4 = 1758 Bound4UnwrapTraits::Unwrap(storage->p4_); 1759 return InvokeHelper<StorageType::IsWeakCall::value, R, 1760 typename StorageType::RunnableType, 1761 void(typename Bound1UnwrapTraits::ForwardType, 1762 typename Bound2UnwrapTraits::ForwardType, 1763 typename Bound3UnwrapTraits::ForwardType, 1764 typename Bound4UnwrapTraits::ForwardType, 1765 typename CallbackParamTraits<X5>::ForwardType x5)> 1766 ::MakeItSo(storage->runnable_, CallbackForward(x1), 1767 CallbackForward(x2), CallbackForward(x3), 1768 CallbackForward(x4), CallbackForward(x5)); 1769 } 1770}; 1771 1772// Arity 5 -> 0. 1773template <typename StorageType, typename R,typename X1, typename X2, 1774 typename X3, typename X4, typename X5> 1775struct Invoker<5, StorageType, R(X1, X2, X3, X4, X5)> { 1776 typedef R(RunType)(BindStateBase*); 1777 1778 typedef R(UnboundRunType)(); 1779 1780 static R Run(BindStateBase* base) { 1781 StorageType* storage = static_cast<StorageType*>(base); 1782 1783 // Local references to make debugger stepping easier. If in a debugger, 1784 // you really want to warp ahead and step through the 1785 // InvokeHelper<>::MakeItSo() call below. 1786 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 1787 typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; 1788 typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; 1789 typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits; 1790 typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits; 1791 1792 typename Bound1UnwrapTraits::ForwardType x1 = 1793 Bound1UnwrapTraits::Unwrap(storage->p1_); 1794 typename Bound2UnwrapTraits::ForwardType x2 = 1795 Bound2UnwrapTraits::Unwrap(storage->p2_); 1796 typename Bound3UnwrapTraits::ForwardType x3 = 1797 Bound3UnwrapTraits::Unwrap(storage->p3_); 1798 typename Bound4UnwrapTraits::ForwardType x4 = 1799 Bound4UnwrapTraits::Unwrap(storage->p4_); 1800 typename Bound5UnwrapTraits::ForwardType x5 = 1801 Bound5UnwrapTraits::Unwrap(storage->p5_); 1802 return InvokeHelper<StorageType::IsWeakCall::value, R, 1803 typename StorageType::RunnableType, 1804 void(typename Bound1UnwrapTraits::ForwardType, 1805 typename Bound2UnwrapTraits::ForwardType, 1806 typename Bound3UnwrapTraits::ForwardType, 1807 typename Bound4UnwrapTraits::ForwardType, 1808 typename Bound5UnwrapTraits::ForwardType)> 1809 ::MakeItSo(storage->runnable_, CallbackForward(x1), 1810 CallbackForward(x2), CallbackForward(x3), 1811 CallbackForward(x4), CallbackForward(x5)); 1812 } 1813}; 1814 1815// Arity 6 -> 6. 1816template <typename StorageType, typename R,typename X1, typename X2, 1817 typename X3, typename X4, typename X5, typename X6> 1818struct Invoker<0, StorageType, R(X1, X2, X3, X4, X5, X6)> { 1819 typedef R(RunType)(BindStateBase*, 1820 typename CallbackParamTraits<X1>::ForwardType, 1821 typename CallbackParamTraits<X2>::ForwardType, 1822 typename CallbackParamTraits<X3>::ForwardType, 1823 typename CallbackParamTraits<X4>::ForwardType, 1824 typename CallbackParamTraits<X5>::ForwardType, 1825 typename CallbackParamTraits<X6>::ForwardType); 1826 1827 typedef R(UnboundRunType)(X1, X2, X3, X4, X5, X6); 1828 1829 static R Run(BindStateBase* base, 1830 typename CallbackParamTraits<X1>::ForwardType x1, 1831 typename CallbackParamTraits<X2>::ForwardType x2, 1832 typename CallbackParamTraits<X3>::ForwardType x3, 1833 typename CallbackParamTraits<X4>::ForwardType x4, 1834 typename CallbackParamTraits<X5>::ForwardType x5, 1835 typename CallbackParamTraits<X6>::ForwardType x6) { 1836 StorageType* storage = static_cast<StorageType*>(base); 1837 1838 // Local references to make debugger stepping easier. If in a debugger, 1839 // you really want to warp ahead and step through the 1840 // InvokeHelper<>::MakeItSo() call below. 1841 1842 return InvokeHelper<StorageType::IsWeakCall::value, R, 1843 typename StorageType::RunnableType, 1844 void(typename CallbackParamTraits<X1>::ForwardType x1, 1845 typename CallbackParamTraits<X2>::ForwardType x2, 1846 typename CallbackParamTraits<X3>::ForwardType x3, 1847 typename CallbackParamTraits<X4>::ForwardType x4, 1848 typename CallbackParamTraits<X5>::ForwardType x5, 1849 typename CallbackParamTraits<X6>::ForwardType x6)> 1850 ::MakeItSo(storage->runnable_, CallbackForward(x1), 1851 CallbackForward(x2), CallbackForward(x3), 1852 CallbackForward(x4), CallbackForward(x5), 1853 CallbackForward(x6)); 1854 } 1855}; 1856 1857// Arity 6 -> 5. 1858template <typename StorageType, typename R,typename X1, typename X2, 1859 typename X3, typename X4, typename X5, typename X6> 1860struct Invoker<1, StorageType, R(X1, X2, X3, X4, X5, X6)> { 1861 typedef R(RunType)(BindStateBase*, 1862 typename CallbackParamTraits<X2>::ForwardType, 1863 typename CallbackParamTraits<X3>::ForwardType, 1864 typename CallbackParamTraits<X4>::ForwardType, 1865 typename CallbackParamTraits<X5>::ForwardType, 1866 typename CallbackParamTraits<X6>::ForwardType); 1867 1868 typedef R(UnboundRunType)(X2, X3, X4, X5, X6); 1869 1870 static R Run(BindStateBase* base, 1871 typename CallbackParamTraits<X2>::ForwardType x2, 1872 typename CallbackParamTraits<X3>::ForwardType x3, 1873 typename CallbackParamTraits<X4>::ForwardType x4, 1874 typename CallbackParamTraits<X5>::ForwardType x5, 1875 typename CallbackParamTraits<X6>::ForwardType x6) { 1876 StorageType* storage = static_cast<StorageType*>(base); 1877 1878 // Local references to make debugger stepping easier. If in a debugger, 1879 // you really want to warp ahead and step through the 1880 // InvokeHelper<>::MakeItSo() call below. 1881 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 1882 1883 typename Bound1UnwrapTraits::ForwardType x1 = 1884 Bound1UnwrapTraits::Unwrap(storage->p1_); 1885 return InvokeHelper<StorageType::IsWeakCall::value, R, 1886 typename StorageType::RunnableType, 1887 void(typename Bound1UnwrapTraits::ForwardType, 1888 typename CallbackParamTraits<X2>::ForwardType x2, 1889 typename CallbackParamTraits<X3>::ForwardType x3, 1890 typename CallbackParamTraits<X4>::ForwardType x4, 1891 typename CallbackParamTraits<X5>::ForwardType x5, 1892 typename CallbackParamTraits<X6>::ForwardType x6)> 1893 ::MakeItSo(storage->runnable_, CallbackForward(x1), 1894 CallbackForward(x2), CallbackForward(x3), 1895 CallbackForward(x4), CallbackForward(x5), 1896 CallbackForward(x6)); 1897 } 1898}; 1899 1900// Arity 6 -> 4. 1901template <typename StorageType, typename R,typename X1, typename X2, 1902 typename X3, typename X4, typename X5, typename X6> 1903struct Invoker<2, StorageType, R(X1, X2, X3, X4, X5, X6)> { 1904 typedef R(RunType)(BindStateBase*, 1905 typename CallbackParamTraits<X3>::ForwardType, 1906 typename CallbackParamTraits<X4>::ForwardType, 1907 typename CallbackParamTraits<X5>::ForwardType, 1908 typename CallbackParamTraits<X6>::ForwardType); 1909 1910 typedef R(UnboundRunType)(X3, X4, X5, X6); 1911 1912 static R Run(BindStateBase* base, 1913 typename CallbackParamTraits<X3>::ForwardType x3, 1914 typename CallbackParamTraits<X4>::ForwardType x4, 1915 typename CallbackParamTraits<X5>::ForwardType x5, 1916 typename CallbackParamTraits<X6>::ForwardType x6) { 1917 StorageType* storage = static_cast<StorageType*>(base); 1918 1919 // Local references to make debugger stepping easier. If in a debugger, 1920 // you really want to warp ahead and step through the 1921 // InvokeHelper<>::MakeItSo() call below. 1922 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 1923 typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; 1924 1925 typename Bound1UnwrapTraits::ForwardType x1 = 1926 Bound1UnwrapTraits::Unwrap(storage->p1_); 1927 typename Bound2UnwrapTraits::ForwardType x2 = 1928 Bound2UnwrapTraits::Unwrap(storage->p2_); 1929 return InvokeHelper<StorageType::IsWeakCall::value, R, 1930 typename StorageType::RunnableType, 1931 void(typename Bound1UnwrapTraits::ForwardType, 1932 typename Bound2UnwrapTraits::ForwardType, 1933 typename CallbackParamTraits<X3>::ForwardType x3, 1934 typename CallbackParamTraits<X4>::ForwardType x4, 1935 typename CallbackParamTraits<X5>::ForwardType x5, 1936 typename CallbackParamTraits<X6>::ForwardType x6)> 1937 ::MakeItSo(storage->runnable_, CallbackForward(x1), 1938 CallbackForward(x2), CallbackForward(x3), 1939 CallbackForward(x4), CallbackForward(x5), 1940 CallbackForward(x6)); 1941 } 1942}; 1943 1944// Arity 6 -> 3. 1945template <typename StorageType, typename R,typename X1, typename X2, 1946 typename X3, typename X4, typename X5, typename X6> 1947struct Invoker<3, StorageType, R(X1, X2, X3, X4, X5, X6)> { 1948 typedef R(RunType)(BindStateBase*, 1949 typename CallbackParamTraits<X4>::ForwardType, 1950 typename CallbackParamTraits<X5>::ForwardType, 1951 typename CallbackParamTraits<X6>::ForwardType); 1952 1953 typedef R(UnboundRunType)(X4, X5, X6); 1954 1955 static R Run(BindStateBase* base, 1956 typename CallbackParamTraits<X4>::ForwardType x4, 1957 typename CallbackParamTraits<X5>::ForwardType x5, 1958 typename CallbackParamTraits<X6>::ForwardType x6) { 1959 StorageType* storage = static_cast<StorageType*>(base); 1960 1961 // Local references to make debugger stepping easier. If in a debugger, 1962 // you really want to warp ahead and step through the 1963 // InvokeHelper<>::MakeItSo() call below. 1964 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 1965 typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; 1966 typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; 1967 1968 typename Bound1UnwrapTraits::ForwardType x1 = 1969 Bound1UnwrapTraits::Unwrap(storage->p1_); 1970 typename Bound2UnwrapTraits::ForwardType x2 = 1971 Bound2UnwrapTraits::Unwrap(storage->p2_); 1972 typename Bound3UnwrapTraits::ForwardType x3 = 1973 Bound3UnwrapTraits::Unwrap(storage->p3_); 1974 return InvokeHelper<StorageType::IsWeakCall::value, R, 1975 typename StorageType::RunnableType, 1976 void(typename Bound1UnwrapTraits::ForwardType, 1977 typename Bound2UnwrapTraits::ForwardType, 1978 typename Bound3UnwrapTraits::ForwardType, 1979 typename CallbackParamTraits<X4>::ForwardType x4, 1980 typename CallbackParamTraits<X5>::ForwardType x5, 1981 typename CallbackParamTraits<X6>::ForwardType x6)> 1982 ::MakeItSo(storage->runnable_, CallbackForward(x1), 1983 CallbackForward(x2), CallbackForward(x3), 1984 CallbackForward(x4), CallbackForward(x5), 1985 CallbackForward(x6)); 1986 } 1987}; 1988 1989// Arity 6 -> 2. 1990template <typename StorageType, typename R,typename X1, typename X2, 1991 typename X3, typename X4, typename X5, typename X6> 1992struct Invoker<4, StorageType, R(X1, X2, X3, X4, X5, X6)> { 1993 typedef R(RunType)(BindStateBase*, 1994 typename CallbackParamTraits<X5>::ForwardType, 1995 typename CallbackParamTraits<X6>::ForwardType); 1996 1997 typedef R(UnboundRunType)(X5, X6); 1998 1999 static R Run(BindStateBase* base, 2000 typename CallbackParamTraits<X5>::ForwardType x5, 2001 typename CallbackParamTraits<X6>::ForwardType x6) { 2002 StorageType* storage = static_cast<StorageType*>(base); 2003 2004 // Local references to make debugger stepping easier. If in a debugger, 2005 // you really want to warp ahead and step through the 2006 // InvokeHelper<>::MakeItSo() call below. 2007 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 2008 typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; 2009 typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; 2010 typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits; 2011 2012 typename Bound1UnwrapTraits::ForwardType x1 = 2013 Bound1UnwrapTraits::Unwrap(storage->p1_); 2014 typename Bound2UnwrapTraits::ForwardType x2 = 2015 Bound2UnwrapTraits::Unwrap(storage->p2_); 2016 typename Bound3UnwrapTraits::ForwardType x3 = 2017 Bound3UnwrapTraits::Unwrap(storage->p3_); 2018 typename Bound4UnwrapTraits::ForwardType x4 = 2019 Bound4UnwrapTraits::Unwrap(storage->p4_); 2020 return InvokeHelper<StorageType::IsWeakCall::value, R, 2021 typename StorageType::RunnableType, 2022 void(typename Bound1UnwrapTraits::ForwardType, 2023 typename Bound2UnwrapTraits::ForwardType, 2024 typename Bound3UnwrapTraits::ForwardType, 2025 typename Bound4UnwrapTraits::ForwardType, 2026 typename CallbackParamTraits<X5>::ForwardType x5, 2027 typename CallbackParamTraits<X6>::ForwardType x6)> 2028 ::MakeItSo(storage->runnable_, CallbackForward(x1), 2029 CallbackForward(x2), CallbackForward(x3), 2030 CallbackForward(x4), CallbackForward(x5), 2031 CallbackForward(x6)); 2032 } 2033}; 2034 2035// Arity 6 -> 1. 2036template <typename StorageType, typename R,typename X1, typename X2, 2037 typename X3, typename X4, typename X5, typename X6> 2038struct Invoker<5, StorageType, R(X1, X2, X3, X4, X5, X6)> { 2039 typedef R(RunType)(BindStateBase*, 2040 typename CallbackParamTraits<X6>::ForwardType); 2041 2042 typedef R(UnboundRunType)(X6); 2043 2044 static R Run(BindStateBase* base, 2045 typename CallbackParamTraits<X6>::ForwardType x6) { 2046 StorageType* storage = static_cast<StorageType*>(base); 2047 2048 // Local references to make debugger stepping easier. If in a debugger, 2049 // you really want to warp ahead and step through the 2050 // InvokeHelper<>::MakeItSo() call below. 2051 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 2052 typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; 2053 typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; 2054 typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits; 2055 typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits; 2056 2057 typename Bound1UnwrapTraits::ForwardType x1 = 2058 Bound1UnwrapTraits::Unwrap(storage->p1_); 2059 typename Bound2UnwrapTraits::ForwardType x2 = 2060 Bound2UnwrapTraits::Unwrap(storage->p2_); 2061 typename Bound3UnwrapTraits::ForwardType x3 = 2062 Bound3UnwrapTraits::Unwrap(storage->p3_); 2063 typename Bound4UnwrapTraits::ForwardType x4 = 2064 Bound4UnwrapTraits::Unwrap(storage->p4_); 2065 typename Bound5UnwrapTraits::ForwardType x5 = 2066 Bound5UnwrapTraits::Unwrap(storage->p5_); 2067 return InvokeHelper<StorageType::IsWeakCall::value, R, 2068 typename StorageType::RunnableType, 2069 void(typename Bound1UnwrapTraits::ForwardType, 2070 typename Bound2UnwrapTraits::ForwardType, 2071 typename Bound3UnwrapTraits::ForwardType, 2072 typename Bound4UnwrapTraits::ForwardType, 2073 typename Bound5UnwrapTraits::ForwardType, 2074 typename CallbackParamTraits<X6>::ForwardType x6)> 2075 ::MakeItSo(storage->runnable_, CallbackForward(x1), 2076 CallbackForward(x2), CallbackForward(x3), 2077 CallbackForward(x4), CallbackForward(x5), 2078 CallbackForward(x6)); 2079 } 2080}; 2081 2082// Arity 6 -> 0. 2083template <typename StorageType, typename R,typename X1, typename X2, 2084 typename X3, typename X4, typename X5, typename X6> 2085struct Invoker<6, StorageType, R(X1, X2, X3, X4, X5, X6)> { 2086 typedef R(RunType)(BindStateBase*); 2087 2088 typedef R(UnboundRunType)(); 2089 2090 static R Run(BindStateBase* base) { 2091 StorageType* storage = static_cast<StorageType*>(base); 2092 2093 // Local references to make debugger stepping easier. If in a debugger, 2094 // you really want to warp ahead and step through the 2095 // InvokeHelper<>::MakeItSo() call below. 2096 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 2097 typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; 2098 typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; 2099 typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits; 2100 typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits; 2101 typedef typename StorageType::Bound6UnwrapTraits Bound6UnwrapTraits; 2102 2103 typename Bound1UnwrapTraits::ForwardType x1 = 2104 Bound1UnwrapTraits::Unwrap(storage->p1_); 2105 typename Bound2UnwrapTraits::ForwardType x2 = 2106 Bound2UnwrapTraits::Unwrap(storage->p2_); 2107 typename Bound3UnwrapTraits::ForwardType x3 = 2108 Bound3UnwrapTraits::Unwrap(storage->p3_); 2109 typename Bound4UnwrapTraits::ForwardType x4 = 2110 Bound4UnwrapTraits::Unwrap(storage->p4_); 2111 typename Bound5UnwrapTraits::ForwardType x5 = 2112 Bound5UnwrapTraits::Unwrap(storage->p5_); 2113 typename Bound6UnwrapTraits::ForwardType x6 = 2114 Bound6UnwrapTraits::Unwrap(storage->p6_); 2115 return InvokeHelper<StorageType::IsWeakCall::value, R, 2116 typename StorageType::RunnableType, 2117 void(typename Bound1UnwrapTraits::ForwardType, 2118 typename Bound2UnwrapTraits::ForwardType, 2119 typename Bound3UnwrapTraits::ForwardType, 2120 typename Bound4UnwrapTraits::ForwardType, 2121 typename Bound5UnwrapTraits::ForwardType, 2122 typename Bound6UnwrapTraits::ForwardType)> 2123 ::MakeItSo(storage->runnable_, CallbackForward(x1), 2124 CallbackForward(x2), CallbackForward(x3), 2125 CallbackForward(x4), CallbackForward(x5), 2126 CallbackForward(x6)); 2127 } 2128}; 2129 2130// Arity 7 -> 7. 2131template <typename StorageType, typename R,typename X1, typename X2, 2132 typename X3, typename X4, typename X5, typename X6, typename X7> 2133struct Invoker<0, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> { 2134 typedef R(RunType)(BindStateBase*, 2135 typename CallbackParamTraits<X1>::ForwardType, 2136 typename CallbackParamTraits<X2>::ForwardType, 2137 typename CallbackParamTraits<X3>::ForwardType, 2138 typename CallbackParamTraits<X4>::ForwardType, 2139 typename CallbackParamTraits<X5>::ForwardType, 2140 typename CallbackParamTraits<X6>::ForwardType, 2141 typename CallbackParamTraits<X7>::ForwardType); 2142 2143 typedef R(UnboundRunType)(X1, X2, X3, X4, X5, X6, X7); 2144 2145 static R Run(BindStateBase* base, 2146 typename CallbackParamTraits<X1>::ForwardType x1, 2147 typename CallbackParamTraits<X2>::ForwardType x2, 2148 typename CallbackParamTraits<X3>::ForwardType x3, 2149 typename CallbackParamTraits<X4>::ForwardType x4, 2150 typename CallbackParamTraits<X5>::ForwardType x5, 2151 typename CallbackParamTraits<X6>::ForwardType x6, 2152 typename CallbackParamTraits<X7>::ForwardType x7) { 2153 StorageType* storage = static_cast<StorageType*>(base); 2154 2155 // Local references to make debugger stepping easier. If in a debugger, 2156 // you really want to warp ahead and step through the 2157 // InvokeHelper<>::MakeItSo() call below. 2158 2159 return InvokeHelper<StorageType::IsWeakCall::value, R, 2160 typename StorageType::RunnableType, 2161 void(typename CallbackParamTraits<X1>::ForwardType x1, 2162 typename CallbackParamTraits<X2>::ForwardType x2, 2163 typename CallbackParamTraits<X3>::ForwardType x3, 2164 typename CallbackParamTraits<X4>::ForwardType x4, 2165 typename CallbackParamTraits<X5>::ForwardType x5, 2166 typename CallbackParamTraits<X6>::ForwardType x6, 2167 typename CallbackParamTraits<X7>::ForwardType x7)> 2168 ::MakeItSo(storage->runnable_, CallbackForward(x1), 2169 CallbackForward(x2), CallbackForward(x3), 2170 CallbackForward(x4), CallbackForward(x5), 2171 CallbackForward(x6), CallbackForward(x7)); 2172 } 2173}; 2174 2175// Arity 7 -> 6. 2176template <typename StorageType, typename R,typename X1, typename X2, 2177 typename X3, typename X4, typename X5, typename X6, typename X7> 2178struct Invoker<1, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> { 2179 typedef R(RunType)(BindStateBase*, 2180 typename CallbackParamTraits<X2>::ForwardType, 2181 typename CallbackParamTraits<X3>::ForwardType, 2182 typename CallbackParamTraits<X4>::ForwardType, 2183 typename CallbackParamTraits<X5>::ForwardType, 2184 typename CallbackParamTraits<X6>::ForwardType, 2185 typename CallbackParamTraits<X7>::ForwardType); 2186 2187 typedef R(UnboundRunType)(X2, X3, X4, X5, X6, X7); 2188 2189 static R Run(BindStateBase* base, 2190 typename CallbackParamTraits<X2>::ForwardType x2, 2191 typename CallbackParamTraits<X3>::ForwardType x3, 2192 typename CallbackParamTraits<X4>::ForwardType x4, 2193 typename CallbackParamTraits<X5>::ForwardType x5, 2194 typename CallbackParamTraits<X6>::ForwardType x6, 2195 typename CallbackParamTraits<X7>::ForwardType x7) { 2196 StorageType* storage = static_cast<StorageType*>(base); 2197 2198 // Local references to make debugger stepping easier. If in a debugger, 2199 // you really want to warp ahead and step through the 2200 // InvokeHelper<>::MakeItSo() call below. 2201 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 2202 2203 typename Bound1UnwrapTraits::ForwardType x1 = 2204 Bound1UnwrapTraits::Unwrap(storage->p1_); 2205 return InvokeHelper<StorageType::IsWeakCall::value, R, 2206 typename StorageType::RunnableType, 2207 void(typename Bound1UnwrapTraits::ForwardType, 2208 typename CallbackParamTraits<X2>::ForwardType x2, 2209 typename CallbackParamTraits<X3>::ForwardType x3, 2210 typename CallbackParamTraits<X4>::ForwardType x4, 2211 typename CallbackParamTraits<X5>::ForwardType x5, 2212 typename CallbackParamTraits<X6>::ForwardType x6, 2213 typename CallbackParamTraits<X7>::ForwardType x7)> 2214 ::MakeItSo(storage->runnable_, CallbackForward(x1), 2215 CallbackForward(x2), CallbackForward(x3), 2216 CallbackForward(x4), CallbackForward(x5), 2217 CallbackForward(x6), CallbackForward(x7)); 2218 } 2219}; 2220 2221// Arity 7 -> 5. 2222template <typename StorageType, typename R,typename X1, typename X2, 2223 typename X3, typename X4, typename X5, typename X6, typename X7> 2224struct Invoker<2, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> { 2225 typedef R(RunType)(BindStateBase*, 2226 typename CallbackParamTraits<X3>::ForwardType, 2227 typename CallbackParamTraits<X4>::ForwardType, 2228 typename CallbackParamTraits<X5>::ForwardType, 2229 typename CallbackParamTraits<X6>::ForwardType, 2230 typename CallbackParamTraits<X7>::ForwardType); 2231 2232 typedef R(UnboundRunType)(X3, X4, X5, X6, X7); 2233 2234 static R Run(BindStateBase* base, 2235 typename CallbackParamTraits<X3>::ForwardType x3, 2236 typename CallbackParamTraits<X4>::ForwardType x4, 2237 typename CallbackParamTraits<X5>::ForwardType x5, 2238 typename CallbackParamTraits<X6>::ForwardType x6, 2239 typename CallbackParamTraits<X7>::ForwardType x7) { 2240 StorageType* storage = static_cast<StorageType*>(base); 2241 2242 // Local references to make debugger stepping easier. If in a debugger, 2243 // you really want to warp ahead and step through the 2244 // InvokeHelper<>::MakeItSo() call below. 2245 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 2246 typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; 2247 2248 typename Bound1UnwrapTraits::ForwardType x1 = 2249 Bound1UnwrapTraits::Unwrap(storage->p1_); 2250 typename Bound2UnwrapTraits::ForwardType x2 = 2251 Bound2UnwrapTraits::Unwrap(storage->p2_); 2252 return InvokeHelper<StorageType::IsWeakCall::value, R, 2253 typename StorageType::RunnableType, 2254 void(typename Bound1UnwrapTraits::ForwardType, 2255 typename Bound2UnwrapTraits::ForwardType, 2256 typename CallbackParamTraits<X3>::ForwardType x3, 2257 typename CallbackParamTraits<X4>::ForwardType x4, 2258 typename CallbackParamTraits<X5>::ForwardType x5, 2259 typename CallbackParamTraits<X6>::ForwardType x6, 2260 typename CallbackParamTraits<X7>::ForwardType x7)> 2261 ::MakeItSo(storage->runnable_, CallbackForward(x1), 2262 CallbackForward(x2), CallbackForward(x3), 2263 CallbackForward(x4), CallbackForward(x5), 2264 CallbackForward(x6), CallbackForward(x7)); 2265 } 2266}; 2267 2268// Arity 7 -> 4. 2269template <typename StorageType, typename R,typename X1, typename X2, 2270 typename X3, typename X4, typename X5, typename X6, typename X7> 2271struct Invoker<3, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> { 2272 typedef R(RunType)(BindStateBase*, 2273 typename CallbackParamTraits<X4>::ForwardType, 2274 typename CallbackParamTraits<X5>::ForwardType, 2275 typename CallbackParamTraits<X6>::ForwardType, 2276 typename CallbackParamTraits<X7>::ForwardType); 2277 2278 typedef R(UnboundRunType)(X4, X5, X6, X7); 2279 2280 static R Run(BindStateBase* base, 2281 typename CallbackParamTraits<X4>::ForwardType x4, 2282 typename CallbackParamTraits<X5>::ForwardType x5, 2283 typename CallbackParamTraits<X6>::ForwardType x6, 2284 typename CallbackParamTraits<X7>::ForwardType x7) { 2285 StorageType* storage = static_cast<StorageType*>(base); 2286 2287 // Local references to make debugger stepping easier. If in a debugger, 2288 // you really want to warp ahead and step through the 2289 // InvokeHelper<>::MakeItSo() call below. 2290 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 2291 typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; 2292 typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; 2293 2294 typename Bound1UnwrapTraits::ForwardType x1 = 2295 Bound1UnwrapTraits::Unwrap(storage->p1_); 2296 typename Bound2UnwrapTraits::ForwardType x2 = 2297 Bound2UnwrapTraits::Unwrap(storage->p2_); 2298 typename Bound3UnwrapTraits::ForwardType x3 = 2299 Bound3UnwrapTraits::Unwrap(storage->p3_); 2300 return InvokeHelper<StorageType::IsWeakCall::value, R, 2301 typename StorageType::RunnableType, 2302 void(typename Bound1UnwrapTraits::ForwardType, 2303 typename Bound2UnwrapTraits::ForwardType, 2304 typename Bound3UnwrapTraits::ForwardType, 2305 typename CallbackParamTraits<X4>::ForwardType x4, 2306 typename CallbackParamTraits<X5>::ForwardType x5, 2307 typename CallbackParamTraits<X6>::ForwardType x6, 2308 typename CallbackParamTraits<X7>::ForwardType x7)> 2309 ::MakeItSo(storage->runnable_, CallbackForward(x1), 2310 CallbackForward(x2), CallbackForward(x3), 2311 CallbackForward(x4), CallbackForward(x5), 2312 CallbackForward(x6), CallbackForward(x7)); 2313 } 2314}; 2315 2316// Arity 7 -> 3. 2317template <typename StorageType, typename R,typename X1, typename X2, 2318 typename X3, typename X4, typename X5, typename X6, typename X7> 2319struct Invoker<4, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> { 2320 typedef R(RunType)(BindStateBase*, 2321 typename CallbackParamTraits<X5>::ForwardType, 2322 typename CallbackParamTraits<X6>::ForwardType, 2323 typename CallbackParamTraits<X7>::ForwardType); 2324 2325 typedef R(UnboundRunType)(X5, X6, X7); 2326 2327 static R Run(BindStateBase* base, 2328 typename CallbackParamTraits<X5>::ForwardType x5, 2329 typename CallbackParamTraits<X6>::ForwardType x6, 2330 typename CallbackParamTraits<X7>::ForwardType x7) { 2331 StorageType* storage = static_cast<StorageType*>(base); 2332 2333 // Local references to make debugger stepping easier. If in a debugger, 2334 // you really want to warp ahead and step through the 2335 // InvokeHelper<>::MakeItSo() call below. 2336 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 2337 typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; 2338 typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; 2339 typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits; 2340 2341 typename Bound1UnwrapTraits::ForwardType x1 = 2342 Bound1UnwrapTraits::Unwrap(storage->p1_); 2343 typename Bound2UnwrapTraits::ForwardType x2 = 2344 Bound2UnwrapTraits::Unwrap(storage->p2_); 2345 typename Bound3UnwrapTraits::ForwardType x3 = 2346 Bound3UnwrapTraits::Unwrap(storage->p3_); 2347 typename Bound4UnwrapTraits::ForwardType x4 = 2348 Bound4UnwrapTraits::Unwrap(storage->p4_); 2349 return InvokeHelper<StorageType::IsWeakCall::value, R, 2350 typename StorageType::RunnableType, 2351 void(typename Bound1UnwrapTraits::ForwardType, 2352 typename Bound2UnwrapTraits::ForwardType, 2353 typename Bound3UnwrapTraits::ForwardType, 2354 typename Bound4UnwrapTraits::ForwardType, 2355 typename CallbackParamTraits<X5>::ForwardType x5, 2356 typename CallbackParamTraits<X6>::ForwardType x6, 2357 typename CallbackParamTraits<X7>::ForwardType x7)> 2358 ::MakeItSo(storage->runnable_, CallbackForward(x1), 2359 CallbackForward(x2), CallbackForward(x3), 2360 CallbackForward(x4), CallbackForward(x5), 2361 CallbackForward(x6), CallbackForward(x7)); 2362 } 2363}; 2364 2365// Arity 7 -> 2. 2366template <typename StorageType, typename R,typename X1, typename X2, 2367 typename X3, typename X4, typename X5, typename X6, typename X7> 2368struct Invoker<5, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> { 2369 typedef R(RunType)(BindStateBase*, 2370 typename CallbackParamTraits<X6>::ForwardType, 2371 typename CallbackParamTraits<X7>::ForwardType); 2372 2373 typedef R(UnboundRunType)(X6, X7); 2374 2375 static R Run(BindStateBase* base, 2376 typename CallbackParamTraits<X6>::ForwardType x6, 2377 typename CallbackParamTraits<X7>::ForwardType x7) { 2378 StorageType* storage = static_cast<StorageType*>(base); 2379 2380 // Local references to make debugger stepping easier. If in a debugger, 2381 // you really want to warp ahead and step through the 2382 // InvokeHelper<>::MakeItSo() call below. 2383 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 2384 typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; 2385 typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; 2386 typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits; 2387 typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits; 2388 2389 typename Bound1UnwrapTraits::ForwardType x1 = 2390 Bound1UnwrapTraits::Unwrap(storage->p1_); 2391 typename Bound2UnwrapTraits::ForwardType x2 = 2392 Bound2UnwrapTraits::Unwrap(storage->p2_); 2393 typename Bound3UnwrapTraits::ForwardType x3 = 2394 Bound3UnwrapTraits::Unwrap(storage->p3_); 2395 typename Bound4UnwrapTraits::ForwardType x4 = 2396 Bound4UnwrapTraits::Unwrap(storage->p4_); 2397 typename Bound5UnwrapTraits::ForwardType x5 = 2398 Bound5UnwrapTraits::Unwrap(storage->p5_); 2399 return InvokeHelper<StorageType::IsWeakCall::value, R, 2400 typename StorageType::RunnableType, 2401 void(typename Bound1UnwrapTraits::ForwardType, 2402 typename Bound2UnwrapTraits::ForwardType, 2403 typename Bound3UnwrapTraits::ForwardType, 2404 typename Bound4UnwrapTraits::ForwardType, 2405 typename Bound5UnwrapTraits::ForwardType, 2406 typename CallbackParamTraits<X6>::ForwardType x6, 2407 typename CallbackParamTraits<X7>::ForwardType x7)> 2408 ::MakeItSo(storage->runnable_, CallbackForward(x1), 2409 CallbackForward(x2), CallbackForward(x3), 2410 CallbackForward(x4), CallbackForward(x5), 2411 CallbackForward(x6), CallbackForward(x7)); 2412 } 2413}; 2414 2415// Arity 7 -> 1. 2416template <typename StorageType, typename R,typename X1, typename X2, 2417 typename X3, typename X4, typename X5, typename X6, typename X7> 2418struct Invoker<6, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> { 2419 typedef R(RunType)(BindStateBase*, 2420 typename CallbackParamTraits<X7>::ForwardType); 2421 2422 typedef R(UnboundRunType)(X7); 2423 2424 static R Run(BindStateBase* base, 2425 typename CallbackParamTraits<X7>::ForwardType x7) { 2426 StorageType* storage = static_cast<StorageType*>(base); 2427 2428 // Local references to make debugger stepping easier. If in a debugger, 2429 // you really want to warp ahead and step through the 2430 // InvokeHelper<>::MakeItSo() call below. 2431 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 2432 typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; 2433 typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; 2434 typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits; 2435 typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits; 2436 typedef typename StorageType::Bound6UnwrapTraits Bound6UnwrapTraits; 2437 2438 typename Bound1UnwrapTraits::ForwardType x1 = 2439 Bound1UnwrapTraits::Unwrap(storage->p1_); 2440 typename Bound2UnwrapTraits::ForwardType x2 = 2441 Bound2UnwrapTraits::Unwrap(storage->p2_); 2442 typename Bound3UnwrapTraits::ForwardType x3 = 2443 Bound3UnwrapTraits::Unwrap(storage->p3_); 2444 typename Bound4UnwrapTraits::ForwardType x4 = 2445 Bound4UnwrapTraits::Unwrap(storage->p4_); 2446 typename Bound5UnwrapTraits::ForwardType x5 = 2447 Bound5UnwrapTraits::Unwrap(storage->p5_); 2448 typename Bound6UnwrapTraits::ForwardType x6 = 2449 Bound6UnwrapTraits::Unwrap(storage->p6_); 2450 return InvokeHelper<StorageType::IsWeakCall::value, R, 2451 typename StorageType::RunnableType, 2452 void(typename Bound1UnwrapTraits::ForwardType, 2453 typename Bound2UnwrapTraits::ForwardType, 2454 typename Bound3UnwrapTraits::ForwardType, 2455 typename Bound4UnwrapTraits::ForwardType, 2456 typename Bound5UnwrapTraits::ForwardType, 2457 typename Bound6UnwrapTraits::ForwardType, 2458 typename CallbackParamTraits<X7>::ForwardType x7)> 2459 ::MakeItSo(storage->runnable_, CallbackForward(x1), 2460 CallbackForward(x2), CallbackForward(x3), 2461 CallbackForward(x4), CallbackForward(x5), 2462 CallbackForward(x6), CallbackForward(x7)); 2463 } 2464}; 2465 2466// Arity 7 -> 0. 2467template <typename StorageType, typename R,typename X1, typename X2, 2468 typename X3, typename X4, typename X5, typename X6, typename X7> 2469struct Invoker<7, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> { 2470 typedef R(RunType)(BindStateBase*); 2471 2472 typedef R(UnboundRunType)(); 2473 2474 static R Run(BindStateBase* base) { 2475 StorageType* storage = static_cast<StorageType*>(base); 2476 2477 // Local references to make debugger stepping easier. If in a debugger, 2478 // you really want to warp ahead and step through the 2479 // InvokeHelper<>::MakeItSo() call below. 2480 typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; 2481 typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; 2482 typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; 2483 typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits; 2484 typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits; 2485 typedef typename StorageType::Bound6UnwrapTraits Bound6UnwrapTraits; 2486 typedef typename StorageType::Bound7UnwrapTraits Bound7UnwrapTraits; 2487 2488 typename Bound1UnwrapTraits::ForwardType x1 = 2489 Bound1UnwrapTraits::Unwrap(storage->p1_); 2490 typename Bound2UnwrapTraits::ForwardType x2 = 2491 Bound2UnwrapTraits::Unwrap(storage->p2_); 2492 typename Bound3UnwrapTraits::ForwardType x3 = 2493 Bound3UnwrapTraits::Unwrap(storage->p3_); 2494 typename Bound4UnwrapTraits::ForwardType x4 = 2495 Bound4UnwrapTraits::Unwrap(storage->p4_); 2496 typename Bound5UnwrapTraits::ForwardType x5 = 2497 Bound5UnwrapTraits::Unwrap(storage->p5_); 2498 typename Bound6UnwrapTraits::ForwardType x6 = 2499 Bound6UnwrapTraits::Unwrap(storage->p6_); 2500 typename Bound7UnwrapTraits::ForwardType x7 = 2501 Bound7UnwrapTraits::Unwrap(storage->p7_); 2502 return InvokeHelper<StorageType::IsWeakCall::value, R, 2503 typename StorageType::RunnableType, 2504 void(typename Bound1UnwrapTraits::ForwardType, 2505 typename Bound2UnwrapTraits::ForwardType, 2506 typename Bound3UnwrapTraits::ForwardType, 2507 typename Bound4UnwrapTraits::ForwardType, 2508 typename Bound5UnwrapTraits::ForwardType, 2509 typename Bound6UnwrapTraits::ForwardType, 2510 typename Bound7UnwrapTraits::ForwardType)> 2511 ::MakeItSo(storage->runnable_, CallbackForward(x1), 2512 CallbackForward(x2), CallbackForward(x3), 2513 CallbackForward(x4), CallbackForward(x5), 2514 CallbackForward(x6), CallbackForward(x7)); 2515 } 2516}; 2517 2518 2519// BindState<> 2520// 2521// This stores all the state passed into Bind() and is also where most 2522// of the template resolution magic occurs. 2523// 2524// Runnable is the functor we are binding arguments to. 2525// RunType is type of the Run() function that the Invoker<> should use. 2526// Normally, this is the same as the RunType of the Runnable, but it can 2527// be different if an adapter like IgnoreResult() has been used. 2528// 2529// BoundArgsType contains the storage type for all the bound arguments by 2530// (ab)using a function type. 2531template <typename Runnable, typename RunType, typename BoundArgsType> 2532struct BindState; 2533 2534template <typename Runnable, typename RunType> 2535struct BindState<Runnable, RunType, void()> : public BindStateBase { 2536 typedef Runnable RunnableType; 2537 typedef false_type IsWeakCall; 2538 typedef Invoker<0, BindState, RunType> InvokerType; 2539 typedef typename InvokerType::UnboundRunType UnboundRunType; 2540 explicit BindState(const Runnable& runnable) 2541 : runnable_(runnable) { 2542 } 2543 2544 virtual ~BindState() { } 2545 2546 RunnableType runnable_; 2547}; 2548 2549template <typename Runnable, typename RunType, typename P1> 2550struct BindState<Runnable, RunType, void(P1)> : public BindStateBase { 2551 typedef Runnable RunnableType; 2552 typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall; 2553 typedef Invoker<1, BindState, RunType> InvokerType; 2554 typedef typename InvokerType::UnboundRunType UnboundRunType; 2555 2556 // Convenience typedefs for bound argument types. 2557 typedef UnwrapTraits<P1> Bound1UnwrapTraits; 2558 2559 BindState(const Runnable& runnable, const P1& p1) 2560 : runnable_(runnable), 2561 p1_(p1) { 2562 MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_); 2563 } 2564 2565 virtual ~BindState() { MaybeRefcount<HasIsMethodTag<Runnable>::value, 2566 P1>::Release(p1_); } 2567 2568 RunnableType runnable_; 2569 P1 p1_; 2570}; 2571 2572template <typename Runnable, typename RunType, typename P1, typename P2> 2573struct BindState<Runnable, RunType, void(P1, P2)> : public BindStateBase { 2574 typedef Runnable RunnableType; 2575 typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall; 2576 typedef Invoker<2, BindState, RunType> InvokerType; 2577 typedef typename InvokerType::UnboundRunType UnboundRunType; 2578 2579 // Convenience typedefs for bound argument types. 2580 typedef UnwrapTraits<P1> Bound1UnwrapTraits; 2581 typedef UnwrapTraits<P2> Bound2UnwrapTraits; 2582 2583 BindState(const Runnable& runnable, const P1& p1, const P2& p2) 2584 : runnable_(runnable), 2585 p1_(p1), 2586 p2_(p2) { 2587 MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_); 2588 } 2589 2590 virtual ~BindState() { MaybeRefcount<HasIsMethodTag<Runnable>::value, 2591 P1>::Release(p1_); } 2592 2593 RunnableType runnable_; 2594 P1 p1_; 2595 P2 p2_; 2596}; 2597 2598template <typename Runnable, typename RunType, typename P1, typename P2, 2599 typename P3> 2600struct BindState<Runnable, RunType, void(P1, P2, P3)> : public BindStateBase { 2601 typedef Runnable RunnableType; 2602 typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall; 2603 typedef Invoker<3, BindState, RunType> InvokerType; 2604 typedef typename InvokerType::UnboundRunType UnboundRunType; 2605 2606 // Convenience typedefs for bound argument types. 2607 typedef UnwrapTraits<P1> Bound1UnwrapTraits; 2608 typedef UnwrapTraits<P2> Bound2UnwrapTraits; 2609 typedef UnwrapTraits<P3> Bound3UnwrapTraits; 2610 2611 BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3) 2612 : runnable_(runnable), 2613 p1_(p1), 2614 p2_(p2), 2615 p3_(p3) { 2616 MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_); 2617 } 2618 2619 virtual ~BindState() { MaybeRefcount<HasIsMethodTag<Runnable>::value, 2620 P1>::Release(p1_); } 2621 2622 RunnableType runnable_; 2623 P1 p1_; 2624 P2 p2_; 2625 P3 p3_; 2626}; 2627 2628template <typename Runnable, typename RunType, typename P1, typename P2, 2629 typename P3, typename P4> 2630struct BindState<Runnable, RunType, void(P1, P2, P3, 2631 P4)> : public BindStateBase { 2632 typedef Runnable RunnableType; 2633 typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall; 2634 typedef Invoker<4, BindState, RunType> InvokerType; 2635 typedef typename InvokerType::UnboundRunType UnboundRunType; 2636 2637 // Convenience typedefs for bound argument types. 2638 typedef UnwrapTraits<P1> Bound1UnwrapTraits; 2639 typedef UnwrapTraits<P2> Bound2UnwrapTraits; 2640 typedef UnwrapTraits<P3> Bound3UnwrapTraits; 2641 typedef UnwrapTraits<P4> Bound4UnwrapTraits; 2642 2643 BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3, 2644 const P4& p4) 2645 : runnable_(runnable), 2646 p1_(p1), 2647 p2_(p2), 2648 p3_(p3), 2649 p4_(p4) { 2650 MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_); 2651 } 2652 2653 virtual ~BindState() { MaybeRefcount<HasIsMethodTag<Runnable>::value, 2654 P1>::Release(p1_); } 2655 2656 RunnableType runnable_; 2657 P1 p1_; 2658 P2 p2_; 2659 P3 p3_; 2660 P4 p4_; 2661}; 2662 2663template <typename Runnable, typename RunType, typename P1, typename P2, 2664 typename P3, typename P4, typename P5> 2665struct BindState<Runnable, RunType, void(P1, P2, P3, P4, 2666 P5)> : public BindStateBase { 2667 typedef Runnable RunnableType; 2668 typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall; 2669 typedef Invoker<5, BindState, RunType> InvokerType; 2670 typedef typename InvokerType::UnboundRunType UnboundRunType; 2671 2672 // Convenience typedefs for bound argument types. 2673 typedef UnwrapTraits<P1> Bound1UnwrapTraits; 2674 typedef UnwrapTraits<P2> Bound2UnwrapTraits; 2675 typedef UnwrapTraits<P3> Bound3UnwrapTraits; 2676 typedef UnwrapTraits<P4> Bound4UnwrapTraits; 2677 typedef UnwrapTraits<P5> Bound5UnwrapTraits; 2678 2679 BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3, 2680 const P4& p4, const P5& p5) 2681 : runnable_(runnable), 2682 p1_(p1), 2683 p2_(p2), 2684 p3_(p3), 2685 p4_(p4), 2686 p5_(p5) { 2687 MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_); 2688 } 2689 2690 virtual ~BindState() { MaybeRefcount<HasIsMethodTag<Runnable>::value, 2691 P1>::Release(p1_); } 2692 2693 RunnableType runnable_; 2694 P1 p1_; 2695 P2 p2_; 2696 P3 p3_; 2697 P4 p4_; 2698 P5 p5_; 2699}; 2700 2701template <typename Runnable, typename RunType, typename P1, typename P2, 2702 typename P3, typename P4, typename P5, typename P6> 2703struct BindState<Runnable, RunType, void(P1, P2, P3, P4, P5, 2704 P6)> : public BindStateBase { 2705 typedef Runnable RunnableType; 2706 typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall; 2707 typedef Invoker<6, BindState, RunType> InvokerType; 2708 typedef typename InvokerType::UnboundRunType UnboundRunType; 2709 2710 // Convenience typedefs for bound argument types. 2711 typedef UnwrapTraits<P1> Bound1UnwrapTraits; 2712 typedef UnwrapTraits<P2> Bound2UnwrapTraits; 2713 typedef UnwrapTraits<P3> Bound3UnwrapTraits; 2714 typedef UnwrapTraits<P4> Bound4UnwrapTraits; 2715 typedef UnwrapTraits<P5> Bound5UnwrapTraits; 2716 typedef UnwrapTraits<P6> Bound6UnwrapTraits; 2717 2718 BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3, 2719 const P4& p4, const P5& p5, const P6& p6) 2720 : runnable_(runnable), 2721 p1_(p1), 2722 p2_(p2), 2723 p3_(p3), 2724 p4_(p4), 2725 p5_(p5), 2726 p6_(p6) { 2727 MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_); 2728 } 2729 2730 virtual ~BindState() { MaybeRefcount<HasIsMethodTag<Runnable>::value, 2731 P1>::Release(p1_); } 2732 2733 RunnableType runnable_; 2734 P1 p1_; 2735 P2 p2_; 2736 P3 p3_; 2737 P4 p4_; 2738 P5 p5_; 2739 P6 p6_; 2740}; 2741 2742template <typename Runnable, typename RunType, typename P1, typename P2, 2743 typename P3, typename P4, typename P5, typename P6, typename P7> 2744struct BindState<Runnable, RunType, void(P1, P2, P3, P4, P5, P6, 2745 P7)> : public BindStateBase { 2746 typedef Runnable RunnableType; 2747 typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall; 2748 typedef Invoker<7, BindState, RunType> InvokerType; 2749 typedef typename InvokerType::UnboundRunType UnboundRunType; 2750 2751 // Convenience typedefs for bound argument types. 2752 typedef UnwrapTraits<P1> Bound1UnwrapTraits; 2753 typedef UnwrapTraits<P2> Bound2UnwrapTraits; 2754 typedef UnwrapTraits<P3> Bound3UnwrapTraits; 2755 typedef UnwrapTraits<P4> Bound4UnwrapTraits; 2756 typedef UnwrapTraits<P5> Bound5UnwrapTraits; 2757 typedef UnwrapTraits<P6> Bound6UnwrapTraits; 2758 typedef UnwrapTraits<P7> Bound7UnwrapTraits; 2759 2760 BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3, 2761 const P4& p4, const P5& p5, const P6& p6, const P7& p7) 2762 : runnable_(runnable), 2763 p1_(p1), 2764 p2_(p2), 2765 p3_(p3), 2766 p4_(p4), 2767 p5_(p5), 2768 p6_(p6), 2769 p7_(p7) { 2770 MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_); 2771 } 2772 2773 virtual ~BindState() { MaybeRefcount<HasIsMethodTag<Runnable>::value, 2774 P1>::Release(p1_); } 2775 2776 RunnableType runnable_; 2777 P1 p1_; 2778 P2 p2_; 2779 P3 p3_; 2780 P4 p4_; 2781 P5 p5_; 2782 P6 p6_; 2783 P7 p7_; 2784}; 2785 2786} // namespace internal 2787} // namespace base 2788 2789#endif // BASE_BIND_INTERNAL_H_ 2790