A Discrete-Event Network Simulator
API
make-event.h
Go to the documentation of this file.
1/*
2 * Copyright (c) 2008 INRIA
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation;
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 *
17 */
18
19#ifndef MAKE_EVENT_H
20#define MAKE_EVENT_H
21
28namespace ns3
29{
30
31class EventImpl;
32
54template <typename MEM, typename OBJ>
55EventImpl* MakeEvent(MEM mem_ptr, OBJ obj);
56
67template <typename MEM, typename OBJ, typename T1>
68EventImpl* MakeEvent(MEM mem_ptr, OBJ obj, T1 a1);
69
82template <typename MEM, typename OBJ, typename T1, typename T2>
83EventImpl* MakeEvent(MEM mem_ptr, OBJ obj, T1 a1, T2 a2);
84
99template <typename MEM, typename OBJ, typename T1, typename T2, typename T3>
100EventImpl* MakeEvent(MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3);
101
118template <typename MEM, typename OBJ, typename T1, typename T2, typename T3, typename T4>
119EventImpl* MakeEvent(MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3, T4 a4);
120
139template <typename MEM,
140 typename OBJ,
141 typename T1,
142 typename T2,
143 typename T3,
144 typename T4,
145 typename T5>
146EventImpl* MakeEvent(MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);
147
168template <typename MEM,
169 typename OBJ,
170 typename T1,
171 typename T2,
172 typename T3,
173 typename T4,
174 typename T5,
175 typename T6>
176EventImpl* MakeEvent(MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6);
177
196EventImpl* MakeEvent(void (*f)());
197
206template <typename U1, typename T1>
207EventImpl* MakeEvent(void (*f)(U1), T1 a1);
208
220template <typename U1, typename U2, typename T1, typename T2>
221EventImpl* MakeEvent(void (*f)(U1, U2), T1 a1, T2 a2);
222
237template <typename U1, typename U2, typename U3, typename T1, typename T2, typename T3>
238EventImpl* MakeEvent(void (*f)(U1, U2, U3), T1 a1, T2 a2, T3 a3);
239
257template <typename U1,
258 typename U2,
259 typename U3,
260 typename U4,
261 typename T1,
262 typename T2,
263 typename T3,
264 typename T4>
265EventImpl* MakeEvent(void (*f)(U1, U2, U3, U4), T1 a1, T2 a2, T3 a3, T4 a4);
266
287template <typename U1,
288 typename U2,
289 typename U3,
290 typename U4,
291 typename U5,
292 typename T1,
293 typename T2,
294 typename T3,
295 typename T4,
296 typename T5>
297EventImpl* MakeEvent(void (*f)(U1, U2, U3, U4, U5), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);
298
322template <typename U1,
323 typename U2,
324 typename U3,
325 typename U4,
326 typename U5,
327 typename U6,
328 typename T1,
329 typename T2,
330 typename T3,
331 typename T4,
332 typename T5,
333 typename T6>
334EventImpl* MakeEvent(void (*f)(U1, U2, U3, U4, U5, U6), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6);
335
342template <typename T>
343EventImpl* MakeEvent(T function);
344
347} // namespace ns3
348
349/********************************************************************
350 * Implementation of the templates declared above.
351 ********************************************************************/
352
353#include "event-impl.h"
354#include "type-traits.h"
355
356namespace ns3
357{
358
369template <typename T>
370struct EventMemberImplObjTraits;
371
382template <typename T>
383struct EventMemberImplObjTraits<T*>
384{
389 static T& GetReference(T* p)
390 {
391 return *p;
392 }
393};
394
395template <typename MEM, typename OBJ>
396EventImpl*
397MakeEvent(MEM mem_ptr, OBJ obj)
398{
399 // zero argument version
400 class EventMemberImpl0 : public EventImpl
401 {
402 public:
403 EventMemberImpl0(OBJ obj, MEM function)
404 : m_obj(obj),
405 m_function(function)
406 {
407 }
408
409 ~EventMemberImpl0() override
410 {
411 }
412
413 private:
414 void Notify() override
415 {
416 (EventMemberImplObjTraits<OBJ>::GetReference(m_obj).*m_function)();
417 }
418
419 OBJ m_obj;
420 MEM m_function;
421 }* ev = new EventMemberImpl0(obj, mem_ptr);
422
423 return ev;
424}
425
426template <typename MEM, typename OBJ, typename T1>
427EventImpl*
428MakeEvent(MEM mem_ptr, OBJ obj, T1 a1)
429{
430 // one argument version
431 class EventMemberImpl1 : public EventImpl
432 {
433 public:
434 EventMemberImpl1(OBJ obj, MEM function, T1 a1)
435 : m_obj(obj),
436 m_function(function),
437 m_a1(a1)
438 {
439 }
440
441 protected:
442 ~EventMemberImpl1() override
443 {
444 }
445
446 private:
447 void Notify() override
448 {
449 (EventMemberImplObjTraits<OBJ>::GetReference(m_obj).*m_function)(m_a1);
450 }
451
452 OBJ m_obj;
453 MEM m_function;
454 typename TypeTraits<T1>::ReferencedType m_a1;
455 }* ev = new EventMemberImpl1(obj, mem_ptr, a1);
456
457 return ev;
458}
459
460template <typename MEM, typename OBJ, typename T1, typename T2>
461EventImpl*
462MakeEvent(MEM mem_ptr, OBJ obj, T1 a1, T2 a2)
463{
464 // two argument version
465 class EventMemberImpl2 : public EventImpl
466 {
467 public:
468 EventMemberImpl2(OBJ obj, MEM function, T1 a1, T2 a2)
469 : m_obj(obj),
470 m_function(function),
471 m_a1(a1),
472 m_a2(a2)
473 {
474 }
475
476 protected:
477 ~EventMemberImpl2() override
478 {
479 }
480
481 private:
482 void Notify() override
483 {
484 (EventMemberImplObjTraits<OBJ>::GetReference(m_obj).*m_function)(m_a1, m_a2);
485 }
486
487 OBJ m_obj;
488 MEM m_function;
489 typename TypeTraits<T1>::ReferencedType m_a1;
490 typename TypeTraits<T2>::ReferencedType m_a2;
491 }* ev = new EventMemberImpl2(obj, mem_ptr, a1, a2);
492
493 return ev;
494}
495
496template <typename MEM, typename OBJ, typename T1, typename T2, typename T3>
497EventImpl*
498MakeEvent(MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3)
499{
500 // three argument version
501 class EventMemberImpl3 : public EventImpl
502 {
503 public:
504 EventMemberImpl3(OBJ obj, MEM function, T1 a1, T2 a2, T3 a3)
505 : m_obj(obj),
506 m_function(function),
507 m_a1(a1),
508 m_a2(a2),
509 m_a3(a3)
510 {
511 }
512
513 protected:
514 ~EventMemberImpl3() override
515 {
516 }
517
518 private:
519 void Notify() override
520 {
521 (EventMemberImplObjTraits<OBJ>::GetReference(m_obj).*m_function)(m_a1, m_a2, m_a3);
522 }
523
524 OBJ m_obj;
525 MEM m_function;
526 typename TypeTraits<T1>::ReferencedType m_a1;
527 typename TypeTraits<T2>::ReferencedType m_a2;
528 typename TypeTraits<T3>::ReferencedType m_a3;
529 }* ev = new EventMemberImpl3(obj, mem_ptr, a1, a2, a3);
530
531 return ev;
532}
533
534template <typename MEM, typename OBJ, typename T1, typename T2, typename T3, typename T4>
535EventImpl*
536MakeEvent(MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3, T4 a4)
537{
538 // four argument version
539 class EventMemberImpl4 : public EventImpl
540 {
541 public:
542 EventMemberImpl4(OBJ obj, MEM function, T1 a1, T2 a2, T3 a3, T4 a4)
543 : m_obj(obj),
544 m_function(function),
545 m_a1(a1),
546 m_a2(a2),
547 m_a3(a3),
548 m_a4(a4)
549 {
550 }
551
552 protected:
553 ~EventMemberImpl4() override
554 {
555 }
556
557 private:
558 void Notify() override
559 {
560 (EventMemberImplObjTraits<OBJ>::GetReference(m_obj).*
561 m_function)(m_a1, m_a2, m_a3, m_a4);
562 }
563
564 OBJ m_obj;
565 MEM m_function;
566 typename TypeTraits<T1>::ReferencedType m_a1;
567 typename TypeTraits<T2>::ReferencedType m_a2;
568 typename TypeTraits<T3>::ReferencedType m_a3;
569 typename TypeTraits<T4>::ReferencedType m_a4;
570 }* ev = new EventMemberImpl4(obj, mem_ptr, a1, a2, a3, a4);
571
572 return ev;
573}
574
575template <typename MEM,
576 typename OBJ,
577 typename T1,
578 typename T2,
579 typename T3,
580 typename T4,
581 typename T5>
582EventImpl*
583MakeEvent(MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
584{
585 // five argument version
586 class EventMemberImpl5 : public EventImpl
587 {
588 public:
589 EventMemberImpl5(OBJ obj, MEM function, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
590 : m_obj(obj),
591 m_function(function),
592 m_a1(a1),
593 m_a2(a2),
594 m_a3(a3),
595 m_a4(a4),
596 m_a5(a5)
597 {
598 }
599
600 protected:
601 ~EventMemberImpl5() override
602 {
603 }
604
605 private:
606 void Notify() override
607 {
608 (EventMemberImplObjTraits<OBJ>::GetReference(m_obj).*
609 m_function)(m_a1, m_a2, m_a3, m_a4, m_a5);
610 }
611
612 OBJ m_obj;
613 MEM m_function;
614 typename TypeTraits<T1>::ReferencedType m_a1;
615 typename TypeTraits<T2>::ReferencedType m_a2;
616 typename TypeTraits<T3>::ReferencedType m_a3;
617 typename TypeTraits<T4>::ReferencedType m_a4;
618 typename TypeTraits<T5>::ReferencedType m_a5;
619 }* ev = new EventMemberImpl5(obj, mem_ptr, a1, a2, a3, a4, a5);
620
621 return ev;
622}
623
624template <typename MEM,
625 typename OBJ,
626 typename T1,
627 typename T2,
628 typename T3,
629 typename T4,
630 typename T5,
631 typename T6>
632EventImpl*
633MakeEvent(MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6)
634{
635 // six argument version
636 class EventMemberImpl6 : public EventImpl
637 {
638 public:
639 EventMemberImpl6(OBJ obj, MEM function, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6)
640 : m_obj(obj),
641 m_function(function),
642 m_a1(a1),
643 m_a2(a2),
644 m_a3(a3),
645 m_a4(a4),
646 m_a5(a5),
647 m_a6(a6)
648 {
649 }
650
651 protected:
652 ~EventMemberImpl6() override
653 {
654 }
655
656 private:
657 void Notify() override
658 {
659 (EventMemberImplObjTraits<OBJ>::GetReference(m_obj).*
660 m_function)(m_a1, m_a2, m_a3, m_a4, m_a5, m_a6);
661 }
662
663 OBJ m_obj;
664 MEM m_function;
665 typename TypeTraits<T1>::ReferencedType m_a1;
666 typename TypeTraits<T2>::ReferencedType m_a2;
667 typename TypeTraits<T3>::ReferencedType m_a3;
668 typename TypeTraits<T4>::ReferencedType m_a4;
669 typename TypeTraits<T5>::ReferencedType m_a5;
670 typename TypeTraits<T6>::ReferencedType m_a6;
671 }* ev = new EventMemberImpl6(obj, mem_ptr, a1, a2, a3, a4, a5, a6);
672
673 return ev;
674}
675
676template <typename U1, typename T1>
677EventImpl*
678MakeEvent(void (*f)(U1), T1 a1)
679{
680 // one arg version
681 class EventFunctionImpl1 : public EventImpl
682 {
683 public:
684 [[maybe_unused]] typedef void (*F)(U1);
685
686 EventFunctionImpl1(F function, T1 a1)
687 : m_function(function),
688 m_a1(a1)
689 {
690 }
691
692 protected:
693 ~EventFunctionImpl1() override
694 {
695 }
696
697 private:
698 void Notify() override
699 {
700 (*m_function)(m_a1);
701 }
702
703 F m_function;
704 typename TypeTraits<T1>::ReferencedType m_a1;
705 }* ev = new EventFunctionImpl1(f, a1);
706
707 return ev;
708}
709
710template <typename U1, typename U2, typename T1, typename T2>
711EventImpl*
712MakeEvent(void (*f)(U1, U2), T1 a1, T2 a2)
713{
714 // two arg version
715 class EventFunctionImpl2 : public EventImpl
716 {
717 public:
718 [[maybe_unused]] typedef void (*F)(U1, U2);
719
720 EventFunctionImpl2(F function, T1 a1, T2 a2)
721 : m_function(function),
722 m_a1(a1),
723 m_a2(a2)
724 {
725 }
726
727 protected:
728 ~EventFunctionImpl2() override
729 {
730 }
731
732 private:
733 void Notify() override
734 {
735 (*m_function)(m_a1, m_a2);
736 }
737
738 F m_function;
739 typename TypeTraits<T1>::ReferencedType m_a1;
740 typename TypeTraits<T2>::ReferencedType m_a2;
741 }* ev = new EventFunctionImpl2(f, a1, a2);
742
743 return ev;
744}
745
746template <typename U1, typename U2, typename U3, typename T1, typename T2, typename T3>
747EventImpl*
748MakeEvent(void (*f)(U1, U2, U3), T1 a1, T2 a2, T3 a3)
749{
750 // three arg version
751 class EventFunctionImpl3 : public EventImpl
752 {
753 public:
754 [[maybe_unused]] typedef void (*F)(U1, U2, U3);
755
756 EventFunctionImpl3(F function, T1 a1, T2 a2, T3 a3)
757 : m_function(function),
758 m_a1(a1),
759 m_a2(a2),
760 m_a3(a3)
761 {
762 }
763
764 protected:
765 ~EventFunctionImpl3() override
766 {
767 }
768
769 private:
770 void Notify() override
771 {
772 (*m_function)(m_a1, m_a2, m_a3);
773 }
774
775 F m_function;
776 typename TypeTraits<T1>::ReferencedType m_a1;
777 typename TypeTraits<T2>::ReferencedType m_a2;
778 typename TypeTraits<T3>::ReferencedType m_a3;
779 }* ev = new EventFunctionImpl3(f, a1, a2, a3);
780
781 return ev;
782}
783
784template <typename U1,
785 typename U2,
786 typename U3,
787 typename U4,
788 typename T1,
789 typename T2,
790 typename T3,
791 typename T4>
792EventImpl*
793MakeEvent(void (*f)(U1, U2, U3, U4), T1 a1, T2 a2, T3 a3, T4 a4)
794{
795 // four arg version
796 class EventFunctionImpl4 : public EventImpl
797 {
798 public:
799 [[maybe_unused]] typedef void (*F)(U1, U2, U3, U4);
800
801 EventFunctionImpl4(F function, T1 a1, T2 a2, T3 a3, T4 a4)
802 : m_function(function),
803 m_a1(a1),
804 m_a2(a2),
805 m_a3(a3),
806 m_a4(a4)
807 {
808 }
809
810 protected:
811 ~EventFunctionImpl4() override
812 {
813 }
814
815 private:
816 void Notify() override
817 {
818 (*m_function)(m_a1, m_a2, m_a3, m_a4);
819 }
820
821 F m_function;
822 typename TypeTraits<T1>::ReferencedType m_a1;
823 typename TypeTraits<T2>::ReferencedType m_a2;
824 typename TypeTraits<T3>::ReferencedType m_a3;
825 typename TypeTraits<T4>::ReferencedType m_a4;
826 }* ev = new EventFunctionImpl4(f, a1, a2, a3, a4);
827
828 return ev;
829}
830
831template <typename U1,
832 typename U2,
833 typename U3,
834 typename U4,
835 typename U5,
836 typename T1,
837 typename T2,
838 typename T3,
839 typename T4,
840 typename T5>
841EventImpl*
842MakeEvent(void (*f)(U1, U2, U3, U4, U5), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
843{
844 // five arg version
845 class EventFunctionImpl5 : public EventImpl
846 {
847 public:
848 [[maybe_unused]] typedef void (*F)(U1, U2, U3, U4, U5);
849
850 EventFunctionImpl5(F function, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
851 : m_function(function),
852 m_a1(a1),
853 m_a2(a2),
854 m_a3(a3),
855 m_a4(a4),
856 m_a5(a5)
857 {
858 }
859
860 protected:
861 ~EventFunctionImpl5() override
862 {
863 }
864
865 private:
866 void Notify() override
867 {
868 (*m_function)(m_a1, m_a2, m_a3, m_a4, m_a5);
869 }
870
871 F m_function;
872 typename TypeTraits<T1>::ReferencedType m_a1;
873 typename TypeTraits<T2>::ReferencedType m_a2;
874 typename TypeTraits<T3>::ReferencedType m_a3;
875 typename TypeTraits<T4>::ReferencedType m_a4;
876 typename TypeTraits<T5>::ReferencedType m_a5;
877 }* ev = new EventFunctionImpl5(f, a1, a2, a3, a4, a5);
878
879 return ev;
880}
881
882template <typename U1,
883 typename U2,
884 typename U3,
885 typename U4,
886 typename U5,
887 typename U6,
888 typename T1,
889 typename T2,
890 typename T3,
891 typename T4,
892 typename T5,
893 typename T6>
894EventImpl*
895MakeEvent(void (*f)(U1, U2, U3, U4, U5, U6), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6)
896{
897 // six arg version
898 class EventFunctionImpl6 : public EventImpl
899 {
900 public:
901 [[maybe_unused]] typedef void (*F)(U1, U2, U3, U4, U5, U6);
902
903 EventFunctionImpl6(F function, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6)
904 : m_function(function),
905 m_a1(a1),
906 m_a2(a2),
907 m_a3(a3),
908 m_a4(a4),
909 m_a5(a5),
910 m_a6(a6)
911 {
912 }
913
914 protected:
915 ~EventFunctionImpl6() override
916 {
917 }
918
919 private:
920 void Notify() override
921 {
922 (*m_function)(m_a1, m_a2, m_a3, m_a4, m_a5, m_a6);
923 }
924
925 F m_function;
926 typename TypeTraits<T1>::ReferencedType m_a1;
927 typename TypeTraits<T2>::ReferencedType m_a2;
928 typename TypeTraits<T3>::ReferencedType m_a3;
929 typename TypeTraits<T4>::ReferencedType m_a4;
930 typename TypeTraits<T5>::ReferencedType m_a5;
931 typename TypeTraits<T6>::ReferencedType m_a6;
932 }* ev = new EventFunctionImpl6(f, a1, a2, a3, a4, a5, a6);
933
934 return ev;
935}
936
937template <typename T>
938EventImpl*
939MakeEvent(T function)
940{
941 class EventImplFunctional : public EventImpl
942 {
943 public:
944 EventImplFunctional(T function)
945 : m_function(function)
946 {
947 }
948
949 ~EventImplFunctional() override
950 {
951 }
952
953 private:
954 void Notify() override
955 {
956 m_function();
957 }
958
959 T m_function;
960 }* ev = new EventImplFunctional(function);
961
962 return ev;
963}
964
965} // namespace ns3
966
967#endif /* MAKE_EVENT_H */
f
double f(double x, void *params)
Definition: 80211b.c:71
ns3::EventImpl
A simulation event.
Definition: event-impl.h:46
event-impl.h
ns3::EventImpl declarations.
ns3::MakeEvent
EventImpl * MakeEvent(void(*f)())
Make an EventImpl from a function pointer taking varying numbers of arguments.
Definition: make-event.cc:36
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::EventMemberImplObjTraits
Helper for the MakeEvent functions which take a class method.
Definition: make-event.h:370
ns3::TypeTraits::ReferencedType
ReferenceTraits< T >::ReferencedType ReferencedType
Referenced type.
Definition: type-traits.h:857
type-traits.h
ns3::TypeTraits introspection declaration and template implementation.