20 #ifndef TIMER_IMPL_H

    20 #ifndef TIMER_IMPL_H

    21 #define TIMER_IMPL_H

    21 #define TIMER_IMPL_H

    22 

    22 

    23 #include "simulator.h"

    23 #include "simulator.h"

    24 #include "ns3/type-traits.h"

    24 #include "ns3/type-traits.h"

    25 

    27 

    26 namespace ns3 {

    28 namespace ns3 {

    27 

    29 

    28 class TimerImpl

    30 class TimerImpl

    29 {

    31 {

    45   template <typename T1, typename T2, typename T3, 

    47   template <typename T1, typename T2, typename T3, 

    46             typename T4, typename T5, typename T6>

    48             typename T4, typename T5, typename T6>

    47   void SetArgs (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6);

    49   void SetArgs (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6);

    48 

    50 

    49   virtual EventId Schedule (const Time &delay) = 0;

    51   virtual EventId Schedule (const Time &delay) = 0;

    50 };

    53 };

    51 

    54 

    52 

    55 

    53 template <typename T1>

    56 template <typename T1>

    54 struct TimerImplOne : public TimerImpl

    57 struct TimerImplOne : public TimerImpl

    88 {

    91 {

    89   typedef typename TypeTraits<typename TypeTraits<T>::ReferencedType>::NonConstType StoredType;

    92   typedef typename TypeTraits<typename TypeTraits<T>::ReferencedType>::NonConstType StoredType;

    90   typedef const StoredType &ParameterType;

    93   typedef const StoredType &ParameterType;

    91 };

    94 };

    92 

    95 

    94 template <typename FN>

    96 template <typename FN>

    95 TimerImpl *

    97 TimerImpl *

    96 MakeTimerImpl (FN fn)

    98 MakeTimerImpl (FN fn)

    97 {

    99 {

    98   NS_ASSERT (TypeTraits<FN>::IsFunctionPointer);

   100   NS_ASSERT (TypeTraits<FN>::IsFunctionPointer);

   107   {

   109   {

   108     FnTimerImplZero (FN fn) 

   110     FnTimerImplZero (FN fn) 

   109       : m_fn (fn) {}

   111       : m_fn (fn) {}

   110     virtual EventId Schedule (const Time &delay) {

   112     virtual EventId Schedule (const Time &delay) {

   111       return Simulator::Schedule (delay, m_fn);

   113       return Simulator::Schedule (delay, m_fn);

   112     }

   117     }

   113     FN m_fn;

   118     FN m_fn;

   114   } *function = new FnTimerImplZero (fn);

   119   } *function = new FnTimerImplZero (fn);

   115   return function;

   120   return function;

   116 }

   121 }

   131       m_a1 = a1;

   136       m_a1 = a1;

   132     }

   137     }

   133     virtual EventId Schedule (const Time &delay) {

   138     virtual EventId Schedule (const Time &delay) {

   134       return Simulator::Schedule (delay, m_fn, m_a1);

   139       return Simulator::Schedule (delay, m_fn, m_a1);

   135     }

   140     }

   136     FN m_fn;

   144     FN m_fn;

   137     T1Stored m_a1;

   145     T1Stored m_a1;

   138   } *function = new FnTimerImplOne (fn);

   146   } *function = new FnTimerImplOne (fn);

   139   return function;

   147   return function;

   140 }

   148 }

   159       m_a2 = a2;

   167       m_a2 = a2;

   160     }

   168     }

   161     virtual EventId Schedule (const Time &delay) {

   169     virtual EventId Schedule (const Time &delay) {

   162       return Simulator::Schedule (delay, m_fn, m_a1, m_a2);

   170       return Simulator::Schedule (delay, m_fn, m_a1, m_a2);

   163     }

   171     }

   164     FN m_fn;

   175     FN m_fn;

   165     T1Stored m_a1;

   176     T1Stored m_a1;

   166     T2Stored m_a2;

   177     T2Stored m_a2;

   167   } *function = new FnTimerImplTwo (fn);

   178   } *function = new FnTimerImplTwo (fn);

   168   return function;

   179   return function;

   191       m_a2 = a2;

   202       m_a2 = a2;

   192       m_a3 = a3;

   203       m_a3 = a3;

   193     }

   204     }

   194     virtual EventId Schedule (const Time &delay) {

   205     virtual EventId Schedule (const Time &delay) {

   195       return Simulator::Schedule (delay, m_fn, m_a1, m_a2, m_a3);

   206       return Simulator::Schedule (delay, m_fn, m_a1, m_a2, m_a3);

   196     }

   210     }

   197     FN m_fn;

   211     FN m_fn;

   198     T1Stored m_a1;

   212     T1Stored m_a1;

   199     T2Stored m_a2;

   213     T2Stored m_a2;

   200     T3Stored m_a3;

   214     T3Stored m_a3;

   229       m_a3 = a3;

   243       m_a3 = a3;

   230       m_a4 = a4;

   244       m_a4 = a4;

   231     }

   245     }

   232     virtual EventId Schedule (const Time &delay) {

   246     virtual EventId Schedule (const Time &delay) {

   233       return Simulator::Schedule (delay, m_fn, m_a1, m_a2, m_a3, m_a4);

   247       return Simulator::Schedule (delay, m_fn, m_a1, m_a2, m_a3, m_a4);

   234     }

   251     }

   235     FN m_fn;

   252     FN m_fn;

   236     T1Stored m_a1;

   253     T1Stored m_a1;

   237     T2Stored m_a2;

   254     T2Stored m_a2;

   238     T3Stored m_a3;

   255     T3Stored m_a3;

   272       m_a4 = a4;

   289       m_a4 = a4;

   273       m_a5 = a5;

   290       m_a5 = a5;

   274     }

   291     }

   275     virtual EventId Schedule (const Time &delay) {

   292     virtual EventId Schedule (const Time &delay) {

   276       return Simulator::Schedule (delay, m_fn, m_a1, m_a2, m_a3, m_a4, m_a5);

   293       return Simulator::Schedule (delay, m_fn, m_a1, m_a2, m_a3, m_a4, m_a5);

   277     }

   297     }

   278     FN m_fn;

   298     FN m_fn;

   279     T1Stored m_a1;

   299     T1Stored m_a1;

   280     T2Stored m_a2;

   300     T2Stored m_a2;

   281     T3Stored m_a3;

   301     T3Stored m_a3;

   321       m_a6 = a6;

   341       m_a6 = a6;

   322     }

   342     }

   323     virtual EventId Schedule (const Time &delay) {

   343     virtual EventId Schedule (const Time &delay) {

   324       return Simulator::Schedule (delay, m_fn, m_a1, m_a2, m_a3, m_a4, m_a5, m_a6);

   344       return Simulator::Schedule (delay, m_fn, m_a1, m_a2, m_a3, m_a4, m_a5, m_a6);

   325     }

   345     }

   326     FN m_fn;

   349     FN m_fn;

   327     T1Stored m_a1;

   350     T1Stored m_a1;

   328     T2Stored m_a2;

   351     T2Stored m_a2;

   329     T3Stored m_a3;

   352     T3Stored m_a3;

   330     T4Stored m_a4;

   353     T4Stored m_a4;

   332     T6Stored m_a6;

   355     T6Stored m_a6;

   333   } *function = new FnTimerImplSix (fn);

   356   } *function = new FnTimerImplSix (fn);

   334   return function;

   357   return function;

   335 }

   358 }

   336 

   359 

   337 template <typename MEM_PTR, typename OBJ_PTR>

   373 template <typename MEM_PTR, typename OBJ_PTR>

   338 TimerImpl *

   374 TimerImpl *

   339 MakeTimerImpl (MEM_PTR memPtr, OBJ_PTR objPtr)

   375 MakeTimerImpl (MEM_PTR memPtr, OBJ_PTR objPtr)

   340 {

   376 {

   341   NS_ASSERT (TypeTraits<MEM_PTR>::IsPointerToMember);

   377   NS_ASSERT (TypeTraits<MEM_PTR>::IsPointerToMember);

   350   {

   386   {

   351     MemFnTimerImplZero (MEM_PTR memPtr, OBJ_PTR objPtr) 

   387     MemFnTimerImplZero (MEM_PTR memPtr, OBJ_PTR objPtr) 

   352       : m_memPtr (memPtr), m_objPtr (objPtr) {}

   388       : m_memPtr (memPtr), m_objPtr (objPtr) {}

   353     virtual EventId Schedule (const Time &delay) {

   389     virtual EventId Schedule (const Time &delay) {

   354       return Simulator::Schedule (delay, m_memPtr, m_objPtr);

   390       return Simulator::Schedule (delay, m_memPtr, m_objPtr);

   355     }

   394     }

   356     MEM_PTR m_memPtr;

   395     MEM_PTR m_memPtr;

   357     OBJ_PTR m_objPtr;

   396     OBJ_PTR m_objPtr;

   358   } *function = new MemFnTimerImplZero (memPtr, objPtr);

   397   } *function = new MemFnTimerImplZero (memPtr, objPtr);

   359   return function;

   398   return function;

   375       m_a1 = a1;

   414       m_a1 = a1;

   376     }

   415     }

   377     virtual EventId Schedule (const Time &delay) {

   416     virtual EventId Schedule (const Time &delay) {

   378       return Simulator::Schedule (delay, m_memPtr, m_objPtr, m_a1);

   417       return Simulator::Schedule (delay, m_memPtr, m_objPtr, m_a1);

   379     }

   418     }

   380     MEM_PTR m_memPtr;

   422     MEM_PTR m_memPtr;

   381     OBJ_PTR m_objPtr;

   423     OBJ_PTR m_objPtr;

   382     T1Stored m_a1;

   424     T1Stored m_a1;

   383   } *function = new MemFnTimerImplOne (memPtr, objPtr);

   425   } *function = new MemFnTimerImplOne (memPtr, objPtr);

   384   return function;

   426   return function;

   403       m_a1 = a1;

   445       m_a1 = a1;

   404       m_a2 = a2;

   446       m_a2 = a2;

   405     }

   447     }

   406     virtual EventId Schedule (const Time &delay) {

   448     virtual EventId Schedule (const Time &delay) {

   407       return Simulator::Schedule (delay, m_memPtr, m_objPtr, m_a1, m_a2);

   449       return Simulator::Schedule (delay, m_memPtr, m_objPtr, m_a1, m_a2);

   408     }

   453     }

   409     MEM_PTR m_memPtr;

   454     MEM_PTR m_memPtr;

   410     OBJ_PTR m_objPtr;

   455     OBJ_PTR m_objPtr;

   411     T1Stored m_a1;

   456     T1Stored m_a1;

   412     T2Stored m_a2;

   457     T2Stored m_a2;

   437       m_a2 = a2;

   482       m_a2 = a2;

   438       m_a3 = a3;

   483       m_a3 = a3;

   439     }

   484     }

   440     virtual EventId Schedule (const Time &delay) {

   485     virtual EventId Schedule (const Time &delay) {

   441       return Simulator::Schedule (delay, m_memPtr, m_objPtr, m_a1, m_a2, m_a3);

   486       return Simulator::Schedule (delay, m_memPtr, m_objPtr, m_a1, m_a2, m_a3);

   442     }

   490     }

   443     MEM_PTR m_memPtr;

   491     MEM_PTR m_memPtr;

   444     OBJ_PTR m_objPtr;

   492     OBJ_PTR m_objPtr;

   445     T1Stored m_a1;

   493     T1Stored m_a1;

   446     T2Stored m_a2;

   494     T2Stored m_a2;

   476       m_a3 = a3;

   524       m_a3 = a3;

   477       m_a4 = a4;

   525       m_a4 = a4;

   478     }

   526     }

   479     virtual EventId Schedule (const Time &delay) {

   527     virtual EventId Schedule (const Time &delay) {

   480       return Simulator::Schedule (delay, m_memPtr, m_objPtr, m_a1, m_a2, m_a3, m_a4);

   528       return Simulator::Schedule (delay, m_memPtr, m_objPtr, m_a1, m_a2, m_a3, m_a4);

   481     }

   532     }

   482     MEM_PTR m_memPtr;

   533     MEM_PTR m_memPtr;

   483     OBJ_PTR m_objPtr;

   534     OBJ_PTR m_objPtr;

   484     T1Stored m_a1;

   535     T1Stored m_a1;

   485     T2Stored m_a2;

   536     T2Stored m_a2;

   520       m_a4 = a4;

   571       m_a4 = a4;

   521       m_a5 = a5;

   572       m_a5 = a5;

   522     }

   573     }

   523     virtual EventId Schedule (const Time &delay) {

   574     virtual EventId Schedule (const Time &delay) {

   524       return Simulator::Schedule (delay, m_memPtr, m_objPtr, m_a1, m_a2, m_a3, m_a4, m_a5);

   575       return Simulator::Schedule (delay, m_memPtr, m_objPtr, m_a1, m_a2, m_a3, m_a4, m_a5);

   525     }

   579     }

   526     MEM_PTR m_memPtr;

   580     MEM_PTR m_memPtr;

   527     OBJ_PTR m_objPtr;

   581     OBJ_PTR m_objPtr;

   528     T1Stored m_a1;

   582     T1Stored m_a1;

   529     T2Stored m_a2;

   583     T2Stored m_a2;

   570       m_a6 = a6;

   624       m_a6 = a6;

   571     }

   625     }

   572     virtual EventId Schedule (const Time &delay) {

   626     virtual EventId Schedule (const Time &delay) {

   573       return Simulator::Schedule (delay, m_memPtr, m_objPtr, m_a1, m_a2, m_a3, m_a4, m_a5, m_a6);

   627       return Simulator::Schedule (delay, m_memPtr, m_objPtr, m_a1, m_a2, m_a3, m_a4, m_a5, m_a6);

   574     }

   628     }

   575     MEM_PTR m_memPtr;

   632     MEM_PTR m_memPtr;

   576     OBJ_PTR m_objPtr;

   633     OBJ_PTR m_objPtr;

   577     T1Stored m_a1;

   634     T1Stored m_a1;

   578     T2Stored m_a2;

   635     T2Stored m_a2;

   579     T3Stored m_a3;

   636     T3Stored m_a3;