Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(203)

Side by Side Diff: base/callback.h

Issue 610423003: [Base] Use variadic template in base/callback.h (wave 1) (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: rebase Created 6 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « no previous file | base/callback.h.pump » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // This file was GENERATED by command:
2 // pump.py callback.h.pump
3 // DO NOT EDIT BY HAND!!!
4
5
6 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
7 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
8 // found in the LICENSE file. 3 // found in the LICENSE file.
9 4
10 #ifndef BASE_CALLBACK_H_ 5 #ifndef BASE_CALLBACK_H_
11 #define BASE_CALLBACK_H_ 6 #define BASE_CALLBACK_H_
12 7
13 #include "base/callback_forward.h" 8 #include "base/callback_forward.h"
14 #include "base/callback_internal.h" 9 #include "base/callback_internal.h"
15 #include "base/template_util.h" 10 #include "base/template_util.h"
(...skipping 344 matching lines...) Expand 10 before | Expand all | Expand 10 after
360 // If you are thinking of forward declaring Callback in your own header file, 355 // If you are thinking of forward declaring Callback in your own header file,
361 // please include "base/callback_forward.h" instead. 356 // please include "base/callback_forward.h" instead.
362 template <typename Sig> 357 template <typename Sig>
363 class Callback; 358 class Callback;
364 359
365 namespace internal { 360 namespace internal {
366 template <typename Runnable, typename RunType, typename BoundArgsType> 361 template <typename Runnable, typename RunType, typename BoundArgsType>
367 struct BindState; 362 struct BindState;
368 } // namespace internal 363 } // namespace internal
369 364
370 template <typename R> 365 template <typename R, typename... Args>
371 class Callback<R(void)> : public internal::CallbackBase { 366 class Callback<R(Args...)> : public internal::CallbackBase {
372 public: 367 public:
373 typedef R(RunType)(); 368 typedef R(RunType)(Args...);
374 369
375 Callback() : CallbackBase(NULL) { } 370 Callback() : CallbackBase(NULL) { }
376 371
377 // Note that this constructor CANNOT be explicit, and that Bind() CANNOT 372 // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
378 // return the exact Callback<> type. See base/bind.h for details. 373 // return the exact Callback<> type. See base/bind.h for details.
379 template <typename Runnable, typename BindRunType, typename BoundArgsType> 374 template <typename Runnable, typename BindRunType, typename BoundArgsType>
380 Callback(internal::BindState<Runnable, BindRunType, 375 Callback(internal::BindState<Runnable, BindRunType,
381 BoundArgsType>* bind_state) 376 BoundArgsType>* bind_state)
382 : CallbackBase(bind_state) { 377 : CallbackBase(bind_state) {
383
384 // Force the assignment to a local variable of PolymorphicInvoke 378 // Force the assignment to a local variable of PolymorphicInvoke
385 // so the compiler will typecheck that the passed in Run() method has 379 // so the compiler will typecheck that the passed in Run() method has
386 // the correct type. 380 // the correct type.
387 PolymorphicInvoke invoke_func = 381 PolymorphicInvoke invoke_func =
388 &internal::BindState<Runnable, BindRunType, BoundArgsType> 382 &internal::BindState<Runnable, BindRunType, BoundArgsType>
389 ::InvokerType::Run; 383 ::InvokerType::Run;
390 polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func); 384 polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
391 } 385 }
392 386
393 bool Equals(const Callback& other) const { 387 bool Equals(const Callback& other) const {
394 return CallbackBase::Equals(other); 388 return CallbackBase::Equals(other);
395 } 389 }
396 390
397 R Run() const { 391 R Run(typename internal::CallbackParamTraits<Args>::ForwardType... args)
392 const {
398 PolymorphicInvoke f = 393 PolymorphicInvoke f =
399 reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_); 394 reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
400 395
401 return f(bind_state_.get()); 396 return f(bind_state_.get(), internal::CallbackForward(args)...);
402 }
403
404 private:
405 typedef R(*PolymorphicInvoke)(
406 internal::BindStateBase*);
407
408 };
409
410 template <typename R, typename A1>
411 class Callback<R(A1)> : public internal::CallbackBase {
412 public:
413 typedef R(RunType)(A1);
414
415 Callback() : CallbackBase(NULL) { }
416
417 // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
418 // return the exact Callback<> type. See base/bind.h for details.
419 template <typename Runnable, typename BindRunType, typename BoundArgsType>
420 Callback(internal::BindState<Runnable, BindRunType,
421 BoundArgsType>* bind_state)
422 : CallbackBase(bind_state) {
423
424 // Force the assignment to a local variable of PolymorphicInvoke
425 // so the compiler will typecheck that the passed in Run() method has
426 // the correct type.
427 PolymorphicInvoke invoke_func =
428 &internal::BindState<Runnable, BindRunType, BoundArgsType>
429 ::InvokerType::Run;
430 polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
431 }
432
433 bool Equals(const Callback& other) const {
434 return CallbackBase::Equals(other);
435 }
436
437 R Run(typename internal::CallbackParamTraits<A1>::ForwardType a1) const {
438 PolymorphicInvoke f =
439 reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
440
441 return f(bind_state_.get(), internal::CallbackForward(a1));
442 } 397 }
443 398
444 private: 399 private:
445 typedef R(*PolymorphicInvoke)( 400 typedef R(*PolymorphicInvoke)(
446 internal::BindStateBase*, 401 internal::BindStateBase*,
447 typename internal::CallbackParamTraits<A1>::ForwardType); 402 typename internal::CallbackParamTraits<Args>::ForwardType...);
448
449 }; 403 };
450 404
451 template <typename R, typename A1, typename A2>
452 class Callback<R(A1, A2)> : public internal::CallbackBase {
453 public:
454 typedef R(RunType)(A1, A2);
455
456 Callback() : CallbackBase(NULL) { }
457
458 // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
459 // return the exact Callback<> type. See base/bind.h for details.
460 template <typename Runnable, typename BindRunType, typename BoundArgsType>
461 Callback(internal::BindState<Runnable, BindRunType,
462 BoundArgsType>* bind_state)
463 : CallbackBase(bind_state) {
464
465 // Force the assignment to a local variable of PolymorphicInvoke
466 // so the compiler will typecheck that the passed in Run() method has
467 // the correct type.
468 PolymorphicInvoke invoke_func =
469 &internal::BindState<Runnable, BindRunType, BoundArgsType>
470 ::InvokerType::Run;
471 polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
472 }
473
474 bool Equals(const Callback& other) const {
475 return CallbackBase::Equals(other);
476 }
477
478 R Run(typename internal::CallbackParamTraits<A1>::ForwardType a1,
479 typename internal::CallbackParamTraits<A2>::ForwardType a2) const {
480 PolymorphicInvoke f =
481 reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
482
483 return f(bind_state_.get(), internal::CallbackForward(a1),
484 internal::CallbackForward(a2));
485 }
486
487 private:
488 typedef R(*PolymorphicInvoke)(
489 internal::BindStateBase*,
490 typename internal::CallbackParamTraits<A1>::ForwardType,
491 typename internal::CallbackParamTraits<A2>::ForwardType);
492
493 };
494
495 template <typename R, typename A1, typename A2, typename A3>
496 class Callback<R(A1, A2, A3)> : public internal::CallbackBase {
497 public:
498 typedef R(RunType)(A1, A2, A3);
499
500 Callback() : CallbackBase(NULL) { }
501
502 // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
503 // return the exact Callback<> type. See base/bind.h for details.
504 template <typename Runnable, typename BindRunType, typename BoundArgsType>
505 Callback(internal::BindState<Runnable, BindRunType,
506 BoundArgsType>* bind_state)
507 : CallbackBase(bind_state) {
508
509 // Force the assignment to a local variable of PolymorphicInvoke
510 // so the compiler will typecheck that the passed in Run() method has
511 // the correct type.
512 PolymorphicInvoke invoke_func =
513 &internal::BindState<Runnable, BindRunType, BoundArgsType>
514 ::InvokerType::Run;
515 polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
516 }
517
518 bool Equals(const Callback& other) const {
519 return CallbackBase::Equals(other);
520 }
521
522 R Run(typename internal::CallbackParamTraits<A1>::ForwardType a1,
523 typename internal::CallbackParamTraits<A2>::ForwardType a2,
524 typename internal::CallbackParamTraits<A3>::ForwardType a3) const {
525 PolymorphicInvoke f =
526 reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
527
528 return f(bind_state_.get(), internal::CallbackForward(a1),
529 internal::CallbackForward(a2),
530 internal::CallbackForward(a3));
531 }
532
533 private:
534 typedef R(*PolymorphicInvoke)(
535 internal::BindStateBase*,
536 typename internal::CallbackParamTraits<A1>::ForwardType,
537 typename internal::CallbackParamTraits<A2>::ForwardType,
538 typename internal::CallbackParamTraits<A3>::ForwardType);
539
540 };
541
542 template <typename R, typename A1, typename A2, typename A3, typename A4>
543 class Callback<R(A1, A2, A3, A4)> : public internal::CallbackBase {
544 public:
545 typedef R(RunType)(A1, A2, A3, A4);
546
547 Callback() : CallbackBase(NULL) { }
548
549 // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
550 // return the exact Callback<> type. See base/bind.h for details.
551 template <typename Runnable, typename BindRunType, typename BoundArgsType>
552 Callback(internal::BindState<Runnable, BindRunType,
553 BoundArgsType>* bind_state)
554 : CallbackBase(bind_state) {
555
556 // Force the assignment to a local variable of PolymorphicInvoke
557 // so the compiler will typecheck that the passed in Run() method has
558 // the correct type.
559 PolymorphicInvoke invoke_func =
560 &internal::BindState<Runnable, BindRunType, BoundArgsType>
561 ::InvokerType::Run;
562 polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
563 }
564
565 bool Equals(const Callback& other) const {
566 return CallbackBase::Equals(other);
567 }
568
569 R Run(typename internal::CallbackParamTraits<A1>::ForwardType a1,
570 typename internal::CallbackParamTraits<A2>::ForwardType a2,
571 typename internal::CallbackParamTraits<A3>::ForwardType a3,
572 typename internal::CallbackParamTraits<A4>::ForwardType a4) const {
573 PolymorphicInvoke f =
574 reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
575
576 return f(bind_state_.get(), internal::CallbackForward(a1),
577 internal::CallbackForward(a2),
578 internal::CallbackForward(a3),
579 internal::CallbackForward(a4));
580 }
581
582 private:
583 typedef R(*PolymorphicInvoke)(
584 internal::BindStateBase*,
585 typename internal::CallbackParamTraits<A1>::ForwardType,
586 typename internal::CallbackParamTraits<A2>::ForwardType,
587 typename internal::CallbackParamTraits<A3>::ForwardType,
588 typename internal::CallbackParamTraits<A4>::ForwardType);
589
590 };
591
592 template <typename R, typename A1, typename A2, typename A3, typename A4,
593 typename A5>
594 class Callback<R(A1, A2, A3, A4, A5)> : public internal::CallbackBase {
595 public:
596 typedef R(RunType)(A1, A2, A3, A4, A5);
597
598 Callback() : CallbackBase(NULL) { }
599
600 // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
601 // return the exact Callback<> type. See base/bind.h for details.
602 template <typename Runnable, typename BindRunType, typename BoundArgsType>
603 Callback(internal::BindState<Runnable, BindRunType,
604 BoundArgsType>* bind_state)
605 : CallbackBase(bind_state) {
606
607 // Force the assignment to a local variable of PolymorphicInvoke
608 // so the compiler will typecheck that the passed in Run() method has
609 // the correct type.
610 PolymorphicInvoke invoke_func =
611 &internal::BindState<Runnable, BindRunType, BoundArgsType>
612 ::InvokerType::Run;
613 polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
614 }
615
616 bool Equals(const Callback& other) const {
617 return CallbackBase::Equals(other);
618 }
619
620 R Run(typename internal::CallbackParamTraits<A1>::ForwardType a1,
621 typename internal::CallbackParamTraits<A2>::ForwardType a2,
622 typename internal::CallbackParamTraits<A3>::ForwardType a3,
623 typename internal::CallbackParamTraits<A4>::ForwardType a4,
624 typename internal::CallbackParamTraits<A5>::ForwardType a5) const {
625 PolymorphicInvoke f =
626 reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
627
628 return f(bind_state_.get(), internal::CallbackForward(a1),
629 internal::CallbackForward(a2),
630 internal::CallbackForward(a3),
631 internal::CallbackForward(a4),
632 internal::CallbackForward(a5));
633 }
634
635 private:
636 typedef R(*PolymorphicInvoke)(
637 internal::BindStateBase*,
638 typename internal::CallbackParamTraits<A1>::ForwardType,
639 typename internal::CallbackParamTraits<A2>::ForwardType,
640 typename internal::CallbackParamTraits<A3>::ForwardType,
641 typename internal::CallbackParamTraits<A4>::ForwardType,
642 typename internal::CallbackParamTraits<A5>::ForwardType);
643
644 };
645
646 template <typename R, typename A1, typename A2, typename A3, typename A4,
647 typename A5, typename A6>
648 class Callback<R(A1, A2, A3, A4, A5, A6)> : public internal::CallbackBase {
649 public:
650 typedef R(RunType)(A1, A2, A3, A4, A5, A6);
651
652 Callback() : CallbackBase(NULL) { }
653
654 // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
655 // return the exact Callback<> type. See base/bind.h for details.
656 template <typename Runnable, typename BindRunType, typename BoundArgsType>
657 Callback(internal::BindState<Runnable, BindRunType,
658 BoundArgsType>* bind_state)
659 : CallbackBase(bind_state) {
660
661 // Force the assignment to a local variable of PolymorphicInvoke
662 // so the compiler will typecheck that the passed in Run() method has
663 // the correct type.
664 PolymorphicInvoke invoke_func =
665 &internal::BindState<Runnable, BindRunType, BoundArgsType>
666 ::InvokerType::Run;
667 polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
668 }
669
670 bool Equals(const Callback& other) const {
671 return CallbackBase::Equals(other);
672 }
673
674 R Run(typename internal::CallbackParamTraits<A1>::ForwardType a1,
675 typename internal::CallbackParamTraits<A2>::ForwardType a2,
676 typename internal::CallbackParamTraits<A3>::ForwardType a3,
677 typename internal::CallbackParamTraits<A4>::ForwardType a4,
678 typename internal::CallbackParamTraits<A5>::ForwardType a5,
679 typename internal::CallbackParamTraits<A6>::ForwardType a6) const {
680 PolymorphicInvoke f =
681 reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
682
683 return f(bind_state_.get(), internal::CallbackForward(a1),
684 internal::CallbackForward(a2),
685 internal::CallbackForward(a3),
686 internal::CallbackForward(a4),
687 internal::CallbackForward(a5),
688 internal::CallbackForward(a6));
689 }
690
691 private:
692 typedef R(*PolymorphicInvoke)(
693 internal::BindStateBase*,
694 typename internal::CallbackParamTraits<A1>::ForwardType,
695 typename internal::CallbackParamTraits<A2>::ForwardType,
696 typename internal::CallbackParamTraits<A3>::ForwardType,
697 typename internal::CallbackParamTraits<A4>::ForwardType,
698 typename internal::CallbackParamTraits<A5>::ForwardType,
699 typename internal::CallbackParamTraits<A6>::ForwardType);
700
701 };
702
703 template <typename R, typename A1, typename A2, typename A3, typename A4,
704 typename A5, typename A6, typename A7>
705 class Callback<R(A1, A2, A3, A4, A5, A6, A7)> : public internal::CallbackBase {
706 public:
707 typedef R(RunType)(A1, A2, A3, A4, A5, A6, A7);
708
709 Callback() : CallbackBase(NULL) { }
710
711 // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
712 // return the exact Callback<> type. See base/bind.h for details.
713 template <typename Runnable, typename BindRunType, typename BoundArgsType>
714 Callback(internal::BindState<Runnable, BindRunType,
715 BoundArgsType>* bind_state)
716 : CallbackBase(bind_state) {
717
718 // Force the assignment to a local variable of PolymorphicInvoke
719 // so the compiler will typecheck that the passed in Run() method has
720 // the correct type.
721 PolymorphicInvoke invoke_func =
722 &internal::BindState<Runnable, BindRunType, BoundArgsType>
723 ::InvokerType::Run;
724 polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
725 }
726
727 bool Equals(const Callback& other) const {
728 return CallbackBase::Equals(other);
729 }
730
731 R Run(typename internal::CallbackParamTraits<A1>::ForwardType a1,
732 typename internal::CallbackParamTraits<A2>::ForwardType a2,
733 typename internal::CallbackParamTraits<A3>::ForwardType a3,
734 typename internal::CallbackParamTraits<A4>::ForwardType a4,
735 typename internal::CallbackParamTraits<A5>::ForwardType a5,
736 typename internal::CallbackParamTraits<A6>::ForwardType a6,
737 typename internal::CallbackParamTraits<A7>::ForwardType a7) const {
738 PolymorphicInvoke f =
739 reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
740
741 return f(bind_state_.get(), internal::CallbackForward(a1),
742 internal::CallbackForward(a2),
743 internal::CallbackForward(a3),
744 internal::CallbackForward(a4),
745 internal::CallbackForward(a5),
746 internal::CallbackForward(a6),
747 internal::CallbackForward(a7));
748 }
749
750 private:
751 typedef R(*PolymorphicInvoke)(
752 internal::BindStateBase*,
753 typename internal::CallbackParamTraits<A1>::ForwardType,
754 typename internal::CallbackParamTraits<A2>::ForwardType,
755 typename internal::CallbackParamTraits<A3>::ForwardType,
756 typename internal::CallbackParamTraits<A4>::ForwardType,
757 typename internal::CallbackParamTraits<A5>::ForwardType,
758 typename internal::CallbackParamTraits<A6>::ForwardType,
759 typename internal::CallbackParamTraits<A7>::ForwardType);
760
761 };
762
763
764 // Syntactic sugar to make Callback<void(void)> easier to declare since it 405 // Syntactic sugar to make Callback<void(void)> easier to declare since it
765 // will be used in a lot of APIs with delayed execution. 406 // will be used in a lot of APIs with delayed execution.
766 typedef Callback<void(void)> Closure; 407 typedef Callback<void(void)> Closure;
767 408
768 } // namespace base 409 } // namespace base
769 410
770 #endif // BASE_CALLBACK_H 411 #endif // BASE_CALLBACK_H_
OLDNEW
« no previous file with comments | « no previous file | base/callback.h.pump » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698