A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
timer-impl.h
Go to the documentation of this file.
1/*
2 * Copyright (c) 2007 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 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
18 */
19
20#ifndef TIMER_IMPL_H
21#define TIMER_IMPL_H
22
23#include "fatal-error.h"
24#include "int-to-type.h"
25#include "simulator.h"
26#include "type-traits.h"
27
35namespace ns3
36{
37
42class TimerImpl
43{
44 public:
46 virtual ~TimerImpl()
47 {
48 }
49
58 template <typename T1>
59 void SetArgs(T1 a1);
66 template <typename T1, typename T2>
67 void SetArgs(T1 a1, T2 a2);
76 template <typename T1, typename T2, typename T3>
77 void SetArgs(T1 a1, T2 a2, T3 a3);
88 template <typename T1, typename T2, typename T3, typename T4>
89 void SetArgs(T1 a1, T2 a2, T3 a3, T4 a4);
102 template <typename T1, typename T2, typename T3, typename T4, typename T5>
103 void SetArgs(T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);
118 template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
119 void SetArgs(T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6);
128 virtual EventId Schedule(const Time& delay) = 0;
130 virtual void Invoke() = 0;
131};
132
133} // namespace ns3
134
135/********************************************************************
136 * Implementation of TimerImpl implementation functions.
137 ********************************************************************/
138
139namespace ns3
140{
141
149template <typename T1>
150struct TimerImplOne : public TimerImpl
151{
157 virtual void SetArguments(T1 a1) = 0;
158};
159
161template <typename T1, typename T2>
162struct TimerImplTwo : public TimerImpl
163{
170 virtual void SetArguments(T1 a1, T2 a2) = 0;
171};
172
174template <typename T1, typename T2, typename T3>
175struct TimerImplThree : public TimerImpl
176{
184 virtual void SetArguments(T1 a1, T2 a2, T3 a3) = 0;
185};
186
188template <typename T1, typename T2, typename T3, typename T4>
189struct TimerImplFour : public TimerImpl
190{
199 virtual void SetArguments(T1 a1, T2 a2, T3 a3, T4 a4) = 0;
200};
201
203template <typename T1, typename T2, typename T3, typename T4, typename T5>
204struct TimerImplFive : public TimerImpl
205{
215 virtual void SetArguments(T1 a1, T2 a2, T3 a3, T4 a4, T5 a5) = 0;
216};
217
219template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
220struct TimerImplSix : public TimerImpl
221{
232 virtual void SetArguments(T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6) = 0;
233};
234
236template <typename T>
237struct TimerTraits
238{
240 typedef typename TypeTraits<typename TypeTraits<T>::ReferencedType>::NonConstType StoredType;
242 typedef const StoredType& ParameterType;
243};
244
252template <typename FN>
253TimerImpl*
254MakeTimerImpl(FN fn)
255{
256 NS_ASSERT(TypeTraits<FN>::IsFunctionPointer);
257 return MakeTimerImpl(IntToType<TypeTraits<FN>::FunctionPointerTraits::nArgs>(), fn);
258}
259
264template <typename FN>
265TimerImpl*
266MakeTimerImpl(IntToType<0>, FN fn)
267{
268 struct FnTimerImplZero : public TimerImpl
269 {
270 FnTimerImplZero(FN fn)
271 : m_fn(fn)
272 {
273 }
274
275 EventId Schedule(const Time& delay) override
276 {
277 return Simulator::Schedule(delay, m_fn);
278 }
279
280 void Invoke() override
281 {
282 m_fn();
283 }
284
285 FN m_fn;
286 }* function = new FnTimerImplZero(fn);
287
288 return function;
289}
290
295template <typename FN>
296TimerImpl*
297MakeTimerImpl(IntToType<1>, FN fn)
298{
299 typedef typename TypeTraits<FN>::FunctionPointerTraits::Arg1Type T1;
300 typedef typename TimerTraits<T1>::ParameterType T1Parameter;
301 typedef typename TimerTraits<T1>::StoredType T1Stored;
302
303 struct FnTimerImplOne : public TimerImplOne<T1Parameter>
304 {
305 FnTimerImplOne(FN fn)
306 : m_fn(fn)
307 {
308 }
309
310 void SetArguments(T1Parameter a1) override
311 {
312 m_a1 = a1;
313 }
314
315 EventId Schedule(const Time& delay) override
316 {
317 return Simulator::Schedule(delay, m_fn, m_a1);
318 }
319
320 void Invoke() override
321 {
322 m_fn(m_a1);
323 }
324
325 FN m_fn;
326 T1Stored m_a1;
327 }* function = new FnTimerImplOne(fn);
328
329 return function;
330}
331
336template <typename FN>
337TimerImpl*
338MakeTimerImpl(IntToType<2>, FN fn)
339{
340 typedef typename TypeTraits<FN>::FunctionPointerTraits::Arg1Type T1;
341 typedef typename TimerTraits<T1>::ParameterType T1Parameter;
342 typedef typename TimerTraits<T1>::StoredType T1Stored;
343 typedef typename TypeTraits<FN>::FunctionPointerTraits::Arg2Type T2;
344 typedef typename TimerTraits<T2>::ParameterType T2Parameter;
345 typedef typename TimerTraits<T2>::StoredType T2Stored;
346
347 struct FnTimerImplTwo : public TimerImplTwo<T1Parameter, T2Parameter>
348 {
349 FnTimerImplTwo(FN fn)
350 : m_fn(fn)
351 {
352 }
353
354 void SetArguments(T1Parameter a1, T2Parameter a2) override
355 {
356 m_a1 = a1;
357 m_a2 = a2;
358 }
359
360 EventId Schedule(const Time& delay) override
361 {
362 return Simulator::Schedule(delay, m_fn, m_a1, m_a2);
363 }
364
365 void Invoke() override
366 {
367 m_fn(m_a1, m_a2);
368 }
369
370 FN m_fn;
371 T1Stored m_a1;
372 T2Stored m_a2;
373 }* function = new FnTimerImplTwo(fn);
374
375 return function;
376}
377
382template <typename FN>
383TimerImpl*
384MakeTimerImpl(IntToType<3>, FN fn)
385{
386 typedef typename TypeTraits<FN>::FunctionPointerTraits::Arg1Type T1;
387 typedef typename TimerTraits<T1>::ParameterType T1Parameter;
388 typedef typename TimerTraits<T1>::StoredType T1Stored;
389 typedef typename TypeTraits<FN>::FunctionPointerTraits::Arg2Type T2;
390 typedef typename TimerTraits<T2>::ParameterType T2Parameter;
391 typedef typename TimerTraits<T2>::StoredType T2Stored;
392 typedef typename TypeTraits<FN>::FunctionPointerTraits::Arg3Type T3;
393 typedef typename TimerTraits<T3>::ParameterType T3Parameter;
394 typedef typename TimerTraits<T3>::StoredType T3Stored;
395
396 struct FnTimerImplThree : public TimerImplThree<T1Parameter, T2Parameter, T3Parameter>
397 {
398 FnTimerImplThree(FN fn)
399 : m_fn(fn)
400 {
401 }
402
403 void SetArguments(T1Parameter a1, T2Parameter a2, T3Parameter a3) override
404 {
405 m_a1 = a1;
406 m_a2 = a2;
407 m_a3 = a3;
408 }
409
410 EventId Schedule(const Time& delay) override
411 {
412 return Simulator::Schedule(delay, m_fn, m_a1, m_a2, m_a3);
413 }
414
415 void Invoke() override
416 {
417 m_fn(m_a1, m_a2, m_a3);
418 }
419
420 FN m_fn;
421 T1Stored m_a1;
422 T2Stored m_a2;
423 T3Stored m_a3;
424 }* function = new FnTimerImplThree(fn);
425
426 return function;
427}
428
433template <typename FN>
434TimerImpl*
435MakeTimerImpl(IntToType<4>, FN fn)
436{
437 typedef typename TypeTraits<FN>::FunctionPointerTraits::Arg1Type T1;
438 typedef typename TimerTraits<T1>::ParameterType T1Parameter;
439 typedef typename TimerTraits<T1>::StoredType T1Stored;
440 typedef typename TypeTraits<FN>::FunctionPointerTraits::Arg2Type T2;
441 typedef typename TimerTraits<T2>::ParameterType T2Parameter;
442 typedef typename TimerTraits<T2>::StoredType T2Stored;
443 typedef typename TypeTraits<FN>::FunctionPointerTraits::Arg3Type T3;
444 typedef typename TimerTraits<T3>::ParameterType T3Parameter;
445 typedef typename TimerTraits<T3>::StoredType T3Stored;
446 typedef typename TypeTraits<FN>::FunctionPointerTraits::Arg4Type T4;
447 typedef typename TimerTraits<T4>::ParameterType T4Parameter;
448 typedef typename TimerTraits<T4>::StoredType T4Stored;
449
450 struct FnTimerImplFour
451 : public TimerImplFour<T1Parameter, T2Parameter, T3Parameter, T4Parameter>
452 {
453 FnTimerImplFour(FN fn)
454 : m_fn(fn)
455 {
456 }
457
458 void SetArguments(T1Parameter a1, T2Parameter a2, T3Parameter a3, T4Parameter a4) override
459 {
460 m_a1 = a1;
461 m_a2 = a2;
462 m_a3 = a3;
463 m_a4 = a4;
464 }
465
466 EventId Schedule(const Time& delay) override
467 {
468 return Simulator::Schedule(delay, m_fn, m_a1, m_a2, m_a3, m_a4);
469 }
470
471 void Invoke() override
472 {
473 m_fn(m_a1, m_a2, m_a3, m_a4);
474 }
475
476 FN m_fn;
477 T1Stored m_a1;
478 T2Stored m_a2;
479 T3Stored m_a3;
480 T4Stored m_a4;
481 }* function = new FnTimerImplFour(fn);
482
483 return function;
484}
485
490template <typename FN>
491TimerImpl*
492MakeTimerImpl(IntToType<5>, FN fn)
493{
494 typedef typename TypeTraits<FN>::FunctionPointerTraits::Arg1Type T1;
495 typedef typename TimerTraits<T1>::ParameterType T1Parameter;
496 typedef typename TimerTraits<T1>::StoredType T1Stored;
497 typedef typename TypeTraits<FN>::FunctionPointerTraits::Arg2Type T2;
498 typedef typename TimerTraits<T2>::ParameterType T2Parameter;
499 typedef typename TimerTraits<T2>::StoredType T2Stored;
500 typedef typename TypeTraits<FN>::FunctionPointerTraits::Arg3Type T3;
501 typedef typename TimerTraits<T3>::ParameterType T3Parameter;
502 typedef typename TimerTraits<T3>::StoredType T3Stored;
503 typedef typename TypeTraits<FN>::FunctionPointerTraits::Arg4Type T4;
504 typedef typename TimerTraits<T4>::ParameterType T4Parameter;
505 typedef typename TimerTraits<T4>::StoredType T4Stored;
506 typedef typename TypeTraits<FN>::FunctionPointerTraits::Arg5Type T5;
507 typedef typename TimerTraits<T5>::ParameterType T5Parameter;
508 typedef typename TimerTraits<T5>::StoredType T5Stored;
509
510 struct FnTimerImplFive
511 : public TimerImplFive<T1Parameter, T2Parameter, T3Parameter, T4Parameter, T5Parameter>
512 {
513 FnTimerImplFive(FN fn)
514 : m_fn(fn)
515 {
516 }
517
518 void SetArguments(T1Parameter a1,
519 T2Parameter a2,
520 T3Parameter a3,
521 T4Parameter a4,
522 T5Parameter a5) override
523 {
524 m_a1 = a1;
525 m_a2 = a2;
526 m_a3 = a3;
527 m_a4 = a4;
528 m_a5 = a5;
529 }
530
531 EventId Schedule(const Time& delay) override
532 {
533 return Simulator::Schedule(delay, m_fn, m_a1, m_a2, m_a3, m_a4, m_a5);
534 }
535
536 void Invoke() override
537 {
538 m_fn(m_a1, m_a2, m_a3, m_a4, m_a5);
539 }
540
541 FN m_fn;
542 T1Stored m_a1;
543 T2Stored m_a2;
544 T3Stored m_a3;
545 T4Stored m_a4;
546 T5Stored m_a5;
547 }* function = new FnTimerImplFive(fn);
548
549 return function;
550}
551
556template <typename FN>
557TimerImpl*
558MakeTimerImpl(IntToType<6>, FN fn)
559{
560 typedef typename TypeTraits<FN>::FunctionPointerTraits::Arg1Type T1;
561 typedef typename TimerTraits<T1>::ParameterType T1Parameter;
562 typedef typename TimerTraits<T1>::StoredType T1Stored;
563 typedef typename TypeTraits<FN>::FunctionPointerTraits::Arg2Type T2;
564 typedef typename TimerTraits<T2>::ParameterType T2Parameter;
565 typedef typename TimerTraits<T2>::StoredType T2Stored;
566 typedef typename TypeTraits<FN>::FunctionPointerTraits::Arg3Type T3;
567 typedef typename TimerTraits<T3>::ParameterType T3Parameter;
568 typedef typename TimerTraits<T3>::StoredType T3Stored;
569 typedef typename TypeTraits<FN>::FunctionPointerTraits::Arg4Type T4;
570 typedef typename TimerTraits<T4>::ParameterType T4Parameter;
571 typedef typename TimerTraits<T4>::StoredType T4Stored;
572 typedef typename TypeTraits<FN>::FunctionPointerTraits::Arg5Type T5;
573 typedef typename TimerTraits<T5>::ParameterType T5Parameter;
574 typedef typename TimerTraits<T5>::StoredType T5Stored;
575 typedef typename TypeTraits<FN>::FunctionPointerTraits::Arg6Type T6;
576 typedef typename TimerTraits<T6>::ParameterType T6Parameter;
577 typedef typename TimerTraits<T6>::StoredType T6Stored;
578
579 struct FnTimerImplSix : public TimerImplSix<T1Parameter,
580 T2Parameter,
581 T3Parameter,
582 T4Parameter,
583 T5Parameter,
584 T6Parameter>
585 {
586 FnTimerImplSix(FN fn)
587 : m_fn(fn)
588 {
589 }
590
591 virtual void SetArguments(T1Parameter a1,
592 T2Parameter a2,
593 T3Parameter a3,
594 T4Parameter a4,
595 T5Parameter a5,
596 T6Parameter a6)
597 {
598 m_a1 = a1;
599 m_a2 = a2;
600 m_a3 = a3;
601 m_a4 = a4;
602 m_a5 = a5;
603 m_a6 = a6;
604 }
605
606 virtual EventId Schedule(const Time& delay)
607 {
608 return Simulator::Schedule(delay, m_fn, m_a1, m_a2, m_a3, m_a4, m_a5, m_a6);
609 }
610
611 virtual void Invoke()
612 {
613 m_fn(m_a1, m_a2, m_a3, m_a4, m_a5, m_a6);
614 }
615
616 FN m_fn;
617 T1Stored m_a1;
618 T2Stored m_a2;
619 T3Stored m_a3;
620 T4Stored m_a4;
621 T5Stored m_a5;
622 T6Stored m_a6;
623 }* function = new FnTimerImplSix(fn);
624
625 return function;
626}
627
637template <typename T>
638struct TimerImplMemberTraits;
639
649template <typename T>
650struct TimerImplMemberTraits<T*>
651{
658 static T& GetReference(T* p)
659 {
660 return *p;
661 }
662};
663
674template <typename MEM_PTR, typename OBJ_PTR>
675TimerImpl*
676MakeTimerImpl(MEM_PTR memPtr, OBJ_PTR objPtr)
677{
678 NS_ASSERT(TypeTraits<MEM_PTR>::IsPointerToMember);
679 return MakeTimerImpl(IntToType<TypeTraits<MEM_PTR>::PointerToMemberTraits::nArgs>(),
680 memPtr,
681 objPtr);
682}
683
688template <typename MEM_PTR, typename OBJ_PTR>
689TimerImpl*
690MakeTimerImpl(IntToType<0>, MEM_PTR memPtr, OBJ_PTR objPtr)
691{
692 struct MemFnTimerImplZero : public TimerImpl
693 {
694 MemFnTimerImplZero(MEM_PTR memPtr, OBJ_PTR objPtr)
695 : m_memPtr(memPtr),
696 m_objPtr(objPtr)
697 {
698 }
699
700 EventId Schedule(const Time& delay) override
701 {
702 return Simulator::Schedule(delay, m_memPtr, m_objPtr);
703 }
704
705 void Invoke() override
706 {
707 (TimerImplMemberTraits<OBJ_PTR>::GetReference(m_objPtr).*m_memPtr)();
708 }
709
710 MEM_PTR m_memPtr;
711 OBJ_PTR m_objPtr;
712 }* function = new MemFnTimerImplZero(memPtr, objPtr);
713
714 return function;
715}
716
721template <typename MEM_PTR, typename OBJ_PTR>
722TimerImpl*
723MakeTimerImpl(IntToType<1>, MEM_PTR memPtr, OBJ_PTR objPtr)
724{
725 typedef typename TypeTraits<MEM_PTR>::PointerToMemberTraits::Arg1Type T1;
726 typedef typename TimerTraits<T1>::ParameterType T1Parameter;
727 typedef typename TimerTraits<T1>::StoredType T1Stored;
728
729 struct MemFnTimerImplOne : public TimerImplOne<T1Parameter>
730 {
731 MemFnTimerImplOne(MEM_PTR memPtr, OBJ_PTR objPtr)
732 : m_memPtr(memPtr),
733 m_objPtr(objPtr)
734 {
735 }
736
737 void SetArguments(T1Parameter a1) override
738 {
739 m_a1 = a1;
740 }
741
742 EventId Schedule(const Time& delay) override
743 {
744 return Simulator::Schedule(delay, m_memPtr, m_objPtr, m_a1);
745 }
746
747 void Invoke() override
748 {
749 (TimerImplMemberTraits<OBJ_PTR>::GetReference(m_objPtr).*m_memPtr)(m_a1);
750 }
751
752 MEM_PTR m_memPtr;
753 OBJ_PTR m_objPtr;
754 T1Stored m_a1;
755 }* function = new MemFnTimerImplOne(memPtr, objPtr);
756
757 return function;
758}
759
764template <typename MEM_PTR, typename OBJ_PTR>
765TimerImpl*
766MakeTimerImpl(IntToType<2>, MEM_PTR memPtr, OBJ_PTR objPtr)
767{
768 typedef typename TypeTraits<MEM_PTR>::PointerToMemberTraits::Arg1Type T1;
769 typedef typename TimerTraits<T1>::ParameterType T1Parameter;
770 typedef typename TimerTraits<T1>::StoredType T1Stored;
771 typedef typename TypeTraits<MEM_PTR>::PointerToMemberTraits::Arg2Type T2;
772 typedef typename TimerTraits<T2>::ParameterType T2Parameter;
773 typedef typename TimerTraits<T2>::StoredType T2Stored;
774
775 struct MemFnTimerImplTwo : public TimerImplTwo<T1Parameter, T2Parameter>
776 {
777 MemFnTimerImplTwo(MEM_PTR memPtr, OBJ_PTR objPtr)
778 : m_memPtr(memPtr),
779 m_objPtr(objPtr)
780 {
781 }
782
783 void SetArguments(T1Parameter a1, T2Parameter a2) override
784 {
785 m_a1 = a1;
786 m_a2 = a2;
787 }
788
789 EventId Schedule(const Time& delay) override
790 {
791 return Simulator::Schedule(delay, m_memPtr, m_objPtr, m_a1, m_a2);
792 }
793
794 void Invoke() override
795 {
796 (TimerImplMemberTraits<OBJ_PTR>::GetReference(m_objPtr).*m_memPtr)(m_a1, m_a2);
797 }
798
799 MEM_PTR m_memPtr;
800 OBJ_PTR m_objPtr;
801 T1Stored m_a1;
802 T2Stored m_a2;
803 }* function = new MemFnTimerImplTwo(memPtr, objPtr);
804
805 return function;
806}
807
812template <typename MEM_PTR, typename OBJ_PTR>
813TimerImpl*
814MakeTimerImpl(IntToType<3>, MEM_PTR memPtr, OBJ_PTR objPtr)
815{
816 typedef typename TypeTraits<MEM_PTR>::PointerToMemberTraits::Arg1Type T1;
817 typedef typename TimerTraits<T1>::ParameterType T1Parameter;
818 typedef typename TimerTraits<T1>::StoredType T1Stored;
819 typedef typename TypeTraits<MEM_PTR>::PointerToMemberTraits::Arg2Type T2;
820 typedef typename TimerTraits<T2>::ParameterType T2Parameter;
821 typedef typename TimerTraits<T2>::StoredType T2Stored;
822 typedef typename TypeTraits<MEM_PTR>::PointerToMemberTraits::Arg3Type T3;
823 typedef typename TimerTraits<T3>::ParameterType T3Parameter;
824 typedef typename TimerTraits<T3>::StoredType T3Stored;
825
826 struct MemFnTimerImplThree : public TimerImplThree<T1Parameter, T2Parameter, T3Parameter>
827 {
828 MemFnTimerImplThree(MEM_PTR memPtr, OBJ_PTR objPtr)
829 : m_memPtr(memPtr),
830 m_objPtr(objPtr)
831 {
832 }
833
834 void SetArguments(T1Parameter a1, T2Parameter a2, T3Parameter a3) override
835 {
836 m_a1 = a1;
837 m_a2 = a2;
838 m_a3 = a3;
839 }
840
841 EventId Schedule(const Time& delay) override
842 {
843 return Simulator::Schedule(delay, m_memPtr, m_objPtr, m_a1, m_a2, m_a3);
844 }
845
846 void Invoke() override
847 {
848 (TimerImplMemberTraits<OBJ_PTR>::GetReference(m_objPtr).*m_memPtr)(m_a1, m_a2, m_a3);
849 }
850
851 MEM_PTR m_memPtr;
852 OBJ_PTR m_objPtr;
853 T1Stored m_a1;
854 T2Stored m_a2;
855 T3Stored m_a3;
856 }* function = new MemFnTimerImplThree(memPtr, objPtr);
857
858 return function;
859}
860
865template <typename MEM_PTR, typename OBJ_PTR>
866TimerImpl*
867MakeTimerImpl(IntToType<4>, MEM_PTR memPtr, OBJ_PTR objPtr)
868{
869 typedef typename TypeTraits<MEM_PTR>::PointerToMemberTraits::Arg1Type T1;
870 typedef typename TimerTraits<T1>::ParameterType T1Parameter;
871 typedef typename TimerTraits<T1>::StoredType T1Stored;
872 typedef typename TypeTraits<MEM_PTR>::PointerToMemberTraits::Arg2Type T2;
873 typedef typename TimerTraits<T2>::ParameterType T2Parameter;
874 typedef typename TimerTraits<T2>::StoredType T2Stored;
875 typedef typename TypeTraits<MEM_PTR>::PointerToMemberTraits::Arg3Type T3;
876 typedef typename TimerTraits<T3>::ParameterType T3Parameter;
877 typedef typename TimerTraits<T3>::StoredType T3Stored;
878 typedef typename TypeTraits<MEM_PTR>::PointerToMemberTraits::Arg4Type T4;
879 typedef typename TimerTraits<T4>::ParameterType T4Parameter;
880 typedef typename TimerTraits<T4>::StoredType T4Stored;
881
882 struct MemFnTimerImplFour
883 : public TimerImplFour<T1Parameter, T2Parameter, T3Parameter, T4Parameter>
884 {
885 MemFnTimerImplFour(MEM_PTR memPtr, OBJ_PTR objPtr)
886 : m_memPtr(memPtr),
887 m_objPtr(objPtr)
888 {
889 }
890
891 void SetArguments(T1Parameter a1, T2Parameter a2, T3Parameter a3, T4Parameter a4) override
892 {
893 m_a1 = a1;
894 m_a2 = a2;
895 m_a3 = a3;
896 m_a4 = a4;
897 }
898
899 EventId Schedule(const Time& delay) override
900 {
901 return Simulator::Schedule(delay, m_memPtr, m_objPtr, m_a1, m_a2, m_a3, m_a4);
902 }
903
904 void Invoke() override
905 {
906 (TimerImplMemberTraits<OBJ_PTR>::GetReference(m_objPtr).*
907 m_memPtr)(m_a1, m_a2, m_a3, m_a4);
908 }
909
910 MEM_PTR m_memPtr;
911 OBJ_PTR m_objPtr;
912 T1Stored m_a1;
913 T2Stored m_a2;
914 T3Stored m_a3;
915 T4Stored m_a4;
916 }* function = new MemFnTimerImplFour(memPtr, objPtr);
917
918 return function;
919}
920
925template <typename MEM_PTR, typename OBJ_PTR>
926TimerImpl*
927MakeTimerImpl(IntToType<5>, MEM_PTR memPtr, OBJ_PTR objPtr)
928{
929 typedef typename TypeTraits<MEM_PTR>::PointerToMemberTraits::Arg1Type T1;
930 typedef typename TimerTraits<T1>::ParameterType T1Parameter;
931 typedef typename TimerTraits<T1>::StoredType T1Stored;
932 typedef typename TypeTraits<MEM_PTR>::PointerToMemberTraits::Arg2Type T2;
933 typedef typename TimerTraits<T2>::ParameterType T2Parameter;
934 typedef typename TimerTraits<T2>::StoredType T2Stored;
935 typedef typename TypeTraits<MEM_PTR>::PointerToMemberTraits::Arg3Type T3;
936 typedef typename TimerTraits<T3>::ParameterType T3Parameter;
937 typedef typename TimerTraits<T3>::StoredType T3Stored;
938 typedef typename TypeTraits<MEM_PTR>::PointerToMemberTraits::Arg4Type T4;
939 typedef typename TimerTraits<T4>::ParameterType T4Parameter;
940 typedef typename TimerTraits<T4>::StoredType T4Stored;
941 typedef typename TypeTraits<MEM_PTR>::PointerToMemberTraits::Arg5Type T5;
942 typedef typename TimerTraits<T5>::ParameterType T5Parameter;
943 typedef typename TimerTraits<T5>::StoredType T5Stored;
944
945 struct MemFnTimerImplFive
946 : public TimerImplFive<T1Parameter, T2Parameter, T3Parameter, T4Parameter, T5Parameter>
947 {
948 MemFnTimerImplFive(MEM_PTR memPtr, OBJ_PTR objPtr)
949 : m_memPtr(memPtr),
950 m_objPtr(objPtr)
951 {
952 }
953
954 void SetArguments(T1Parameter a1,
955 T2Parameter a2,
956 T3Parameter a3,
957 T4Parameter a4,
958 T5Parameter a5) override
959 {
960 m_a1 = a1;
961 m_a2 = a2;
962 m_a3 = a3;
963 m_a4 = a4;
964 m_a5 = a5;
965 }
966
967 EventId Schedule(const Time& delay) override
968 {
969 return Simulator::Schedule(delay, m_memPtr, m_objPtr, m_a1, m_a2, m_a3, m_a4, m_a5);
970 }
971
972 void Invoke() override
973 {
974 (TimerImplMemberTraits<OBJ_PTR>::GetReference(m_objPtr).*
975 m_memPtr)(m_a1, m_a2, m_a3, m_a4, m_a5);
976 }
977
978 MEM_PTR m_memPtr;
979 OBJ_PTR m_objPtr;
980 T1Stored m_a1;
981 T2Stored m_a2;
982 T3Stored m_a3;
983 T4Stored m_a4;
984 T5Stored m_a5;
985 }* function = new MemFnTimerImplFive(memPtr, objPtr);
986
987 return function;
988}
989
994template <typename MEM_PTR, typename OBJ_PTR>
995TimerImpl*
996MakeTimerImpl(IntToType<6>, MEM_PTR memPtr, OBJ_PTR objPtr)
997{
998 typedef typename TypeTraits<MEM_PTR>::PointerToMemberTraits::Arg1Type T1;
999 typedef typename TimerTraits<T1>::ParameterType T1Parameter;
1000 typedef typename TimerTraits<T1>::StoredType T1Stored;
1001 typedef typename TypeTraits<MEM_PTR>::PointerToMemberTraits::Arg2Type T2;
1002 typedef typename TimerTraits<T2>::ParameterType T2Parameter;
1003 typedef typename TimerTraits<T2>::StoredType T2Stored;
1004 typedef typename TypeTraits<MEM_PTR>::PointerToMemberTraits::Arg3Type T3;
1005 typedef typename TimerTraits<T3>::ParameterType T3Parameter;
1006 typedef typename TimerTraits<T3>::StoredType T3Stored;
1007 typedef typename TypeTraits<MEM_PTR>::PointerToMemberTraits::Arg4Type T4;
1008 typedef typename TimerTraits<T4>::ParameterType T4Parameter;
1009 typedef typename TimerTraits<T4>::StoredType T4Stored;
1010 typedef typename TypeTraits<MEM_PTR>::PointerToMemberTraits::Arg5Type T5;
1011 typedef typename TimerTraits<T5>::ParameterType T5Parameter;
1012 typedef typename TimerTraits<T5>::StoredType T5Stored;
1013 typedef typename TypeTraits<MEM_PTR>::PointerToMemberTraits::Arg6Type T6;
1014 typedef typename TimerTraits<T6>::ParameterType T6Parameter;
1015 typedef typename TimerTraits<T6>::StoredType T6Stored;
1016
1017 struct MemFnTimerImplSix : public TimerImplSix<T1Parameter,
1018 T2Parameter,
1019 T3Parameter,
1020 T4Parameter,
1021 T5Parameter,
1022 T6Parameter>
1023 {
1024 MemFnTimerImplSix(MEM_PTR memPtr, OBJ_PTR objPtr)
1025 : m_memPtr(memPtr),
1026 m_objPtr(objPtr)
1027 {
1028 }
1029
1030 virtual void SetArguments(T1Parameter a1,
1031 T2Parameter a2,
1032 T3Parameter a3,
1033 T4Parameter a4,
1034 T5Parameter a5,
1035 T6Parameter a6)
1036 {
1037 m_a1 = a1;
1038 m_a2 = a2;
1039 m_a3 = a3;
1040 m_a4 = a4;
1041 m_a5 = a5;
1042 m_a6 = a6;
1043 }
1044
1045 virtual EventId Schedule(const Time& delay)
1046 {
1047 return Simulator::Schedule(delay,
1048 m_memPtr,
1049 m_objPtr,
1050 m_a1,
1051 m_a2,
1052 m_a3,
1053 m_a4,
1054 m_a5,
1055 m_a6);
1056 }
1057
1058 virtual void Invoke()
1059 {
1060 (TimerImplMemberTraits<OBJ_PTR>::GetReference(m_objPtr).*
1061 m_memPtr)(m_a1, m_a2, m_a3, m_a4, m_a5, m_a6);
1062 }
1063
1064 MEM_PTR m_memPtr;
1065 OBJ_PTR m_objPtr;
1066 T1Stored m_a1;
1067 T2Stored m_a2;
1068 T3Stored m_a3;
1069 T4Stored m_a4;
1070 T5Stored m_a5;
1071 T6Stored m_a6;
1072 }* function = new MemFnTimerImplSix(memPtr, objPtr);
1073
1074 return function;
1075}
1076 // \ingroup timer
1078
1079/********************************************************************
1080 * Implementation of TimerImpl itself.
1081 ********************************************************************/
1082
1083template <typename T1>
1084void
1085TimerImpl::SetArgs(T1 a1)
1086{
1087 typedef TimerImplOne<typename TimerTraits<T1>::ParameterType> TimerImplBase;
1088 TimerImplBase* impl = dynamic_cast<TimerImplBase*>(this);
1089 if (impl == nullptr)
1090 {
1091 NS_FATAL_ERROR("You tried to set Timer arguments incompatible with its function.");
1092 return;
1093 }
1094 impl->SetArguments(a1);
1095}
1096
1097template <typename T1, typename T2>
1098void
1099TimerImpl::SetArgs(T1 a1, T2 a2)
1100{
1101 typedef TimerImplTwo<typename TimerTraits<T1>::ParameterType,
1102 typename TimerTraits<T2>::ParameterType>
1103 TimerImplBase;
1104 TimerImplBase* impl = dynamic_cast<TimerImplBase*>(this);
1105 if (impl == nullptr)
1106 {
1107 NS_FATAL_ERROR("You tried to set Timer arguments incompatible with its function.");
1108 return;
1109 }
1110 impl->SetArguments(a1, a2);
1111}
1112
1113template <typename T1, typename T2, typename T3>
1114void
1115TimerImpl::SetArgs(T1 a1, T2 a2, T3 a3)
1116{
1117 typedef TimerImplThree<typename TimerTraits<T1>::ParameterType,
1118 typename TimerTraits<T2>::ParameterType,
1119 typename TimerTraits<T3>::ParameterType>
1120 TimerImplBase;
1121 TimerImplBase* impl = dynamic_cast<TimerImplBase*>(this);
1122 if (impl == nullptr)
1123 {
1124 NS_FATAL_ERROR("You tried to set Timer arguments incompatible with its function.");
1125 return;
1126 }
1127 impl->SetArguments(a1, a2, a3);
1128}
1129
1130template <typename T1, typename T2, typename T3, typename T4>
1131void
1132TimerImpl::SetArgs(T1 a1, T2 a2, T3 a3, T4 a4)
1133{
1134 typedef TimerImplFour<typename TimerTraits<T1>::ParameterType,
1135 typename TimerTraits<T2>::ParameterType,
1136 typename TimerTraits<T3>::ParameterType,
1137 typename TimerTraits<T4>::ParameterType>
1138 TimerImplBase;
1139 TimerImplBase* impl = dynamic_cast<TimerImplBase*>(this);
1140 if (impl == nullptr)
1141 {
1142 NS_FATAL_ERROR("You tried to set Timer arguments incompatible with its function.");
1143 return;
1144 }
1145 impl->SetArguments(a1, a2, a3, a4);
1146}
1147
1148template <typename T1, typename T2, typename T3, typename T4, typename T5>
1149void
1150TimerImpl::SetArgs(T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
1151{
1152 typedef TimerImplFive<typename TimerTraits<T1>::ParameterType,
1153 typename TimerTraits<T2>::ParameterType,
1154 typename TimerTraits<T3>::ParameterType,
1155 typename TimerTraits<T4>::ParameterType,
1156 typename TimerTraits<T5>::ParameterType>
1157 TimerImplBase;
1158 TimerImplBase* impl = dynamic_cast<TimerImplBase*>(this);
1159 if (impl == nullptr)
1160 {
1161 NS_FATAL_ERROR("You tried to set Timer arguments incompatible with its function.");
1162 return;
1163 }
1164 impl->SetArguments(a1, a2, a3, a4, a5);
1165}
1166
1167template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
1168void
1169TimerImpl::SetArgs(T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6)
1170{
1171 typedef TimerImplSix<typename TimerTraits<T1>::ParameterType,
1172 typename TimerTraits<T2>::ParameterType,
1173 typename TimerTraits<T3>::ParameterType,
1174 typename TimerTraits<T4>::ParameterType,
1175 typename TimerTraits<T5>::ParameterType,
1176 typename TimerTraits<T6>::ParameterType>
1177 TimerImplBase;
1178 TimerImplBase* impl = dynamic_cast<TimerImplBase*>(this);
1179 if (impl == 0)
1180 {
1181 NS_FATAL_ERROR("You tried to set Timer arguments incompatible with its function.");
1182 return;
1183 }
1184 impl->SetArguments(a1, a2, a3, a4, a5, a6);
1185}
1186
1187} // namespace ns3
1188
1189#endif /* TIMER_IMPL_H */
ns3::EventId
An identifier for simulation events.
Definition: event-id.h:55
ns3::Time
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:105
ns3::TimerImpl
The timer implementation underlying Timer and Watchdog.
Definition: timer-impl.h:43
ns3::TimerImpl::SetArgs
void SetArgs(T1 a1)
Set the arguments to be used when invoking the expire function.
Definition: timer-impl.h:1085
ns3::TimerImpl::~TimerImpl
virtual ~TimerImpl()
Destructor.
Definition: timer-impl.h:46
ns3::TimerImpl::Invoke
virtual void Invoke()=0
Invoke the expire function.
ns3::TimerImpl::Schedule
virtual EventId Schedule(const Time &delay)=0
Schedule the callback for a future time.
fatal-error.h
NS_FATAL_x macro definitions.
NS_ASSERT
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
Definition: assert.h:66
NS_FATAL_ERROR
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition: fatal-error.h:179
ns3::MakeTimerImpl
TimerImpl * MakeTimerImpl(FN fn)
Make a TimerImpl from a function pointer taking varying numbers of arguments.
Definition: timer-impl.h:254
int-to-type.h
ns3::IntToType template class.
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
simulator.h
ns3::Simulator declaration.
ns3::IntToType
Convert an integer into a type.
Definition: int-to-type.h:44
ns3::TimerImplFive
TimerImpl specialization class for varying numbers of arguments.
Definition: timer-impl.h:205
ns3::TimerImplFive::SetArguments
virtual void SetArguments(T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)=0
Bind the arguments to be used when the callback function is invoked.
ns3::TimerImplFour
TimerImpl specialization class for varying numbers of arguments.
Definition: timer-impl.h:190
ns3::TimerImplFour::SetArguments
virtual void SetArguments(T1 a1, T2 a2, T3 a3, T4 a4)=0
Bind the arguments to be used when the callback function is invoked.
ns3::TimerImplMemberTraits< T * >::GetReference
static T & GetReference(T *p)
Convert a pointer type to a reference.
Definition: timer-impl.h:658
ns3::TimerImplMemberTraits
Helper for the MakeTimerImpl functions which take a class method.
Definition: timer-impl.h:638
ns3::TimerImplOne
TimerImpl specialization class for varying numbers of arguments.
Definition: timer-impl.h:151
ns3::TimerImplOne::SetArguments
virtual void SetArguments(T1 a1)=0
Bind the arguments to be used when the callback function is invoked.
ns3::TimerImplSix
TimerImpl specialization class for varying numbers of arguments.
Definition: timer-impl.h:221
ns3::TimerImplSix::SetArguments
virtual void SetArguments(T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6)=0
Bind the arguments to be used when the callback function is invoked.
ns3::TimerImplThree
TimerImpl specialization class for varying numbers of arguments.
Definition: timer-impl.h:176
ns3::TimerImplThree::SetArguments
virtual void SetArguments(T1 a1, T2 a2, T3 a3)=0
Bind the arguments to be used when the callback function is invoked.
ns3::TimerImplTwo
TimerImpl specialization class for varying numbers of arguments.
Definition: timer-impl.h:163
ns3::TimerImplTwo::SetArguments
virtual void SetArguments(T1 a1, T2 a2)=0
Bind the arguments to be used when the callback function is invoked.
ns3::TimerTraits
Type and reference traits for TimerImpl arguments.
Definition: timer-impl.h:238
ns3::TimerTraits::StoredType
TypeTraits< typenameTypeTraits< T >::ReferencedType >::NonConstType StoredType
Storage type for an argument.
Definition: timer-impl.h:240
ns3::TimerTraits::ParameterType
const StoredType & ParameterType
Parameter type for an argument.
Definition: timer-impl.h:242
ns3::TypeTraits
Inspect a type to deduce its features.
Definition: type-traits.h:40
type-traits.h
ns3::TypeTraits introspection declaration and template implementation.