Attachment #2738 for bug #2457

View | Details | Raw Unified | Return to bug 2457
Collapse All | Expand All




 */
/**
 * \ingroup callback
 * \defgroup makecallbackmemptr MakeCallback from member function pointer
 *
 * Build Callbacks for class method members which take varying numbers
 * of arguments and potentially returning a value.
 *
 * Generally the \c MakeCallback functions are invoked with the
 * method function address first, followed by the \c this pointer:
 * \code
 *   MakeCallback ( & MyClass::Handler, this);
 * \endcode
 *
 * There is not a version with bound arguments.  You may be able to
 * get the same result by using \c MakeBoundCallback with a \c static
 * member function, as in:
 * \code
 *   MakeBoundCallback ( & MyClass::StaticHandler, this);
 * \endcode
 * This still leaves two argument slots available for binding.
 */
/**
 * \ingroup callback
 * \defgroup makecallbackfnptr MakeCallback from function pointers
 *
 * Build Callbacks for functions which take varying numbers of arguments
 * and potentially returning a value.
 */
/**
 * \ingroup callback
 * \defgroup makenullcallback MakeCallback with no arguments
 *
 * Define empty (Null) callbacks as placeholders for unset callback variables.
 */
/**
 * \ingroup callback
 * \defgroup makeboundcallback MakeBoundCallback from functions bound with up to three arguments.
 *
 * Build bound Callbacks which take varying numbers of arguments,


  
/**
 * \ingroup callbackimpl
 *
 * Trait class to convert a pointer into a reference,
 * used by MemPtrCallBackImpl

struct CallbackTraits;

/**
 * \ingroup callbackimpl
 *
 * Trait class to convert a pointer into a reference,
 * used by MemPtrCallBackImpl

};

/**
 * \ingroup callbackimpl
 * CallbackImpl for pointer to member functions
 */
template <typename OBJ_PTR, typename MEM_PTR, typename R, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>

}

/**
 * \ingroup makecallbackmemptr
 * @{
 */
/**
 * Build Callbacks for class method members which take varying numbers
 * of arguments and potentially returning a value.
 *
 * \param [in] memPtr Class method member pointer
 * \param [in] objPtr Class instance
 * \return A wrapper Callback
 * 
 * This \c MakeCallback is invoked with the
 * method function address first, followed by the \c this pointer:
 * \code
 *   MakeCallback ( & MyClass::Handler, this);
 * \endcode
 *
 * There is not a version with bound arguments.  You may be able to
 * get the same result by using \c MakeBoundCallback with a \c static
 * member function, as in:
 * \code
 *   MakeBoundCallback ( & MyClass::StaticHandler, this);
 * \endcode
 * This still leaves two argument slots available for binding.
 */
template <typename T, typename OBJ, typename R, typename... Ts>
Callback<R,Ts...> MakeCallback (R (T::*memPtr)(Ts...), OBJ objPtr) {
  return Callback<R,Ts...> (objPtr, memPtr);
}
template <typename T, typename OBJ, typename R, typename... Ts>
Callback<R,Ts...> MakeCallback (R (T::*memPtr)(Ts...) const, OBJ objPtr) {
  return Callback<R,Ts...> (objPtr, memPtr);
}
template <typename T, typename OBJ, typename R, typename T1>
Callback<R,T1> MakeCallback (R (T::*memPtr)(T1), OBJ objPtr) {
  return Callback<R,T1> (objPtr, memPtr);
}
template <typename T, typename OBJ, typename R, typename T1>
Callback<R,T1> MakeCallback (R (T::*memPtr)(T1) const, OBJ objPtr) {
  return Callback<R,T1> (objPtr, memPtr);
}
template <typename T, typename OBJ, typename R, typename T1, typename T2>
Callback<R,T1,T2> MakeCallback (R (T::*memPtr)(T1,T2), OBJ objPtr) {
  return Callback<R,T1,T2> (objPtr, memPtr);
}
template <typename T, typename OBJ, typename R, typename T1, typename T2>
Callback<R,T1,T2> MakeCallback (R (T::*memPtr)(T1,T2) const, OBJ objPtr) {
  return Callback<R,T1,T2> (objPtr, memPtr);
}
template <typename T, typename OBJ, typename R, typename T1,typename T2, typename T3>
Callback<R,T1,T2,T3> MakeCallback (R (T::*memPtr)(T1,T2,T3), OBJ objPtr) {
  return Callback<R,T1,T2,T3> (objPtr, memPtr);
}
template <typename T, typename OBJ, typename R, typename T1,typename T2, typename T3>
Callback<R,T1,T2,T3> MakeCallback (R (T::*memPtr)(T1,T2,T3) const, OBJ objPtr) {
  return Callback<R,T1,T2,T3> (objPtr, memPtr);
}
template <typename T, typename OBJ, typename R, typename T1, typename T2, typename T3, typename T4>
Callback<R,T1,T2,T3,T4> MakeCallback (R (T::*memPtr)(T1,T2,T3,T4), OBJ objPtr) {
  return Callback<R,T1,T2,T3,T4> (objPtr, memPtr);
}
template <typename T, typename OBJ, typename R, typename T1, typename T2, typename T3, typename T4>
Callback<R,T1,T2,T3,T4> MakeCallback (R (T::*memPtr)(T1,T2,T3,T4) const, OBJ objPtr) {
  return Callback<R,T1,T2,T3,T4> (objPtr, memPtr);
}
template <typename T, typename OBJ, typename R, typename T1, typename T2, typename T3, typename T4,typename T5>
Callback<R,T1,T2,T3,T4,T5> MakeCallback (R (T::*memPtr)(T1,T2,T3,T4,T5), OBJ objPtr) {
  return Callback<R,T1,T2,T3,T4,T5> (objPtr, memPtr);
}
template <typename T, typename OBJ, typename R, typename T1, typename T2, typename T3, typename T4,typename T5>
Callback<R,T1,T2,T3,T4,T5> MakeCallback (R (T::*memPtr)(T1,T2,T3,T4,T5) const, OBJ objPtr) {
  return Callback<R,T1,T2,T3,T4,T5> (objPtr, memPtr);
}
template <typename T, typename OBJ, typename R, typename T1, typename T2, typename T3, typename T4,typename T5,typename T6>
Callback<R,T1,T2,T3,T4,T5,T6> MakeCallback (R (T::*memPtr)(T1,T2,T3,T4,T5,T6), OBJ objPtr) {
  return Callback<R,T1,T2,T3,T4,T5,T6> (objPtr, memPtr);
}
template <typename T, typename OBJ, typename R, typename T1, typename T2, typename T3, typename T4,typename T5, typename T6>
Callback<R,T1,T2,T3,T4,T5,T6> MakeCallback (R (T::*memPtr)(T1,T2,T3,T4,T5,T6) const, OBJ objPtr) {
  return Callback<R,T1,T2,T3,T4,T5,T6> (objPtr, memPtr);
}
template <typename T, typename OBJ, typename R, typename T1, typename T2, typename T3, typename T4,typename T5,typename T6, typename T7>
Callback<R,T1,T2,T3,T4,T5,T6,T7> MakeCallback (R (T::*memPtr)(T1,T2,T3,T4,T5,T6,T7), OBJ objPtr) {
  return Callback<R,T1,T2,T3,T4,T5,T6,T7> (objPtr, memPtr);
}
template <typename T, typename OBJ, typename R, typename T1, typename T2, typename T3, typename T4,typename T5, typename T6, typename T7>
Callback<R,T1,T2,T3,T4,T5,T6,T7> MakeCallback (R (T::*memPtr)(T1,T2,T3,T4,T5,T6,T7) const, OBJ objPtr) {
  return Callback<R,T1,T2,T3,T4,T5,T6,T7> (objPtr, memPtr);
}
template <typename T, typename OBJ, typename R, typename T1, typename T2, typename T3, typename T4,typename T5,typename T6, typename T7, typename T8>
Callback<R,T1,T2,T3,T4,T5,T6,T7,T8> MakeCallback (R (T::*memPtr)(T1,T2,T3,T4,T5,T6,T7,T8), OBJ objPtr) {
  return Callback<R,T1,T2,T3,T4,T5,T6,T7,T8> (objPtr, memPtr);
}
template <typename T, typename OBJ, typename R, typename T1, typename T2, typename T3, typename T4,typename T5, typename T6, typename T7, typename T8>
Callback<R,T1,T2,T3,T4,T5,T6,T7,T8> MakeCallback (R (T::*memPtr)(T1,T2,T3,T4,T5,T6,T7,T8) const, OBJ objPtr) {
  return Callback<R,T1,T2,T3,T4,T5,T6,T7,T8> (objPtr, memPtr);
}
template <typename T, typename OBJ, typename R, typename T1, typename T2, typename T3, typename T4,typename T5,typename T6, typename T7, typename T8, typename T9>
Callback<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> MakeCallback (R (T::*memPtr)(T1,T2,T3,T4,T5,T6,T7,T8,T9), OBJ objPtr) {
  return Callback<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> (objPtr, memPtr);
}
template <typename T, typename OBJ, typename R, typename T1, typename T2, typename T3, typename T4,typename T5, typename T6, typename T7, typename T8, typename T9>
Callback<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> MakeCallback (R (T::*memPtr)(T1,T2,T3,T4,T5,T6,T7,T8,T9) const, OBJ objPtr) {
  return Callback<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> (objPtr, memPtr);
}
/**@}*/

/**
 * \ingroup makecallbackfnptr
 * @{
 */
/**
 * \param [in] fnPtr Function pointer
 * \return A wrapper Callback
 * 
 * Build Callbacks for functions which take varying numbers of arguments
 * and potentially returning a value.
 */
template <typename R, typename... Ts>
Callback<R,Ts...> MakeCallback (R (*fnPtr)(Ts...)) {
  return Callback<R,Ts...> (fnPtr, true, true);
}

Callback<R,T1> MakeCallback (R (*fnPtr)(T1)) {
  return Callback<R,T1> (fnPtr, true, true);
}
template <typename R, typename T1, typename T2>
Callback<R,T1,T2> MakeCallback (R (*fnPtr)(T1,T2)) {
  return Callback<R,T1,T2> (fnPtr, true, true);
}
template <typename R, typename T1, typename T2,typename T3>
Callback<R,T1,T2,T3> MakeCallback (R (*fnPtr)(T1,T2,T3)) {
  return Callback<R,T1,T2,T3> (fnPtr, true, true);
}
template <typename R, typename T1, typename T2,typename T3,typename T4>
Callback<R,T1,T2,T3,T4> MakeCallback (R (*fnPtr)(T1,T2,T3,T4)) {
  return Callback<R,T1,T2,T3,T4> (fnPtr, true, true);
}
template <typename R, typename T1, typename T2,typename T3,typename T4,typename T5>
Callback<R,T1,T2,T3,T4,T5> MakeCallback (R (*fnPtr)(T1,T2,T3,T4,T5)) {
  return Callback<R,T1,T2,T3,T4,T5> (fnPtr, true, true);
}
template <typename R, typename T1, typename T2,typename T3,typename T4,typename T5,typename T6>
Callback<R,T1,T2,T3,T4,T5,T6> MakeCallback (R (*fnPtr)(T1,T2,T3,T4,T5,T6)) {
  return Callback<R,T1,T2,T3,T4,T5,T6> (fnPtr, true, true);
}
template <typename R, typename T1, typename T2,typename T3,typename T4,typename T5,typename T6, typename T7>
Callback<R,T1,T2,T3,T4,T5,T6,T7> MakeCallback (R (*fnPtr)(T1,T2,T3,T4,T5,T6,T7)) {
  return Callback<R,T1,T2,T3,T4,T5,T6,T7> (fnPtr, true, true);
}
template <typename R, typename T1, typename T2,typename T3,typename T4,typename T5,typename T6, typename T7, typename T8>
Callback<R,T1,T2,T3,T4,T5,T6,T7,T8> MakeCallback (R (*fnPtr)(T1,T2,T3,T4,T5,T6,T7,T8)) {
  return Callback<R,T1,T2,T3,T4,T5,T6,T7,T8> (fnPtr, true, true);
}
template <typename R, typename T1, typename T2,typename T3,typename T4,typename T5,typename T6, typename T7, typename T8, typename T9>
Callback<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> MakeCallback (R (*fnPtr)(T1,T2,T3,T4,T5,T6,T7,T8,T9)) {
  return Callback<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> (fnPtr, true, true);
}
/**@}*/

/**
 * \ingroup callback
 * @{
 */
/**
 * \return A wrapper Callback
 *
 * Build null Callbacks which take no arguments,
 * for varying number of template arguments,
 * and potentially returning a value.
 */
template <typename R, typename... Ts>
Callback<R,Ts...> MakeNullCallback (void) {
  return Callback<R,Ts...> ();
}
template <typename R, typename T1>
Callback<R,T1> MakeNullCallback (void) {
  return Callback<R,T1> ();
}
template <typename R, typename T1, typename T2>
Callback<R,T1,T2> MakeNullCallback (void) {
  return Callback<R,T1,T2> ();
}
template <typename R, typename T1, typename T2,typename T3>
Callback<R,T1,T2,T3> MakeNullCallback (void) {
  return Callback<R,T1,T2,T3> ();
}
template <typename R, typename T1, typename T2,typename T3,typename T4>
Callback<R,T1,T2,T3,T4> MakeNullCallback (void) {
  return Callback<R,T1,T2,T3,T4> ();
}
template <typename R, typename T1, typename T2,typename T3,typename T4,typename T5>
Callback<R,T1,T2,T3,T4,T5> MakeNullCallback (void) {
  return Callback<R,T1,T2,T3,T4,T5> ();
}
template <typename R, typename T1, typename T2,typename T3,typename T4,typename T5,typename T6>
Callback<R,T1,T2,T3,T4,T5,T6> MakeNullCallback (void) {
  return Callback<R,T1,T2,T3,T4,T5,T6> ();
}
template <typename R, typename T1, typename T2,typename T3,typename T4,typename T5,typename T6, typename T7>
Callback<R,T1,T2,T3,T4,T5,T6,T7> MakeNullCallback (void) {
  return Callback<R,T1,T2,T3,T4,T5,T6,T7> ();
}
template <typename R, typename T1, typename T2,typename T3,typename T4,typename T5,typename T6, typename T7, typename T8>
Callback<R,T1,T2,T3,T4,T5,T6,T7,T8> MakeNullCallback (void) {
  return Callback<R,T1,T2,T3,T4,T5,T6,T7,T8> ();
}
template <typename R, typename T1, typename T2,typename T3,typename T4,typename T5,typename T6, typename T7, typename T8, typename T9>
Callback<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> MakeNullCallback (void) {
  return Callback<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> ();
}
/**@}*/


/**

(-)a/src/core/model/default-simulator-impl.cc (-1 / +1 lines)

Lines 218-224	Link Here

218

DefaultSimulatorImpl::Stop (Time const &delay)

218

DefaultSimulatorImpl::Stop (Time const &delay)

219

220

  NS_LOG_FUNCTION (this << delay.GetTimeStep ());

220

  NS_LOG_FUNCTION (this << delay.GetTimeStep ());

221

  Simulator::Schedule (delay, &Simulator::Stop);

221

  Simulator::Schedule<void ()> (delay, &Simulator::Stop);

222

223

224

//

224

//




#ifndef MAKE_EVENT_H
#define MAKE_EVENT_H

#include "event-impl.h"
#include <functional>

/**
 * \file
 * \ingroup events
 * ns3::MakeEvent function template.
 */

namespace ns3 {

class EventImpl;

/**
 * \ingroup events
 * Create EventImpl instance from a callable object.
 *
 * \tparam Ts \deduced Argument types.
 * \param [in] args Callable object and bound arguments, forwarded to std::bind.
 */
/**
 * \ingroup makeeventmemptr
 * @{
 */
/**
 * Make an EventImpl from class method members which take
 * varying numbers of arguments.
 *
 * \tparam MEM \deduced The class method function signature.
 * \tparam OBJ \deduced The class type holding the method.
 * \param [in] mem_ptr Class method member function pointer
 * \param [in] obj Class instance.
 * \returns The constructed EventImpl.
 */
template <typename... Ts>
EventImpl * MakeEvent (Ts&&... args)

/**
 * \copybrief MakeEvent(MEM,OBJ)
 * \tparam MEM \deduced The class method function signature.
 * \tparam OBJ \deduced The class type holding the method.
 * \tparam T1 \deduced Type of the argument to the underlying function.
 * \param [in] mem_ptr Class method member function pointer
 * \param [in] obj Class instance.
 * \param [in] a1 Argument value to be bound to the underlying function.
 * \returns The constructed EventImpl.
 */
template <typename MEM, typename OBJ,
          typename T1>
EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, T1 a1);

/**
 * \copybrief MakeEvent(MEM,OBJ)
 * \tparam MEM \deduced The class method function signature.
 * \tparam OBJ \deduced The class type holding the method.
 * \tparam T1 \deduced Type of the first argument to the underlying function.
 * \tparam T2 \deduced Type of the second argument to the underlying function.
 * \param [in] mem_ptr Class method member function pointer
 * \param [in] obj Class instance.
 * \param [in] a1 First argument value to be bound to the underlying function.
 * \param [in] a2 Second argument value to be bound to the underlying function.
 * \returns The constructed EventImpl.
 */
template <typename MEM, typename OBJ,
          typename T1, typename T2>
EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, T1 a1, T2 a2);

/**
 * \copybrief MakeEvent(MEM,OBJ)
 * \tparam MEM \deduced The class method function signature.
 * \tparam OBJ \deduced The class type holding the method.
 * \tparam T1 \deduced Type of the first argument to the underlying function.
 * \tparam T2 \deduced Type of the second argument to the underlying function.
 * \tparam T3 \deduced Type of the third argument to the underlying function.
 * \param [in] mem_ptr Class method member function pointer
 * \param [in] obj Class instance.
 * \param [in] a1 First argument value to be bound to the underlying function.
 * \param [in] a2 Second argument value to be bound to the underlying function.
 * \param [in] a3 Third argument value to be bound to the underlying function.
 * \returns The constructed EventImpl.
 */
template <typename MEM, typename OBJ,
          typename T1, typename T2, typename T3>
EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3);

/**
 * \copybrief MakeEvent(MEM,OBJ)
 * \tparam MEM \deduced The class method function signature.
 * \tparam OBJ \deduced The class type holding the method.
 * \tparam T1 \deduced Type of the first argument to the underlying function.
 * \tparam T2 \deduced Type of the second argument to the underlying function.
 * \tparam T3 \deduced Type of the third argument to the underlying function.
 * \tparam T4 \deduced Type of the fourth argument to the underlying function.
 * \param [in] mem_ptr Class method member function pointer
 * \param [in] obj Class instance.
 * \param [in] a1 First argument value to be bound to the underlying function.
 * \param [in] a2 Second argument value to be bound to the underlying function.
 * \param [in] a3 Third argument value to be bound to the underlying function.
 * \param [in] a4 Fourth argument value to be bound to the underlying function.
 * \returns The constructed EventImpl.
 */
template <typename MEM, typename OBJ,
          typename T1, typename T2, typename T3, typename T4>
EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3, T4 a4);

/**
 * \copybrief MakeEvent(MEM,OBJ)
 * \tparam MEM \deduced The class method function signature.
 * \tparam OBJ \deduced The class type holding the method.
 * \tparam T1 \deduced Type of the first argument to the underlying function.
 * \tparam T2 \deduced Type of the second argument to the underlying function.
 * \tparam T3 \deduced Type of the third argument to the underlying function.
 * \tparam T4 \deduced Type of the fourth argument to the underlying function.
 * \tparam T5 \deduced Type of the fifth argument to the underlying function.
 * \param [in] mem_ptr Class method member function pointer
 * \param [in] obj Class instance.
 * \param [in] a1 First argument value to be bound to the underlying function.
 * \param [in] a2 Second argument value to be bound to the underlying function.
 * \param [in] a3 Third argument value to be bound to the underlying function.
 * \param [in] a4 Fourth argument value to be bound to the underlying function.
 * \param [in] a5 Fifh argument value to be bound to the underlying function.
 * \returns The constructed EventImpl.
 */
template <typename MEM, typename OBJ,
          typename T1, typename T2, typename T3, typename T4, typename T5>
EventImpl * MakeEvent (MEM mem_ptr, OBJ obj,
                       T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);
/**@}*/
  
/**
 * \ingroup events
 * \defgroup makeeventfnptr MakeEvent from Function Pointers.
 *
 * Create EventImpl instances from function pointers which take
 * varying numbers of arguments.
 *
 * @{
 */
/**
 * Make an EventImpl from a function pointer taking varying numbers
 * of arguments.
 *
 * \param [in] f The function pointer.
 * \returns The constructed EventImpl.
 */
EventImpl * MakeEvent (void (*f)(void));

/**
 * \copybrief MakeEvent(void(*f)(void))
 * \tparam U1 \deduced Formal type of the argument to the function.
 * \tparam T1 \deduced Actual type of the argument to the function.
 * \param [in] f The function pointer.
 * \param [in] a1 Argument to be bound to the function.
 * \returns The constructed EventImpl.
 */
template <typename U1,
          typename T1>
EventImpl * MakeEvent (void (*f)(U1), T1 a1);

/**
 * \copybrief MakeEvent(void(*f)(void))
 * \tparam U1 \deduced Formal type of the first argument to the function.
 * \tparam U2 \deduced Formal type of the second argument to the function.
 * \tparam T1 \deduced Actual type of the first argument to the function.
 * \tparam T2 \deduced Actual type of the second argument to the function.
 * \param [in] f The function pointer.
 * \param [in] a1 First argument to be bound to the function.
 * \param [in] a2 Second argument to be bound to the function.
 * \returns The constructed EventImpl.
 */
template <typename U1, typename U2,
          typename T1, typename T2>
EventImpl * MakeEvent (void (*f)(U1,U2), T1 a1, T2 a2);

/**
 * \copybrief MakeEvent(void(*f)(void))
 * \tparam U1 \deduced Formal type of the first argument to the function.
 * \tparam U2 \deduced Formal type of the second argument to the function.
 * \tparam U3 \deduced Formal type of the third argument to the function.
 * \tparam T1 \deduced Actual type of the first argument to the function.
 * \tparam T2 \deduced Actual type of the second argument to the function.
 * \tparam T3 \deduced Actual type of the third argument to the function.
 * \param [in] f The function pointer.
 * \param [in] a1 First argument to be bound to the function.
 * \param [in] a2 Second argument to be bound to the function.
 * \param [in] a3 Third argument to be bound to the function.
 * \returns The constructed EventImpl.
 */
template <typename U1, typename U2, typename U3,
          typename T1, typename T2, typename T3>
EventImpl * MakeEvent (void (*f)(U1,U2,U3), T1 a1, T2 a2, T3 a3);

/**
 * \copybrief MakeEvent(void(*f)(void))
 * \tparam U1 \deduced Formal type of the first argument to the function.
 * \tparam U2 \deduced Formal type of the second argument to the function.
 * \tparam U3 \deduced Formal type of the third argument to the function.
 * \tparam U4 \deduced Formal type of the fourth argument to the function.
 * \tparam T1 \deduced Actual type of the first argument to the function.
 * \tparam T2 \deduced Actual type of the second argument to the function.
 * \tparam T3 \deduced Actual type of the third argument to the function.
 * \tparam T4 \deduced Actual type of the fourth argument to the function.
 * \param [in] f The function pointer.
 * \param [in] a1 First argument to be bound to the function.
 * \param [in] a2 Second argument to be bound to the function.
 * \param [in] a3 Third argument to be bound to the function.
 * \param [in] a4 Fourth argument to be bound to the function.
 * \returns The constructed EventImpl.
 */
template <typename U1, typename U2, typename U3, typename U4,
          typename T1, typename T2, typename T3, typename T4>
EventImpl * MakeEvent (void (*f)(U1,U2,U3,U4), T1 a1, T2 a2, T3 a3, T4 a4);

/**
 * \copybrief MakeEvent(void(*f)(void))
 * \tparam U1 \deduced Formal type of the first argument to the function.
 * \tparam U2 \deduced Formal type of the second argument to the function.
 * \tparam U3 \deduced Formal type of the third argument to the function.
 * \tparam U4 \deduced Formal type of the fourth argument to the function.
 * \tparam U5 \deduced Formal type of the fifth argument to the function.
 * \tparam T1 \deduced Actual type of the first argument to the function.
 * \tparam T2 \deduced Actual type of the second argument to the function.
 * \tparam T3 \deduced Actual type of the third argument to the function.
 * \tparam T4 \deduced Actual type of the fourth argument to the function.
 * \tparam T5 \deduced Actual type of the fifth argument to the function.
 * \param [in] f The function pointer.
 * \param [in] a1 First argument to be bound to the function.
 * \param [in] a2 Second argument to be bound to the function.
 * \param [in] a3 Third argument to be bound to the function.
 * \param [in] a4 Fourth argument to be bound to the function.
 * \param [in] a5 Fifth argument to be bound to the function.
 * \returns The constructed EventImpl.
 */
template <typename U1, typename U2, typename U3, typename U4, typename U5,
          typename T1, typename T2, typename T3, typename T4, typename T5>
EventImpl * MakeEvent (void (*f)(U1,U2,U3,U4,U5), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);
/**@}*/

} // namespace ns3

/********************************************************************
 *  Implementation of the templates declared above.
 ********************************************************************/

#include "event-impl.h"
#include "type-traits.h"

namespace ns3 {

/**
 * \ingroup makeeventmemptr
 * Helper for the MakeEvent functions which take a class method.
 *
 * This helper converts a pointer to a reference.
 *
 * This is the generic template declaration (with empty body).
 *
 * \tparam T \explicit The class type.
 */
template <typename T>
struct EventMemberImplObjTraits;

/**
 * \ingroup makeeventmemptr
 * Helper for the MakeEvent functions which take a class method.
 *
 * This helper converts a pointer to a reference.
 *
 * This is the specialization for pointer types.
 *
 * \tparam T \explicit The class type.
 */
template <typename T>
struct EventMemberImplObjTraits<T *>
{
  class EventMemberImpl : public EventImpl
   * \param [in] p Object pointer.
   * \return A reference to the object pointed to by p.
   */
  static T &GetReference (T *p)
  {
    return *p;
  }
};

template <typename MEM, typename OBJ>
EventImpl * MakeEvent (MEM mem_ptr, OBJ obj)
{
  // zero argument version
  class EventMemberImpl0 : public EventImpl
  {
public:
    EventMemberImpl (Ts&&... args)
      : m_function (std::bind (std::forward<Ts> (args)...))
        m_function (function)
    {
    }
protected:
    virtual ~EventMemberImpl ()
    {
    }
private:
    virtual void Notify ()
    {
      m_function ();
    }
    std::function<void ()> m_function;
  };
  return new EventMemberImpl (std::forward<Ts> (args)...);
  return ev;
}


template <typename MEM, typename OBJ,
          typename T1>
EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, T1 a1)
{
  // one argument version
  class EventMemberImpl1 : public EventImpl
  {
public:
    EventMemberImpl1 (OBJ obj, MEM function, T1 a1)
      : m_obj (obj),
        m_function (function),
        m_a1 (a1)
    {
    }
protected:
    virtual ~EventMemberImpl1 ()
    {
    }
private:
    virtual void Notify (void)
    {
      (EventMemberImplObjTraits<OBJ>::GetReference (m_obj).*m_function)(m_a1);
    }
    OBJ m_obj;
    MEM m_function;
    typename TypeTraits<T1>::ReferencedType m_a1;
  } *ev = new EventMemberImpl1 (obj, mem_ptr, a1);
  return ev;
}

template <typename MEM, typename OBJ,
          typename T1, typename T2>
EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, T1 a1, T2 a2)
{
  // two argument version
  class EventMemberImpl2 : public EventImpl
  {
public:
    EventMemberImpl2 (OBJ obj, MEM function, T1 a1, T2 a2)
      : m_obj (obj),
        m_function (function),
        m_a1 (a1),
        m_a2 (a2)
    {
    }
protected:
    virtual ~EventMemberImpl2 ()
    {
    }
private:
    virtual void Notify (void)
    {
      (EventMemberImplObjTraits<OBJ>::GetReference (m_obj).*m_function)(m_a1, m_a2);
    }
    OBJ m_obj;
    MEM m_function;
    typename TypeTraits<T1>::ReferencedType m_a1;
    typename TypeTraits<T2>::ReferencedType m_a2;
  } *ev = new EventMemberImpl2 (obj, mem_ptr, a1, a2);
  return ev;
}

template <typename MEM, typename OBJ,
          typename T1, typename T2, typename T3>
EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3)
{
  // three argument version
  class EventMemberImpl3 : public EventImpl
  {
public:
    EventMemberImpl3 (OBJ obj, MEM function, T1 a1, T2 a2, T3 a3)
      : m_obj (obj),
        m_function (function),
        m_a1 (a1),
        m_a2 (a2),
        m_a3 (a3)
    {
    }
protected:
    virtual ~EventMemberImpl3 ()
    {
    }
private:
    virtual void Notify (void)
    {
      (EventMemberImplObjTraits<OBJ>::GetReference (m_obj).*m_function)(m_a1, m_a2, m_a3);
    }
    OBJ m_obj;
    MEM m_function;
    typename TypeTraits<T1>::ReferencedType m_a1;
    typename TypeTraits<T2>::ReferencedType m_a2;
    typename TypeTraits<T3>::ReferencedType m_a3;
  } *ev = new EventMemberImpl3 (obj, mem_ptr, a1, a2, a3);
  return ev;
}

template <typename MEM, typename OBJ,
          typename T1, typename T2, typename T3, typename T4>
EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3, T4 a4)
{
  // four argument version
  class EventMemberImpl4 : public EventImpl
  {
public:
    EventMemberImpl4 (OBJ obj, MEM function, T1 a1, T2 a2, T3 a3, T4 a4)
      : m_obj (obj),
        m_function (function),
        m_a1 (a1),
        m_a2 (a2),
        m_a3 (a3),
        m_a4 (a4)
    {
    }
protected:
    virtual ~EventMemberImpl4 ()
    {
    }
private:
    virtual void Notify (void)
    {
      (EventMemberImplObjTraits<OBJ>::GetReference (m_obj).*m_function)(m_a1, m_a2, m_a3, m_a4);
    }
    OBJ m_obj;
    MEM m_function;
    typename TypeTraits<T1>::ReferencedType m_a1;
    typename TypeTraits<T2>::ReferencedType m_a2;
    typename TypeTraits<T3>::ReferencedType m_a3;
    typename TypeTraits<T4>::ReferencedType m_a4;
  } *ev = new EventMemberImpl4 (obj, mem_ptr, a1, a2, a3, a4);
  return ev;
}

template <typename MEM, typename OBJ,
          typename T1, typename T2, typename T3, typename T4, typename T5>
EventImpl * MakeEvent (MEM mem_ptr, OBJ obj,
                       T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
{
  // five argument version
  class EventMemberImpl5 : public EventImpl
  {
public:
    EventMemberImpl5 (OBJ obj, MEM function, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
      : m_obj (obj),
        m_function (function),
        m_a1 (a1),
        m_a2 (a2),
        m_a3 (a3),
        m_a4 (a4),
        m_a5 (a5)
    {
    }
protected:
    virtual ~EventMemberImpl5 ()
    {
    }
private:
    virtual void Notify (void)
    {
      (EventMemberImplObjTraits<OBJ>::GetReference (m_obj).*m_function)(m_a1, m_a2, m_a3, m_a4, m_a5);
    }
    OBJ m_obj;
    MEM m_function;
    typename TypeTraits<T1>::ReferencedType m_a1;
    typename TypeTraits<T2>::ReferencedType m_a2;
    typename TypeTraits<T3>::ReferencedType m_a3;
    typename TypeTraits<T4>::ReferencedType m_a4;
    typename TypeTraits<T5>::ReferencedType m_a5;
  } *ev = new EventMemberImpl5 (obj, mem_ptr, a1, a2, a3, a4, a5);
  return ev;
}

template <typename U1, typename T1>
EventImpl * MakeEvent (void (*f)(U1), T1 a1)
{
  // one arg version
  class EventFunctionImpl1 : public EventImpl
  {
public:
    typedef void (*F)(U1);

    EventFunctionImpl1 (F function, T1 a1)
      : m_function (function),
        m_a1 (a1)
    {
    }
protected:
    virtual ~EventFunctionImpl1 ()
    {
    }
private:
    virtual void Notify (void)
    {
      (*m_function)(m_a1);
    }
    F m_function;
    typename TypeTraits<T1>::ReferencedType m_a1;
  } *ev = new EventFunctionImpl1 (f, a1);
  return ev;
}

template <typename U1, typename U2, typename T1, typename T2>
EventImpl * MakeEvent (void (*f)(U1,U2), T1 a1, T2 a2)
{
  // two arg version
  class EventFunctionImpl2 : public EventImpl
  {
public:
    typedef void (*F)(U1, U2);

    EventFunctionImpl2 (F function, T1 a1, T2 a2)
      : m_function (function),
        m_a1 (a1),
        m_a2 (a2)
    {
    }
protected:
    virtual ~EventFunctionImpl2 ()
    {
    }
private:
    virtual void Notify (void)
    {
      (*m_function)(m_a1, m_a2);
    }
    F m_function;
    typename TypeTraits<T1>::ReferencedType m_a1;
    typename TypeTraits<T2>::ReferencedType m_a2;
  } *ev = new EventFunctionImpl2 (f, a1, a2);
  return ev;
}

template <typename U1, typename U2, typename U3,
          typename T1, typename T2, typename T3>
EventImpl * MakeEvent (void (*f)(U1,U2,U3), T1 a1, T2 a2, T3 a3)
{
  // three arg version
  class EventFunctionImpl3 : public EventImpl
  {
public:
    typedef void (*F)(U1, U2, U3);

    EventFunctionImpl3 (F function, T1 a1, T2 a2, T3 a3)
      : m_function (function),
        m_a1 (a1),
        m_a2 (a2),
        m_a3 (a3)
    {
    }
protected:
    virtual ~EventFunctionImpl3 ()
    {
    }
private:
    virtual void Notify (void)
    {
      (*m_function)(m_a1, m_a2, m_a3);
    }
    F m_function;
    typename TypeTraits<T1>::ReferencedType m_a1;
    typename TypeTraits<T2>::ReferencedType m_a2;
    typename TypeTraits<T3>::ReferencedType m_a3;
  } *ev = new EventFunctionImpl3 (f, a1, a2, a3);
  return ev;
}

template <typename U1, typename U2, typename U3, typename U4,
          typename T1, typename T2, typename T3, typename T4>
EventImpl * MakeEvent (void (*f)(U1,U2,U3,U4), T1 a1, T2 a2, T3 a3, T4 a4)
{
  // four arg version
  class EventFunctionImpl4 : public EventImpl
  {
public:
    typedef void (*F)(U1, U2, U3, U4);

    EventFunctionImpl4 (F function, T1 a1, T2 a2, T3 a3, T4 a4)
      : m_function (function),
        m_a1 (a1),
        m_a2 (a2),
        m_a3 (a3),
        m_a4 (a4)
    {
    }
protected:
    virtual ~EventFunctionImpl4 ()
    {
    }
private:
    virtual void Notify (void)
    {
      (*m_function)(m_a1, m_a2, m_a3, m_a4);
    }
    F m_function;
    typename TypeTraits<T1>::ReferencedType m_a1;
    typename TypeTraits<T2>::ReferencedType m_a2;
    typename TypeTraits<T3>::ReferencedType m_a3;
    typename TypeTraits<T4>::ReferencedType m_a4;
  } *ev = new EventFunctionImpl4 (f, a1, a2, a3, a4);
  return ev;
}

template <typename U1, typename U2, typename U3, typename U4, typename U5,
          typename T1, typename T2, typename T3, typename T4, typename T5>
EventImpl * MakeEvent (void (*f)(U1,U2,U3,U4,U5), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
{
  // five arg version
  class EventFunctionImpl5 : public EventImpl
  {
public:
    typedef void (*F)(U1,U2,U3,U4,U5);

    EventFunctionImpl5 (F function, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
      : m_function (function),
        m_a1 (a1),
        m_a2 (a2),
        m_a3 (a3),
        m_a4 (a4),
        m_a5 (a5)
    {
    }
protected:
    virtual ~EventFunctionImpl5 ()
    {
    }
private:
    virtual void Notify (void)
    {
      (*m_function)(m_a1, m_a2, m_a3, m_a4, m_a5);
    }
    F m_function;
    typename TypeTraits<T1>::ReferencedType m_a1;
    typename TypeTraits<T2>::ReferencedType m_a2;
    typename TypeTraits<T3>::ReferencedType m_a3;
    typename TypeTraits<T4>::ReferencedType m_a4;
    typename TypeTraits<T5>::ReferencedType m_a5;
  } *ev = new EventFunctionImpl5 (f, a1, a2, a3, a4, a5);
  return ev;
}

} // namespace ns3




  /**
   * Check if the object has been initialized.
   *
   * \brief Check if the object has been initialized.
   * \returns \c true if the object has been initialized.
   */
  bool IsInitialized (void) const;


 * Create an object by type, with varying number of constructor parameters.
 *
 * \tparam T \explicit The type of the derived object to construct.
 * \tparam Ts \deduced Constructor argument types.
 * \param [in] args The arguments to use in creating the object.
 * \return The derived object.
 */
template <typename T, typename... Ts>
Ptr<T> CreateObject (Ts... args)
{
  return CompleteConstruct (new T (args...));
}
/**
 * \copybrief CreateObject()
 * \tparam T \explicit The type of the derived object to construct.
 * \tparam T1 \deduced The type of the constructor argument.
 * \param [in] a1 The constructor argument
 * \return The derived object.
 */
template <typename T, typename T1>
Ptr<T> CreateObject (T1 a1)
{
  return CompleteConstruct (new T (a1));
}

/**
 * \copybrief CreateObject()
 * \tparam T \explicit The type of the derived object to construct.
 * \tparam T1 \deduced The type of the first constructor argument.
 * \tparam T2 \deduced The type of the second constructor argument.
 * \param [in] a1 The constructor first argument
 * \param [in] a2 The constructor second argument
 * \return The derived object.
 */
template <typename T, typename T1, typename T2>
Ptr<T> CreateObject (T1 a1, T2 a2)
{
  return CompleteConstruct (new T (a1,a2));
}

/**
 * \copybrief CreateObject()
 * \tparam T \explicit The type of the derived object to construct.
 * \tparam T1 \deduced The type of the first constructor argument.
 * \tparam T2 \deduced The type of the second constructor argument.
 * \tparam T3 \deduced The type of the third constructor argument.
 * \param [in] a1 The constructor first argument
 * \param [in] a2 The constructor second argument
 * \param [in] a3 The constructor third argument
 * \return The derived object.
 */
template <typename T, typename T1, typename T2, typename T3>
Ptr<T> CreateObject (T1 a1, T2 a2, T3 a3)
{
  return CompleteConstruct (new T (a1,a2,a3));
}

/**
 * \copybrief CreateObject()
 * \tparam T \explicit The type of the derived object to construct.
 * \tparam T1 \deduced The type of the first constructor argument.
 * \tparam T2 \deduced The type of the second constructor argument.
 * \tparam T3 \deduced The type of the third constructor argument.
 * \tparam T4 \deduced The type of the fourth constructor argument.
 * \param [in] a1 The constructor first argument
 * \param [in] a2 The constructor second argument
 * \param [in] a3 The constructor third argument
 * \param [in] a4 The constructor fourth argument
 * \return The derived object.
 */
template <typename T, typename T1, typename T2, typename T3, typename T4>
Ptr<T> CreateObject (T1 a1, T2 a2, T3 a3, T4 a4)
{
  return CompleteConstruct (new T (a1,a2,a3,a4));
}

/**
 * \copybrief CreateObject()
 * \tparam T \explicit The type of the derived object to construct.
 * \tparam T1 \deduced The type of the first constructor argument.
 * \tparam T2 \deduced The type of the second constructor argument.
 * \tparam T3 \deduced The type of the third constructor argument.
 * \tparam T4 \deduced The type of the fourth constructor argument.
 * \tparam T5 \deduced The type of the fifth constructor argument.
 * \param [in] a1 The constructor first argument
 * \param [in] a2 The constructor second argument
 * \param [in] a3 The constructor third argument
 * \param [in] a4 The constructor fourth argument
 * \param [in] a5 The constructor fifth argument
 * \return The derived object.
 */
template <typename T, typename T1, typename T2, typename T3, typename T4, typename T5>
Ptr<T> CreateObject (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
{
  return CompleteConstruct (new T (a1,a2,a3,a4,a5));
}

/**
 * \copybrief CreateObject()
 * \tparam T \explicit The type of the derived object to construct.
 * \tparam T1 \deduced The type of the first constructor argument.
 * \tparam T2 \deduced The type of the second constructor argument.
 * \tparam T3 \deduced The type of the third constructor argument.
 * \tparam T4 \deduced The type of the fourth constructor argument.
 * \tparam T5 \deduced The type of the fifth constructor argument.
 * \tparam T6 \deduced The type of the sixth constructor argument.
 * \param [in] a1 The constructor first argument
 * \param [in] a2 The constructor second argument
 * \param [in] a3 The constructor third argument
 * \param [in] a4 The constructor fourth argument
 * \param [in] a5 The constructor fifth argument
 * \param [in] a6 The constructor sixth argument
 * \return The derived object.
 */
template <typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
Ptr<T> CreateObject (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6)
{
  return CompleteConstruct (new T (a1,a2,a3,a4,a5,a6));
}

/**
 * \copybrief CreateObject()
 * \tparam T \explicit The type of the derived object to construct.
 * \tparam T1 \deduced The type of the first constructor argument.
 * \tparam T2 \deduced The type of the second constructor argument.
 * \tparam T3 \deduced The type of the third constructor argument.
 * \tparam T4 \deduced The type of the fourth constructor argument.
 * \tparam T5 \deduced The type of the fifth constructor argument.
 * \tparam T6 \deduced The type of the sixth constructor argument.
 * \tparam T7 \deduced The type of the seventh constructor argument.
 * \param [in] a1 The constructor first argument
 * \param [in] a2 The constructor second argument
 * \param [in] a3 The constructor third argument
 * \param [in] a4 The constructor fourth argument
 * \param [in] a5 The constructor fifth argument
 * \param [in] a6 The constructor sixth argument
 * \param [in] a7 The constructor seventh argument
 * \return The derived object.
 */
template <typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
Ptr<T> CreateObject (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7)
{
  return CompleteConstruct (new T (a1,a2,a3,a4,a5,a6,a7));
}
/**@}*/





 * Create class instances by constructors with varying numbers
 * of arguments and return them by Ptr.
 *
 * This template work for any class \c T derived from ns3::SimpleRefCount
 *
 * \see CreateObject for methods to create derivatives of ns3::Object
 */
/** @{ */
/**
 * \tparam T \explicit The type of class object to create.
 * \return A Ptr to the newly created \c T.
 */
template <typename T>
Ptr<T> Create (void);

/**
 * \tparam T  \explicit The type of class object to create.
 * \tparam Ts \deduced Types of the constructor arguments.
 * \param  [in] args Constructor arguments.
 * \return A Ptr to the newly created \c T.
 */
template <typename T,
          typename... Ts>
Ptr<T> Create (Ts... args);

/**
 * \tparam T  \explicit The type of class object to create.
 * \tparam T1 \deduced The type of the first constructor argument.
 * \tparam T2 \deduced The type of the second constructor argument.
 * \param  [in] a1 The first constructor argument.
 * \param  [in] a2 The second constructor argument.
 * \return A Ptr to the newly created \c T.
 */
template <typename T,
          typename T1, typename T2>
Ptr<T> Create (T1 a1, T2 a2);

/**
 * \tparam T  \explicit The type of class object to create.
 * \tparam T1 \deduced The type of the first constructor argument.
 * \tparam T2 \deduced The type of the second constructor argument.
 * \tparam T3 \deduced The type of the third constructor argument.
 * \param  [in] a1 The first constructor argument.
 * \param  [in] a2 The second constructor argument.
 * \param  [in] a3 The third constructor argument.
 * \return A Ptr to the newly created \c T.
 */
template <typename T,
          typename T1, typename T2,
          typename T3>
Ptr<T> Create (T1 a1, T2 a2, T3 a3);

/**
 * \tparam T  \explicit The type of class object to create.
 * \tparam T1 \deduced The type of the first constructor argument.
 * \tparam T2 \deduced The type of the second constructor argument.
 * \tparam T3 \deduced The type of the third constructor argument.
 * \tparam T4 \deduced The type of the fourth constructor argument.
 * \param  [in] a1 The first constructor argument.
 * \param  [in] a2 The second constructor argument.
 * \param  [in] a3 The third constructor argument.
 * \param  [in] a4 The fourth constructor argument.
 * \return A Ptr to the newly created \c T.
 */
template <typename T,
          typename T1, typename T2,
          typename T3, typename T4>
Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4);

/**
 * \tparam T  \explicit The type of class object to create.
 * \tparam T1 \deduced The type of the first constructor argument.
 * \tparam T2 \deduced The type of the second constructor argument.
 * \tparam T3 \deduced The type of the third constructor argument.
 * \tparam T4 \deduced The type of the fourth constructor argument.
 * \tparam T5 \deduced The type of the fifth constructor argument.
 * \param  [in] a1 The first constructor argument.
 * \param  [in] a2 The second constructor argument.
 * \param  [in] a3 The third constructor argument.
 * \param  [in] a4 The fourth constructor argument.
 * \param  [in] a5 The fifth constructor argument.
 * \return A Ptr to the newly created \c T.
 */
template <typename T,
          typename T1, typename T2,
          typename T3, typename T4,
          typename T5>
Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);

/**
 * \tparam T  \explicit The type of class object to create.
 * \tparam T1 \deduced The type of the first constructor argument.
 * \tparam T2 \deduced The type of the second constructor argument.
 * \tparam T3 \deduced The type of the third constructor argument.
 * \tparam T4 \deduced The type of the fourth constructor argument.
 * \tparam T5 \deduced The type of the fifth constructor argument.
 * \tparam T6 \deduced The type of the sixth constructor argument.
 * \param  [in] a1 The first constructor argument.
 * \param  [in] a2 The second constructor argument.
 * \param  [in] a3 The third constructor argument.
 * \param  [in] a4 The fourth constructor argument.
 * \param  [in] a5 The fifth constructor argument.
 * \param  [in] a6 The sixth constructor argument.
 * \return A Ptr to the newly created \c T.
 */
template <typename T,
          typename T1, typename T2,
          typename T3, typename T4,
          typename T5, typename T6>
Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6);

/**
 * \tparam T  \explicit The type of class object to create.
 * \tparam T1 \deduced The type of the first constructor argument.
 * \tparam T2 \deduced The type of the second constructor argument.
 * \tparam T3 \deduced The type of the third constructor argument.
 * \tparam T4 \deduced The type of the fourth constructor argument.
 * \tparam T5 \deduced The type of the fifth constructor argument.
 * \tparam T6 \deduced The type of the sixth constructor argument.
 * \tparam T7 \deduced The type of the seventh constructor argument.
 * \param  [in] a1 The first constructor argument.
 * \param  [in] a2 The second constructor argument.
 * \param  [in] a3 The third constructor argument.
 * \param  [in] a4 The fourth constructor argument.
 * \param  [in] a5 The fifth constructor argument.
 * \param  [in] a6 The sixth constructor argument.
 * \param  [in] a7 The seventh constructor argument.
 * \return A Ptr to the newly created \c T.
 */
template <typename T,
          typename T1, typename T2,
          typename T3, typename T4,
          typename T5, typename T6,
          typename T7>
Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7);
/** @}*/

/**

 *  friend non-member function implementations
 ************************************************/

template <typename T, typename... Ts>
Ptr<T> Create (Ts... args)
{
  return Ptr<T> (new T (args...), false);
}

template <typename T, typename T1>
Ptr<T> Create (T1 a1)
{
  return Ptr<T> (new T (a1), false);
}

template <typename T, typename T1, typename T2>
Ptr<T> Create (T1 a1, T2 a2)
{
  return Ptr<T> (new T (a1, a2), false);
}

template <typename T, typename T1, typename T2, typename T3>
Ptr<T> Create (T1 a1, T2 a2, T3 a3)
{
  return Ptr<T> (new T (a1, a2, a3), false);
}

template <typename T, typename T1, typename T2, typename T3, typename T4>
Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4)
{
  return Ptr<T> (new T (a1, a2, a3, a4), false);
}

template <typename T, typename T1, typename T2, typename T3, typename T4, typename T5>
Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
{
  return Ptr<T> (new T (a1, a2, a3, a4, a5), false);
}

template <typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6)
{
  return Ptr<T> (new T (a1, a2, a3, a4, a5, a6), false);
}

template <typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
Ptr<T> Create (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7)
{
  return Ptr<T> (new T (a1, a2, a3, a4, a5, a6, a7), false);
}

template <typename U>

(-)a/src/core/model/realtime-simulator-impl.cc (-1 / +1 lines)

Lines 502-508	Link Here

502

RealtimeSimulatorImpl::Stop (Time const &delay)

502

RealtimeSimulatorImpl::Stop (Time const &delay)

503

504

  NS_LOG_FUNCTION (this << delay);

504

  NS_LOG_FUNCTION (this << delay);

505

  Simulator::Schedule (delay, &Simulator::Stop);

505

  Simulator::Schedule<void ()> (delay, &Simulator::Stop);

506

507

508

//

508

//




}


EventId
Simulator::Schedule (Time const &delay, void (*f)(void))
{
  return DoSchedule (delay, MakeEvent (f));
}

void
Simulator::ScheduleWithContext (uint32_t context, Time const &delay, void (*f)(void))
{
  return ScheduleWithContext (context, delay, MakeEvent (f));
}

EventId
Simulator::ScheduleNow (void (*f)(void))
{
  return DoScheduleNow (MakeEvent (f));
}

EventId
Simulator::ScheduleDestroy (void (*f)(void))
{
  return DoScheduleDestroy (MakeEvent (f));
}

void
Simulator::Remove (const EventId &id)
{




     */
    NO_CONTEXT = 0xffffffff
  };

  /**
   * @name Schedule events (in the same context) to run at a future time.
   */

   * for the current simulation time plus the @p delay  passed as a
   * parameter.
   *
   * @tparam Ts @deduced Argument types.
   * input method will be invoked on the input object.
   *
   * @tparam MEM @deduced Class method function signature type.
   * @tparam OBJ @deduced Class type of the object.
   * @param [in] delay The relative expiration time of the event.
   * @param [in] args Arguments to pass to MakeEvent.
   * @param [in] obj The object on which to invoke the member method
   * @returns The id for the scheduled event.
   */
  template <typename... Ts>
  static EventId Schedule (Time const &delay, Ts&&... args);

  /**
   *
   * @tparam MEM @deduced Class method function signature type.
   * @tparam OBJ @deduced Class type of the object.
   * @tparam T1 @deduced Type of first argument.
   * @param [in] delay The relative expiration time of the event.
   * @param [in] mem_ptr Member method pointer to invoke
   * @param [in] obj The object on which to invoke the member method
   * @param [in] a1 The first argument to pass to the invoked method
   * @returns The id for the scheduled event.
   */
  template <typename MEM, typename OBJ, typename T1>
  static EventId Schedule (Time const &delay, MEM mem_ptr, OBJ obj, T1 a1);

  /**
   * @see Schedule(const Time&,MEM,OBJ)
   * @tparam MEM @deduced Class method function signature type.
   * @tparam OBJ @deduced Class type of the object.
   * @tparam T1 @deduced Type of first argument.
   * @tparam T2 @deduced Type of second argument.
   * @param [in] delay The relative expiration time of the event.
   * @param [in] mem_ptr Member method pointer to invoke
   * @param [in] obj The object on which to invoke the member method
   * @param [in] a1 The first argument to pass to the invoked method
   * @param [in] a2 The second argument to pass to the invoked method
   * @returns The id for the scheduled event.
   */
  template <typename MEM, typename OBJ, typename T1, typename T2>
  static EventId Schedule (Time const &delay, MEM mem_ptr, OBJ obj, T1 a1, T2 a2);

  /**
   * @see Schedule(const Time&,MEM,OBJ)
   * @tparam MEM @deduced Class method function signature type.
   * @tparam OBJ @deduced Class type of the object.
   * @tparam T1 @deduced Type of first argument.
   * @tparam T2 @deduced Type of second argument.
   * @tparam T3 @deduced Type of third argument.
   * @param [in] delay The relative expiration time of the event.
   * @param [in] mem_ptr Member method pointer to invoke
   * @param [in] obj The object on which to invoke the member method
   * @param [in] a1 The first argument to pass to the invoked method
   * @param [in] a2 The second argument to pass to the invoked method
   * @param [in] a3 The third argument to pass to the invoked method
   * @returns The id for the scheduled event.
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2, typename T3>
  static EventId Schedule (Time const &delay, MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3);

  /**
   * @see Schedule(const Time&,MEM,OBJ)
   * @tparam MEM @deduced Class method function signature type.
   * @tparam OBJ @deduced Class type of the object.
   * @tparam T1 @deduced Type of first argument.
   * @tparam T2 @deduced Type of second argument.
   * @tparam T3 @deduced Type of third argument.
   * @tparam T4 @deduced Type of fourth argument.
   * @param [in] delay The relative expiration time of the event.
   * @param [in] mem_ptr Member method pointer to invoke
   * @param [in] obj The object on which to invoke the member method
   * @param [in] a1 The first argument to pass to the invoked method
   * @param [in] a2 The second argument to pass to the invoked method
   * @param [in] a3 The third argument to pass to the invoked method
   * @param [in] a4 The fourth argument to pass to the invoked method
   * @returns The id for the scheduled event.
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2, typename T3, typename T4>
  static EventId Schedule (Time const &delay, MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3, T4 a4);

  /**
   * @see Schedule(const Time&,MEM,OBJ)
   * @tparam MEM @deduced Class method function signature type.
   * @tparam OBJ @deduced Class type of the object.
   * @tparam T1 @deduced Type of first argument.
   * @tparam T2 @deduced Type of second argument.
   * @tparam T3 @deduced Type of third argument.
   * @tparam T4 @deduced Type of fourth argument.
   * @tparam T5 @deduced Type of fifth argument.
   * @param [in] delay The relative expiration time of the event.
   * @param [in] mem_ptr Member method pointer to invoke
   * @param [in] obj The object on which to invoke the member method
   * @param [in] a1 The first argument to pass to the invoked method
   * @param [in] a2 The second argument to pass to the invoked method
   * @param [in] a3 The third argument to pass to the invoked method
   * @param [in] a4 The fourth argument to pass to the invoked method
   * @param [in] a5 The fifth argument to pass to the invoked method
   * @returns The id for the scheduled event.
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2, typename T3, typename T4, typename T5>
  static EventId Schedule (Time const &delay, MEM mem_ptr, OBJ obj, 
                           T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);
  /**
   * Schedule an event to expire after @p delay.
   * This can be thought of as scheduling an event
   * for the current simulation time plus the @p delay  passed as a

   *
   * When the event expires (when it becomes due to be run), the
   * function will be invoked with any supplied arguments.
   *
   * @tparam Us @deduced Formal function argument types.
   * @tparam Ts @deduced Actual function argument types.
   * @param [in] delay The relative expiration time of the event.
   * @param [in] f The function to invoke.
   * @param [in] args Arguments to pass to the invoked function.
   * @returns The id for the scheduled event.
   */
  template <typename... Us, typename... Ts>
  static EventId Schedule (Time const &delay, void (*f)(Us...), Ts&&... args);
  /**
   * @see Schedule(const Time&,(*)())
   * @tparam U1 @deduced Formal type of the first argument to the function.
   * @tparam T1 @deduced Actual type of the first argument.
   * @param [in] delay The relative expiration time of the event.
   * @param [in] f The function to invoke
   * @param [in] a1 The first argument to pass to the function to invoke.
   * @returns The id for the scheduled event.
   */
  template <typename U1, typename T1>
  static EventId Schedule (Time const &delay, void (*f)(U1), T1 a1);

  /**
   * @see Schedule(const Time&,(*)())
   * @tparam U1 @deduced Formal type of the first argument to the function.
   * @tparam U2 @deduced Formal type of the second argument to the function.
   * @tparam T1 @deduced Actual type of the first argument.
   * @tparam T2 @deduced Actual type of the second argument.
   * @param [in] delay The relative expiration time of the event.
   * @param [in] f The function to invoke
   * @param [in] a1 The first argument to pass to the function to invoke
   * @param [in] a2 The second argument to pass to the function to invoke
   * @returns The id for the scheduled event.
   */
  template <typename U1, typename U2,
            typename T1, typename T2>
  static EventId Schedule (Time const &delay, void (*f)(U1,U2), T1 a1, T2 a2);

  /**
   * @see Schedule(const Time&,void(*)())
   * @tparam U1 @deduced Formal type of the first argument to the function.
   * @tparam U2 @deduced Formal type of the second argument to the function.
   * @tparam U3 @deduced Formal type of the third argument to the function.
   * @tparam T1 @deduced Actual type of the first argument.
   * @tparam T2 @deduced Actual type of the second argument.
   * @tparam T3 @deduced Actual type of the third argument.
   * @param [in] delay The relative expiration time of the event.
   * @param [in] f The function to invoke
   * @param [in] a1 The first argument to pass to the function to invoke
   * @param [in] a2 The second argument to pass to the function to invoke
   * @param [in] a3 The third argument to pass to the function to invoke
   * @returns The id for the scheduled event.
   */
  template <typename U1, typename U2, typename U3,
            typename T1, typename T2, typename T3>
  static EventId Schedule (Time const &delay, void (*f)(U1,U2,U3), T1 a1, T2 a2, T3 a3);

  /**
   * @see Schedule(const Time&,(*)(void))
   * @tparam U1 @deduced Formal type of the first argument to the function.
   * @tparam U2 @deduced Formal type of the second argument to the function.
   * @tparam U3 @deduced Formal type of the third argument to the function.
   * @tparam U4 @deduced Formal type of the fourth argument to the function.
   * @tparam T1 @deduced Actual type of the first argument.
   * @tparam T2 @deduced Actual type of the second argument.
   * @tparam T3 @deduced Actual type of the third argument.
   * @tparam T4 @deduced Actual type of the fourth argument.
   * @param [in] delay The relative expiration time of the event.
   * @param [in] f The function to invoke
   * @param [in] a1 The first argument to pass to the function to invoke
   * @param [in] a2 The second argument to pass to the function to invoke
   * @param [in] a3 The third argument to pass to the function to invoke
   * @param [in] a4 The fourth argument to pass to the function to invoke
   * @returns The id for the scheduled event.
   */
  template <typename U1, typename U2, typename U3, typename U4, 
            typename T1, typename T2, typename T3, typename T4>
  static EventId Schedule (Time const &delay, void (*f)(U1,U2,U3,U4), T1 a1, T2 a2, T3 a3, T4 a4);

  /**
   * @see Schedule(const Time&,void(*)(void))
   * @tparam U1 @deduced Formal type of the first argument to the function.
   * @tparam U2 @deduced Formal type of the second argument to the function.
   * @tparam U3 @deduced Formal type of the third argument to the function.
   * @tparam U4 @deduced Formal type of the fourth argument to the function.
   * @tparam U5 @deduced Formal type of the fifth argument to the function.
   * @tparam T1 @deduced Actual type of the first argument.
   * @tparam T2 @deduced Actual type of the second argument.
   * @tparam T3 @deduced Actual type of the third argument.
   * @tparam T4 @deduced Actual type of the fourth argument.
   * @tparam T5 @deduced Actual type of the fifth argument.
   * @param [in] delay The relative expiration time of the event.
   * @param [in] f The function to invoke
   * @param [in] a1 The first argument to pass to the function to invoke
   * @param [in] a2 The second argument to pass to the function to invoke
   * @param [in] a3 The third argument to pass to the function to invoke
   * @param [in] a4 The fourth argument to pass to the function to invoke
   * @param [in] a5 The fifth argument to pass to the function to invoke
   * @returns The id for the scheduled event.
   */
  template <typename U1, typename U2, typename U3, typename U4, typename U5,
            typename T1, typename T2, typename T3, typename T4, typename T5>
  static EventId Schedule (Time const &delay, void (*f)(U1,U2,U3,U4,U5), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);

  /** @} */

  /**

   * A context of 0xffffffff means no context is specified.
   * This method is thread-safe: it can be called from any thread.
   *
   * @tparam Ts @deduced Argument types.
   * @tparam MEM @deduced Class method function signature type.
   * @tparam OBJ @deduced Class type of the object.
   * @param [in] context User-specified context parameter
   * @param [in] delay The relative expiration time of the event.
   * @param [in] args Arguments to pass to MakeEvent.
   * @param [in] obj The object on which to invoke the member method
   */
  template <typename... Ts>
  static void ScheduleWithContext (uint32_t context, Time const &delay, Ts&&... args);

  /**
   * @see ScheduleWithContext(uint32_t,const Time&,MEM,OBJ)
   * @tparam MEM @deduced Class method function signature type.
   * @tparam OBJ @deduced Class type of the object.
   * @tparam T1 @deduced Type of first argument.
   * @param [in] context User-specified context parameter
   * @param [in] delay The relative expiration time of the event.
   * @param [in] mem_ptr Member method pointer to invoke
   * @param [in] obj The object on which to invoke the member method
   * @param [in] a1 The first argument to pass to the invoked method
   */
  template <typename MEM, typename OBJ, typename T1>
  static void ScheduleWithContext (uint32_t context, Time const &delay, MEM mem_ptr, OBJ obj, T1 a1);

  /**
   * @see ScheduleWithContext(uint32_t,const Time&,MEM,OBJ)
   * @tparam MEM @deduced Class method function signature type.
   * @tparam OBJ @deduced Class type of the object.
   * @tparam T1 @deduced Type of first argument.
   * @tparam T2 @deduced Type of second argument.
   * @param [in] context User-specified context parameter
   * @param [in] delay The relative expiration time of the event.
   * @param [in] mem_ptr Member method pointer to invoke
   * @param [in] obj The object on which to invoke the member method
   * @param [in] a1 The first argument to pass to the invoked method
   * @param [in] a2 The second argument to pass to the invoked method
   */
  template <typename MEM, typename OBJ, typename T1, typename T2>
  static void ScheduleWithContext (uint32_t context, Time const &delay, MEM mem_ptr, OBJ obj, T1 a1, T2 a2);

  /**
   * @see ScheduleWithContext(uint32_t,const Time&,MEM,OBJ)
   * @tparam MEM @deduced Class method function signature type.
   * @tparam OBJ @deduced Class type of the object.
   * @tparam T1 @deduced Type of first argument.
   * @tparam T2 @deduced Type of second argument.
   * @tparam T3 @deduced Type of third argument.
   * @param [in] context User-specified context parameter
   * @param [in] delay The relative expiration time of the event.
   * @param [in] mem_ptr Member method pointer to invoke
   * @param [in] obj The object on which to invoke the member method
   * @param [in] a1 The first argument to pass to the invoked method
   * @param [in] a2 The second argument to pass to the invoked method
   * @param [in] a3 The third argument to pass to the invoked method
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2, typename T3>
  static void ScheduleWithContext (uint32_t context, Time const &delay, MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3);

  /**
   * @see ScheduleWithContext(uint32_t,const Time&,MEM,OBJ)
   * @tparam MEM @deduced Class method function signature type.
   * @tparam OBJ @deduced Class type of the object.
   * @tparam T1 @deduced Type of first argument.
   * @tparam T2 @deduced Type of second argument.
   * @tparam T3 @deduced Type of third argument.
   * @tparam T4 @deduced Type of fourth argument.
   * @param [in] context User-specified context parameter
   * @param [in] delay The relative expiration time of the event.
   * @param [in] mem_ptr Member method pointer to invoke
   * @param [in] obj The object on which to invoke the member method
   * @param [in] a1 The first argument to pass to the invoked method
   * @param [in] a2 The second argument to pass to the invoked method
   * @param [in] a3 The third argument to pass to the invoked method
   * @param [in] a4 The fourth argument to pass to the invoked method
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2, typename T3, typename T4>
  static void ScheduleWithContext (uint32_t context, Time const &delay, MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3, T4 a4);

  /**
   * @see ScheduleWithContext(uint32_t,const Time&,MEM,OBJ)
   * @tparam MEM @deduced Class method function signature type.
   * @tparam OBJ @deduced Class type of the object.
   * @tparam T1 @deduced Type of first argument.
   * @tparam T2 @deduced Type of second argument.
   * @tparam T3 @deduced Type of third argument.
   * @tparam T4 @deduced Type of fourth argument.
   * @tparam T5 @deduced Type of fifth argument.
   * @param [in] context User-specified context parameter
   * @param [in] delay The relative expiration time of the event.
   * @param [in] mem_ptr Member method pointer to invoke
   * @param [in] obj The object on which to invoke the member method
   * @param [in] a1 The first argument to pass to the invoked method
   * @param [in] a2 The second argument to pass to the invoked method
   * @param [in] a3 The third argument to pass to the invoked method
   * @param [in] a4 The fourth argument to pass to the invoked method
   * @param [in] a5 The fifth argument to pass to the invoked method
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2, typename T3, typename T4, typename T5>
  static void ScheduleWithContext (uint32_t context, Time const &delay, MEM mem_ptr, OBJ obj, 
                                   T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);
  /**
   * Schedule an event with the given context.
   * A context of 0xffffffff means no context is specified.
   * This method is thread-safe: it can be called from any thread.
   *
   * @tparam Us @deduced Formal function argument types.
   * @tparam Ts @deduced Actual function argument types.
   *
   * This method is thread-safe: it can be called from any thread.
   * @param [in] context User-specified context parameter
   * @param [in] delay The relative expiration time of the event.
   * @param [in] f The function to invoke.
   * @param [in] args Arguments to pass to the invoked function.
   */
  template <typename... Us, typename... Ts>
  static void ScheduleWithContext (uint32_t context, Time const &delay, void (*f)(Us...), Ts&&... args);
  /** @} */

  /**
   * @see ScheduleWithContext(uint32_t,const Time&,(*)())
   * @tparam U1 @deduced Formal type of the first argument to the function.
   * @tparam T1 @deduced Actual type of the first argument.
   * @param [in] context User-specified context parameter
   * @param [in] delay The relative expiration time of the event.
   * @param [in] f The function to invoke
   * @param [in] a1 The first argument to pass to the function to invoke
   */
  template <typename U1,
            typename T1>
  static void ScheduleWithContext (uint32_t context, Time const &delay, void (*f)(U1), T1 a1);

  /**
   * @see ScheduleWithContext(uint32_t,const Time&,(*)())
   * @tparam U1 @deduced Formal type of the first argument to the function.
   * @tparam U2 @deduced Formal type of the second argument to the function.
   * @tparam T1 @deduced Actual type of the first argument.
   * @tparam T2 @deduced Actual type of the second argument.
   * @param [in] context User-specified context parameter
   * @param [in] delay The relative expiration time of the event.
   * @param [in] f The function to invoke
   * @param [in] a1 The first argument to pass to the function to invoke
   * @param [in] a2 The second argument to pass to the function to invoke
   */
  template <typename U1, typename U2,
            typename T1, typename T2>
  static void ScheduleWithContext (uint32_t context, Time const &delay, void (*f)(U1,U2), T1 a1, T2 a2);

  /**
   * @see ScheduleWithContext(uint32_t,const Time&,(*)())
   * @tparam U1 @deduced Formal type of the first argument to the function.
   * @tparam U2 @deduced Formal type of the second argument to the function.
   * @tparam U3 @deduced Formal type of the third argument to the function.
   * @tparam T1 @deduced Actual type of the first argument.
   * @tparam T2 @deduced Actual type of the second argument.
   * @tparam T3 @deduced Actual type of the third argument.
   * @param [in] context User-specified context parameter
   * @param [in] delay The relative expiration time of the event.
   * @param [in] f The function to invoke
   * @param [in] a1 The first argument to pass to the function to invoke
   * @param [in] a2 The second argument to pass to the function to invoke
   * @param [in] a3 The third argument to pass to the function to invoke
   */
  template <typename U1, typename U2, typename U3,
            typename T1, typename T2, typename T3>
  static void ScheduleWithContext (uint32_t context, Time const &delay, void (*f)(U1,U2,U3), T1 a1, T2 a2, T3 a3);

  /**
   * @see ScheduleWithContext(uint32_t,const Time&,(*)())
   * @tparam U1 @deduced Formal type of the first argument to the function.
   * @tparam U2 @deduced Formal type of the second argument to the function.
   * @tparam U3 @deduced Formal type of the third argument to the function.
   * @tparam U4 @deduced Formal type of the fourth argument to the function.
   * @tparam T1 @deduced Actual type of the first argument.
   * @tparam T2 @deduced Actual type of the second argument.
   * @tparam T3 @deduced Actual type of the third argument.
   * @tparam T4 @deduced Actual type of the fourth argument.
   * @param [in] context User-specified context parameter
   * @param [in] delay The relative expiration time of the event.
   * @param [in] f The function to invoke
   * @param [in] a1 The first argument to pass to the function to invoke
   * @param [in] a2 The second argument to pass to the function to invoke
   * @param [in] a3 The third argument to pass to the function to invoke
   * @param [in] a4 The fourth argument to pass to the function to invoke
   */
  template <typename U1, typename U2, typename U3, typename U4, 
            typename T1, typename T2, typename T3, typename T4>
  static void ScheduleWithContext (uint32_t context, Time const &delay, void (*f)(U1,U2,U3,U4), T1 a1, T2 a2, T3 a3, T4 a4);

  /**
   * @see ScheduleWithContext(uint32_t,const Time&,(*)())
   * @tparam U1 @deduced Formal type of the first argument to the function.
   * @tparam U2 @deduced Formal type of the second argument to the function.
   * @tparam U3 @deduced Formal type of the third argument to the function.
   * @tparam U4 @deduced Formal type of the fourth argument to the function.
   * @tparam U5 @deduced Formal type of the fifth argument to the function.
   * @tparam T1 @deduced Actual type of the first argument.
   * @tparam T2 @deduced Actual type of the second argument.
   * @tparam T3 @deduced Actual type of the third argument.
   * @tparam T4 @deduced Actual type of the fourth argument.
   * @tparam T5 @deduced Actual type of the fifth argument.
   * @param [in] context User-specified context parameter
   * @param [in] delay The relative expiration time of the event.
   * @param [in] f The function to invoke
   * @param [in] a1 The first argument to pass to the function to invoke
   * @param [in] a2 The second argument to pass to the function to invoke
   * @param [in] a3 The third argument to pass to the function to invoke
   * @param [in] a4 The fourth argument to pass to the function to invoke
   * @param [in] a5 The fifth argument to pass to the function to invoke
   */
  template <typename U1, typename U2, typename U3, typename U4, typename U5,
            typename T1, typename T2, typename T3, typename T4, typename T5>
  static void ScheduleWithContext (uint32_t context, Time const &delay, void (*f)(U1,U2,U3,U4,U5), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);

  /** @} */
  
  /**
   * @name Schedule events (in the same context) to run now.
   */
  /** @{ */
  /**
   * Schedule an event to expire Now. All events scheduled to
   * to expire "Now" are scheduled FIFO, after all normal events
   * have expired.
   *
   * @tparam Ts @deduced Actual function argument types.
   * @param [in] args Arguments to pass to the invoked function.
   * @param [in] mem_ptr Member method pointer to invoke
   * @param [in] obj The object on which to invoke the member method
   * @return The EventId of the scheduled event.
   */
  template <typename... Ts>
  static EventId ScheduleNow (Ts&&... args);

  /**
   * Schedule an event to expire Now. All events scheduled to
   * to expire "Now" are scheduled FIFO, after all normal events
   * have expired.
   *
   * @tparam Us @deduced Formal function argument types.
   * @tparam Ts @deduced Actual function argument types.
   * @param [in] f The function to invoke.
   * @param [in] args Arguments to pass to MakeEvent.
   * @return The EventId of the scheduled event.
   */
  template <typename... Us, typename... Ts>
  static EventId ScheduleNow (void (*f)(Us...), Ts&&... args);
  static EventId ScheduleNow (MEM mem_ptr, OBJ obj, T1 a1);

  /**
   * @see ScheduleNow(MEM,OBJ)
   * @tparam MEM @deduced Class method function signature type.
   * @tparam OBJ @deduced Class type of the object.
   * @tparam T1 @deduced Type of first argument.
   * @tparam T2 @deduced Type of second argument.
   * @param [in] mem_ptr Member method pointer to invoke
   * @param [in] obj The object on which to invoke the member method
   * @param [in] a1 The first argument to pass to the invoked method
   * @param [in] a2 The second argument to pass to the invoked method
   * @return The EventId of the scheduled event.
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2>
  static EventId ScheduleNow (MEM mem_ptr, OBJ obj, T1 a1, T2 a2);

  /**
   * @see ScheduleNow(MEM,OBJ)
   * @tparam MEM @deduced Class method function signature type.
   * @tparam OBJ @deduced Class type of the object.
   * @tparam T1 @deduced Type of first argument.
   * @tparam T2 @deduced Type of second argument.
   * @tparam T3 @deduced Type of third argument.
   * @param [in] mem_ptr Member method pointer to invoke
   * @param [in] obj The object on which to invoke the member method
   * @param [in] a1 The first argument to pass to the invoked method
   * @param [in] a2 The second argument to pass to the invoked method
   * @param [in] a3 The third argument to pass to the invoked method
   * @return The EventId of the scheduled event.
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2, typename T3>
  static EventId ScheduleNow (MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3);

  /**
   * @see ScheduleNow(MEM,OBJ)
   * @tparam MEM @deduced Class method function signature type.
   * @tparam OBJ @deduced Class type of the object.
   * @tparam T1 @deduced Type of first argument.
   * @tparam T2 @deduced Type of second argument.
   * @tparam T3 @deduced Type of third argument.
   * @tparam T4 @deduced Type of fourth argument.
   * @param [in] mem_ptr Member method pointer to invoke
   * @param [in] obj The object on which to invoke the member method
   * @param [in] a1 The first argument to pass to the invoked method
   * @param [in] a2 The second argument to pass to the invoked method
   * @param [in] a3 The third argument to pass to the invoked method
   * @param [in] a4 The fourth argument to pass to the invoked method
   * @return The EventId of the scheduled event.
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2, typename T3, typename T4>
  static EventId ScheduleNow (MEM mem_ptr, OBJ obj, 
                              T1 a1, T2 a2, T3 a3, T4 a4);
  /**
   * @see ScheduleNow(MEM,OBJ)
   * @tparam MEM @deduced Class method function signature type.
   * @tparam OBJ @deduced Class type of the object.
   * @tparam T1 @deduced Type of first argument.
   * @tparam T2 @deduced Type of second argument.
   * @tparam T3 @deduced Type of third argument.
   * @tparam T4 @deduced Type of fourth argument.
   * @tparam T5 @deduced Type of fifth argument.
   * @param [in] mem_ptr Member method pointer to invoke
   * @param [in] obj The object on which to invoke the member method
   * @param [in] a1 The first argument to pass to the invoked method
   * @param [in] a2 The second argument to pass to the invoked method
   * @param [in] a3 The third argument to pass to the invoked method
   * @param [in] a4 The fourth argument to pass to the invoked method
   * @param [in] a5 The fifth argument to pass to the invoked method
   * @return The EventId of the scheduled event.
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2, typename T3, typename T4, typename T5>
  static EventId ScheduleNow (MEM mem_ptr, OBJ obj, 
                              T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);
  /**
   * @copybrief ScheduleNow(MEM,OBJ)
   *
   * When the event expires (when it becomes due to be run), the
   * function will be invoked with any supplied arguments.
   * @param [in] f The function to invoke
   * @return The EventId of the scheduled event.
   */
  static EventId ScheduleNow (void (*f)(void));

  /**
   * @see ScheduleNow(*)
   * @tparam U1 @deduced Formal type of the first argument to the function.
   * @tparam T1 @deduced Actual type of the first argument.
   * @param [in] f The function to invoke
   * @param [in] a1 The first argument to pass to the function to invoke
   * @return The EventId of the scheduled event.
   */
  template <typename U1,
            typename T1>
  static EventId ScheduleNow (void (*f)(U1), T1 a1);

  /**
   * @see ScheduleNow(*)
   * @tparam U1 @deduced Formal type of the first argument to the function.
   * @tparam U2 @deduced Formal type of the second argument to the function.
   * @tparam T1 @deduced Actual type of the first argument.
   * @tparam T2 @deduced Actual type of the second argument.
   * @param [in] f The function to invoke
   * @param [in] a1 The first argument to pass to the function to invoke
   * @param [in] a2 The second argument to pass to the function to invoke
   * @return The EventId of the scheduled event.
   */
  template <typename U1, typename U2,
            typename T1, typename T2>
  static EventId ScheduleNow (void (*f)(U1,U2), T1 a1, T2 a2);

  /**
   * @see ScheduleNow(*)
   * @tparam U1 @deduced Formal type of the first argument to the function.
   * @tparam U2 @deduced Formal type of the second argument to the function.
   * @tparam U3 @deduced Formal type of the third argument to the function.
   * @tparam T1 @deduced Actual type of the first argument.
   * @tparam T2 @deduced Actual type of the second argument.
   * @tparam T3 @deduced Actual type of the third argument.
   * @param [in] f The function to invoke
   * @param [in] a1 The first argument to pass to the function to invoke
   * @param [in] a2 The second argument to pass to the function to invoke
   * @param [in] a3 The third argument to pass to the function to invoke
   * @return The EventId of the scheduled event.
   */
  template <typename U1, typename U2, typename U3,
            typename T1, typename T2, typename T3>
  static EventId ScheduleNow (void (*f)(U1,U2,U3), T1 a1, T2 a2, T3 a3);

  /**
   * @see ScheduleNow(*)
   * @tparam U1 @deduced Formal type of the first argument to the function.
   * @tparam U2 @deduced Formal type of the second argument to the function.
   * @tparam U3 @deduced Formal type of the third argument to the function.
   * @tparam U4 @deduced Formal type of the fourth argument to the function.
   * @tparam T1 @deduced Actual type of the first argument.
   * @tparam T2 @deduced Actual type of the second argument.
   * @tparam T3 @deduced Actual type of the third argument.
   * @tparam T4 @deduced Actual type of the fourth argument.
   * @param [in] f The function to invoke
   * @param [in] a1 The first argument to pass to the function to invoke
   * @param [in] a2 The second argument to pass to the function to invoke
   * @param [in] a3 The third argument to pass to the function to invoke
   * @param [in] a4 The fourth argument to pass to the function to invoke
   * @return The EventId of the scheduled event.
   */
  template <typename U1, typename U2, typename U3, typename U4,
            typename T1, typename T2, typename T3, typename T4>
  static EventId ScheduleNow (void (*f)(U1,U2,U3,U4), T1 a1, T2 a2, T3 a3, T4 a4);

  /**
   * @see ScheduleNow(*)
   * @tparam U1 @deduced Formal type of the first argument to the function.
   * @tparam U2 @deduced Formal type of the second argument to the function.
   * @tparam U3 @deduced Formal type of the third argument to the function.
   * @tparam U4 @deduced Formal type of the fourth argument to the function.
   * @tparam U5 @deduced Formal type of the fifth argument to the function.
   * @tparam T1 @deduced Actual type of the first argument.
   * @tparam T2 @deduced Actual type of the second argument.
   * @tparam T3 @deduced Actual type of the third argument.
   * @tparam T4 @deduced Actual type of the fourth argument.
   * @tparam T5 @deduced Actual type of the fifth argument.
   * @param [in] f The function to invoke
   * @param [in] a1 The first argument to pass to the function to invoke
   * @param [in] a2 The second argument to pass to the function to invoke
   * @param [in] a3 The third argument to pass to the function to invoke
   * @param [in] a4 The fourth argument to pass to the function to invoke
   * @param [in] a5 The fifth argument to pass to the function to invoke
   * @return The EventId of the scheduled event.
   */
  template <typename U1, typename U2, typename U3, typename U4, typename U5,
            typename T1, typename T2, typename T3, typename T4, typename T5>
  static EventId ScheduleNow (void (*f)(U1,U2,U3,U4,U5), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);

  /** @} */

  /**

   */
  /** @{ */
  /**
   * Schedule an event to run at the end of the simulation, when Simulator::Destroy() is called.
   * All events scheduled to expire at "Destroy" time are scheduled FIFO,
   * after all normal events have expired and only when
   * Simulator::Destroy is invoked.
   *
   * @tparam Us @deduced Formal function argument types.
   * @tparam Ts @deduced Actual function argument types.
   * @param [in] args Arguments to pass to MakeEvent.
   * @param [in] obj The object on which to invoke the member method
   * @return The EventId of the scheduled event.
   */
  template <typename... Ts>
  static EventId ScheduleDestroy (Ts&&... args);

  /**
   * Schedule an event to run at the end of the simulation, when Simulator::Destroy() is called.
   * All events scheduled to expire at "Destroy" time are scheduled FIFO,
   * after all normal events have expired and only when
   * Simulator::Destroy is invoked.
   *
   * @tparam Us @deduced Formal function argument types.
   * @tparam Ts @deduced Actual function argument types.
   * @param [in] f The function to invoke.
   * @param [in] args Arguments to pass to MakeEvent.
   * @return The EventId of the scheduled event.
   */
  template <typename... Us, typename... Ts>
  static EventId ScheduleDestroy (void (*f)(Us...), Ts&&... args);
  static EventId ScheduleDestroy (MEM mem_ptr, OBJ obj, T1 a1);

  /**
   * @see ScheduleDestroy(MEM,OBJ)
   * @tparam MEM @deduced Class method function signature type.
   * @tparam OBJ @deduced Class type of the object.
   * @tparam T1 @deduced Type of first argument.
   * @tparam T2 @deduced Type of second argument.
   * @param [in] mem_ptr Member method pointer to invoke
   * @param [in] obj The object on which to invoke the member method
   * @param [in] a1 The first argument to pass to the invoked method
   * @param [in] a2 The second argument to pass to the invoked method
   * @return The EventId of the scheduled event.
   */
  template <typename MEM, typename OBJ,
            typename T1, typename T2>
  static EventId ScheduleDestroy (MEM mem_ptr, OBJ obj, T1 a1, T2 a2);

  /**
   * @see ScheduleDestroy(MEM,OBJ)
   * @tparam MEM @deduced Class method function signature type.
   * @tparam OBJ @deduced Class type of the object.
   * @tparam T1 @deduced Type of first argument.
   * @tparam T2 @deduced Type of second argument.
   * @tparam T3 @deduced Type of third argument.
   * @param [in] mem_ptr Member method pointer to invoke
   * @param [in] obj The object on which to invoke the member method
   * @param [in] a1 The first argument to pass to the invoked method
   * @param [in] a2 The second argument to pass to the invoked method
   * @param [in] a3 The third argument to pass to the invoked method
   * @return The EventId of the scheduled event.
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2, typename T3>
  static EventId ScheduleDestroy (MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3);

  /**
   * @see ScheduleDestroy(MEM,OBJ)
   * @tparam MEM @deduced Class method function signature type.
   * @tparam OBJ @deduced Class type of the object.
   * @tparam T1 @deduced Type of first argument.
   * @tparam T2 @deduced Type of second argument.
   * @tparam T3 @deduced Type of third argument.
   * @tparam T4 @deduced Type of fourth argument.
   * @param [in] mem_ptr Member method pointer to invoke
   * @param [in] obj The object on which to invoke the member method
   * @param [in] a1 The first argument to pass to the invoked method
   * @param [in] a2 The second argument to pass to the invoked method
   * @param [in] a3 The third argument to pass to the invoked method
   * @param [in] a4 The fourth argument to pass to the invoked method
   * @return The EventId of the scheduled event.
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2, typename T3, typename T4>
  static EventId ScheduleDestroy (MEM mem_ptr, OBJ obj, 
                                  T1 a1, T2 a2, T3 a3, T4 a4);
  /**
   * @see ScheduleDestroy(MEM,OBJ)
   * @tparam MEM @deduced Class method function signature type.
   * @tparam OBJ @deduced Class type of the object.
   * @tparam T1 @deduced Type of first argument.
   * @tparam T2 @deduced Type of second argument.
   * @tparam T3 @deduced Type of third argument.
   * @tparam T4 @deduced Type of fourth argument.
   * @tparam T5 @deduced Type of fifth argument.
   * @param [in] mem_ptr Member method pointer to invoke
   * @param [in] obj The object on which to invoke the member method
   * @param [in] a1 The first argument to pass to the invoked method
   * @param [in] a2 The second argument to pass to the invoked method
   * @param [in] a3 The third argument to pass to the invoked method
   * @param [in] a4 The fourth argument to pass to the invoked method
   * @param [in] a5 The fifth argument to pass to the invoked method
   * @return The EventId of the scheduled event.
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2, typename T3, typename T4, typename T5>
  static EventId ScheduleDestroy (MEM mem_ptr, OBJ obj, 
                                  T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);
  /**
   * @copybrief ScheduleDestroy(MEM,OBJ)
   * When Simulator::Destroy() is called, the
   * function will be invoked with any supplied arguments.
   * @param [in] f The function to invoke
   * @return The EventId of the scheduled event.
   */
  static EventId ScheduleDestroy (void (*f)(void));

  /**
   * @see ScheduleDestory((*)())
   * @tparam U1 @deduced Formal type of the first argument to the function.
   * @tparam T1 @deduced Actual type of the first argument.
   * @param [in] f The function to invoke
   * @param [in] a1 The first argument to pass to the function to invoke
   * @return The EventId of the scheduled event.
   */
  template <typename U1,
            typename T1>
  static EventId ScheduleDestroy (void (*f)(U1), T1 a1);

  /**
   * @see ScheduleDestory((*)())
   * @tparam U1 @deduced Formal type of the first argument to the function.
   * @tparam U2 @deduced Formal type of the second argument to the function.
   * @tparam T1 @deduced Actual type of the first argument.
   * @tparam T2 @deduced Actual type of the second argument.
   * @param [in] f The function to invoke
   * @param [in] a1 The first argument to pass to the function to invoke
   * @param [in] a2 The second argument to pass to the function to invoke
   * @return The EventId of the scheduled event.
   */
  template <typename U1, typename U2,
            typename T1, typename T2>
  static EventId ScheduleDestroy (void (*f)(U1,U2), T1 a1, T2 a2);

  /**
   * @see ScheduleDestory((*)())
   * @tparam U1 @deduced Formal type of the first argument to the function.
   * @tparam U2 @deduced Formal type of the second argument to the function.
   * @tparam U3 @deduced Formal type of the third argument to the function.
   * @tparam T1 @deduced Actual type of the first argument.
   * @tparam T2 @deduced Actual type of the second argument.
   * @tparam T3 @deduced Actual type of the third argument.
   * @param [in] f The function to invoke
   * @param [in] a1 The first argument to pass to the function to invoke
   * @param [in] a2 The second argument to pass to the function to invoke
   * @param [in] a3 The third argument to pass to the function to invoke
   * @return The EventId of the scheduled event.
   */
  template <typename U1, typename U2, typename U3,
            typename T1, typename T2, typename T3>
  static EventId ScheduleDestroy (void (*f)(U1,U2,U3), T1 a1, T2 a2, T3 a3);

  /**
   * @see ScheduleDestory((*)())
   * @tparam U1 @deduced Formal type of the first argument to the function.
   * @tparam U2 @deduced Formal type of the second argument to the function.
   * @tparam U3 @deduced Formal type of the third argument to the function.
   * @tparam U4 @deduced Formal type of the fourth argument to the function.
   * @tparam T1 @deduced Actual type of the first argument.
   * @tparam T2 @deduced Actual type of the second argument.
   * @tparam T3 @deduced Actual type of the third argument.
   * @tparam T4 @deduced Actual type of the fourth argument.
   * @param [in] f The function to invoke
   * @param [in] a1 The first argument to pass to the function to invoke
   * @param [in] a2 The second argument to pass to the function to invoke
   * @param [in] a3 The third argument to pass to the function to invoke
   * @param [in] a4 The fourth argument to pass to the function to invoke
   * @return The EventId of the scheduled event.
   */
  template <typename U1, typename U2, typename U3, typename U4,
            typename T1, typename T2, typename T3, typename T4>
  static EventId ScheduleDestroy (void (*f)(U1,U2,U3,U4), T1 a1, T2 a2, T3 a3, T4 a4);

  /**
   * @see ScheduleDestory((*)())
   * @tparam U1 @deduced Formal type of the first argument to the function.
   * @tparam U2 @deduced Formal type of the second argument to the function.
   * @tparam U3 @deduced Formal type of the third argument to the function.
   * @tparam U4 @deduced Formal type of the fourth argument to the function.
   * @tparam U5 @deduced Formal type of the fifth argument to the function.
   * @tparam T1 @deduced Actual type of the first argument.
   * @tparam T2 @deduced Actual type of the second argument.
   * @tparam T3 @deduced Actual type of the third argument.
   * @tparam T4 @deduced Actual type of the fourth argument.
   * @tparam T5 @deduced Actual type of the fifth argument.
   * @param [in] f The function to invoke
   * @param [in] a1 The first argument to pass to the function to invoke
   * @param [in] a2 The second argument to pass to the function to invoke
   * @param [in] a3 The third argument to pass to the function to invoke
   * @param [in] a4 The fourth argument to pass to the function to invoke
   * @param [in] a5 The fifth argument to pass to the function to invoke
   * @return The EventId of the scheduled event.
   */
  template <typename U1, typename U2, typename U3, typename U4, typename U5,
            typename T1, typename T2, typename T3, typename T4, typename T5>
  static EventId ScheduleDestroy (void (*f)(U1,U2,U3,U4,U5), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);

  /** @} */

  /**


namespace ns3 {

template <typename... Ts>
EventId Simulator::Schedule (Time const &delay, Ts&&... args)
{
  return DoSchedule (delay, MakeEvent (std::forward<Ts> (args)...));
}

template <typename... Us, typename... Ts>
EventId Simulator::Schedule (Time const &delay, void (*f)(Us...), Ts&&... args)
          typename T1>
EventId Simulator::Schedule (Time const &delay, MEM mem_ptr, OBJ obj, T1 a1) 
{
  return DoSchedule (delay, MakeEvent (f, std::forward<Ts> (args)...));
}

template <typename... Ts>
void Simulator::ScheduleWithContext (uint32_t context, Time const &delay, Ts&&... args)
EventId Simulator::Schedule (Time const &delay, MEM mem_ptr, OBJ obj, T1 a1, T2 a2)
{
  return ScheduleWithContext (context, delay, MakeEvent (std::forward<Ts> (args)...));
}

template <typename... Us, typename... Ts>
void Simulator::ScheduleWithContext (uint32_t context, Time const &delay, void (*f)(Us...), Ts&&... args)
EventId Simulator::Schedule (Time const &delay, MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3) 
{
  return ScheduleWithContext (context, delay, MakeEvent (f, std::forward<Ts> (args)...));
}

template <typename... Ts>
EventId
Simulator::ScheduleNow (Ts&&... args)
{
  return DoScheduleNow (MakeEvent (std::forward<Ts> (args)...));
}

template <typename... Us, typename... Ts>
EventId
Simulator::ScheduleNow (void (*f)(Us...), Ts&&... args)
                             T1 a1, T2 a2, T3 a3, T4 a4, T5 a5) 
{
  return DoScheduleNow (MakeEvent (f, std::forward<Ts> (args)...));
}

template <typename... Ts>
EventId
Simulator::ScheduleDestroy (Ts&&... args)
{
  return DoScheduleDestroy (MakeEvent (std::forward<Ts> (args)...));
}

template <typename... Us, typename... Ts>
EventId
Simulator::ScheduleDestroy (void (*f)(Us...), Ts&&... args)
{
  return DoScheduleDestroy (MakeEvent (f, std::forward<Ts> (args)...));
}

template <typename U1, typename U2, typename U3,
          typename T1, typename T2, typename T3>
EventId Simulator::Schedule (Time const &delay, void (*f)(U1,U2,U3), T1 a1, T2 a2, T3 a3)
{
  return DoSchedule (delay, MakeEvent (f, a1, a2, a3));
}

template <typename U1, typename U2, typename U3, typename U4,
          typename T1, typename T2, typename T3, typename T4>
EventId Simulator::Schedule (Time const &delay, void (*f)(U1,U2,U3,U4), T1 a1, T2 a2, T3 a3, T4 a4)
{
  return DoSchedule (delay, MakeEvent (f, a1, a2, a3, a4));
}

template <typename U1, typename U2, typename U3, typename U4, typename U5,
          typename T1, typename T2, typename T3, typename T4, typename T5>
EventId Simulator::Schedule (Time const &delay, void (*f)(U1,U2,U3,U4,U5), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
{
  return DoSchedule (delay, MakeEvent (f, a1, a2, a3, a4, a5));
}




template <typename MEM, typename OBJ>
void Simulator::ScheduleWithContext (uint32_t context, Time const &delay, MEM mem_ptr, OBJ obj)
{
  ScheduleWithContext (context, delay, MakeEvent (mem_ptr, obj));
}


template <typename MEM, typename OBJ,
          typename T1>
void Simulator::ScheduleWithContext (uint32_t context, Time const &delay, MEM mem_ptr, OBJ obj, T1 a1)
{
  return ScheduleWithContext (context, delay, MakeEvent (mem_ptr, obj, a1));
}

template <typename MEM, typename OBJ,
          typename T1, typename T2>
void Simulator::ScheduleWithContext (uint32_t context, Time const &delay, MEM mem_ptr, OBJ obj, T1 a1, T2 a2)
{
  return ScheduleWithContext (context, delay, MakeEvent (mem_ptr, obj, a1, a2));
}

template <typename MEM, typename OBJ,
          typename T1, typename T2, typename T3>
void Simulator::ScheduleWithContext (uint32_t context, Time const &delay, MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3)
{
  return ScheduleWithContext (context, delay, MakeEvent (mem_ptr, obj, a1, a2, a3));
}

template <typename MEM, typename OBJ,
          typename T1, typename T2, typename T3, typename T4>
void Simulator::ScheduleWithContext (uint32_t context, Time const &delay, MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3, T4 a4)
{
  return ScheduleWithContext (context, delay, MakeEvent (mem_ptr, obj, a1, a2, a3, a4));
}

template <typename MEM, typename OBJ,
          typename T1, typename T2, typename T3, typename T4, typename T5>
void Simulator::ScheduleWithContext (uint32_t context, Time const &delay, MEM mem_ptr, OBJ obj,
                                     T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
{
  return ScheduleWithContext (context, delay, MakeEvent (mem_ptr, obj, a1, a2, a3, a4, a5));
}

template <typename U1,
          typename T1>
void Simulator::ScheduleWithContext (uint32_t context, Time const &delay, void (*f)(U1), T1 a1)
{
  return ScheduleWithContext (context, delay, MakeEvent (f, a1));
}

template <typename U1, typename U2,
          typename T1, typename T2>
void Simulator::ScheduleWithContext (uint32_t context, Time const &delay, void (*f)(U1,U2), T1 a1, T2 a2)
{
  return ScheduleWithContext (context, delay, MakeEvent (f, a1, a2));
}

template <typename U1, typename U2, typename U3,
          typename T1, typename T2, typename T3>
void Simulator::ScheduleWithContext (uint32_t context, Time const &delay, void (*f)(U1,U2,U3), T1 a1, T2 a2, T3 a3)
{
  return ScheduleWithContext (context, delay, MakeEvent (f, a1, a2, a3));
}

template <typename U1, typename U2, typename U3, typename U4,
          typename T1, typename T2, typename T3, typename T4>
void Simulator::ScheduleWithContext (uint32_t context, Time const &delay, void (*f)(U1,U2,U3,U4), T1 a1, T2 a2, T3 a3, T4 a4)
{
  return ScheduleWithContext (context, delay, MakeEvent (f, a1, a2, a3, a4));
}

template <typename U1, typename U2, typename U3, typename U4, typename U5,
          typename T1, typename T2, typename T3, typename T4, typename T5>
void Simulator::ScheduleWithContext (uint32_t context, Time const &delay, void (*f)(U1,U2,U3,U4,U5), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
{
  return ScheduleWithContext (context, delay, MakeEvent (f, a1, a2, a3, a4, a5));
}




template <typename MEM, typename OBJ>
EventId
Simulator::ScheduleNow (MEM mem_ptr, OBJ obj) 
{
  return DoScheduleNow (MakeEvent (mem_ptr, obj));
}


template <typename MEM, typename OBJ, 
          typename T1>
EventId
Simulator::ScheduleNow (MEM mem_ptr, OBJ obj, T1 a1) 
{
  return DoScheduleNow (MakeEvent (mem_ptr, obj, a1));
}

template <typename MEM, typename OBJ, 
          typename T1, typename T2>
EventId
Simulator::ScheduleNow (MEM mem_ptr, OBJ obj, T1 a1, T2 a2) 
{
  return DoScheduleNow (MakeEvent (mem_ptr, obj, a1, a2));
}

template <typename MEM, typename OBJ, 
          typename T1, typename T2, typename T3>
EventId
Simulator::ScheduleNow (MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3) 
{
  return DoScheduleNow (MakeEvent (mem_ptr, obj, a1, a2, a3));
}

template <typename MEM, typename OBJ, 
          typename T1, typename T2, typename T3, typename T4>
EventId
Simulator::ScheduleNow (MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3, T4 a4) 
{
  return DoScheduleNow (MakeEvent (mem_ptr, obj, a1, a2, a3, a4));
}

template <typename MEM, typename OBJ, 
          typename T1, typename T2, typename T3, typename T4, typename T5>
EventId
Simulator::ScheduleNow (MEM mem_ptr, OBJ obj, 
                        T1 a1, T2 a2, T3 a3, T4 a4, T5 a5) 
{
  return DoScheduleNow (MakeEvent (mem_ptr, obj, a1, a2, a3, a4, a5));
}

template <typename U1,
          typename T1>
EventId
Simulator::ScheduleNow (void (*f)(U1), T1 a1)
{
  return DoScheduleNow (MakeEvent (f, a1));
}

template <typename U1, typename U2,
          typename T1, typename T2>
EventId
Simulator::ScheduleNow (void (*f)(U1,U2), T1 a1, T2 a2)
{
  return DoScheduleNow (MakeEvent (f, a1, a2));
}

template <typename U1, typename U2, typename U3,
          typename T1, typename T2, typename T3>
EventId
Simulator::ScheduleNow (void (*f)(U1,U2,U3), T1 a1, T2 a2, T3 a3)
{
  return DoScheduleNow (MakeEvent (f, a1, a2, a3));
}

template <typename U1, typename U2, typename U3, typename U4,
          typename T1, typename T2, typename T3, typename T4>
EventId
Simulator::ScheduleNow (void (*f)(U1,U2,U3,U4), T1 a1, T2 a2, T3 a3, T4 a4)
{
  return DoScheduleNow (MakeEvent (f, a1, a2, a3, a4));
}

template <typename U1, typename U2, typename U3, typename U4, typename U5,
          typename T1, typename T2, typename T3, typename T4, typename T5>
EventId
Simulator::ScheduleNow (void (*f)(U1,U2,U3,U4,U5), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
{
  return DoScheduleNow (MakeEvent (f, a1, a2, a3, a4, a5));
}



template <typename MEM, typename OBJ>
EventId
Simulator::ScheduleDestroy (MEM mem_ptr, OBJ obj) 
{
  return DoScheduleDestroy (MakeEvent (mem_ptr, obj));
}


template <typename MEM, typename OBJ, 
          typename T1>
EventId
Simulator::ScheduleDestroy (MEM mem_ptr, OBJ obj, T1 a1) 
{
  return DoScheduleDestroy (MakeEvent (mem_ptr, obj, a1));
}

template <typename MEM, typename OBJ, 
          typename T1, typename T2>
EventId
Simulator::ScheduleDestroy (MEM mem_ptr, OBJ obj, T1 a1, T2 a2) 
{
  return DoScheduleDestroy (MakeEvent (mem_ptr, obj, a1, a2));
}

template <typename MEM, typename OBJ, 
          typename T1, typename T2, typename T3>
EventId
Simulator::ScheduleDestroy (MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3) 
{
  return DoScheduleDestroy (MakeEvent (mem_ptr, obj, a1, a2, a3));
}

template <typename MEM, typename OBJ,
          typename T1, typename T2, typename T3, typename T4>
EventId
Simulator::ScheduleDestroy (MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3, T4 a4) 
{
  return DoScheduleDestroy (MakeEvent (mem_ptr, obj, a1, a2, a3, a4));
}

template <typename MEM, typename OBJ, 
          typename T1, typename T2, typename T3, typename T4, typename T5>
EventId
Simulator::ScheduleDestroy (MEM mem_ptr, OBJ obj, 
                            T1 a1, T2 a2, T3 a3, T4 a4, T5 a5) 
{
  return DoScheduleDestroy (MakeEvent (mem_ptr, obj, a1, a2, a3, a4, a5));
}

template <typename U1,
          typename T1>
EventId
Simulator::ScheduleDestroy (void (*f)(U1), T1 a1)
{
  return DoScheduleDestroy (MakeEvent (f, a1));
}

template <typename U1, typename U2,
          typename T1, typename T2>
EventId
Simulator::ScheduleDestroy (void (*f)(U1,U2), T1 a1, T2 a2)
{
  return DoScheduleDestroy (MakeEvent (f, a1, a2));
}

template <typename U1, typename U2, typename U3,
          typename T1, typename T2, typename T3>
EventId
Simulator::ScheduleDestroy (void (*f)(U1,U2,U3), T1 a1, T2 a2, T3 a3)
{
  return DoScheduleDestroy (MakeEvent (f, a1, a2, a3));
}

template <typename U1, typename U2, typename U3, typename U4,
          typename T1, typename T2, typename T3, typename T4>
EventId
Simulator::ScheduleDestroy (void (*f)(U1,U2,U3,U4), T1 a1, T2 a2, T3 a3, T4 a4)
{
  return DoScheduleDestroy (MakeEvent (f, a1, a2, a3, a4));
}

template <typename U1, typename U2, typename U3, typename U4, typename U5,
          typename T1, typename T2, typename T3, typename T4, typename T5>
EventId
Simulator::ScheduleDestroy (void (*f)(U1,U2,U3,U4,U5), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
{
  return DoScheduleDestroy (MakeEvent (f, a1, a2, a3, a4, a5));
}

} // namespace ns3





/**
 * \file
 * \ingroup vttimer
 * \ingroup timerimpl
 * ns3::TimerImpl declaration and implementation.
 */

namespace ns3 {

/**
 * \ingroup vttimer
 * The timer implementation underlying Timer and Watchdog.
 */
class TimerImpl

namespace ns3 {

/**
 * \ingroup vttimer
 * \defgroup timerimpl TimerImpl Implementation
 * @{
 */

  return function;
}

/**@}*/  // \ingroup vttimer

  
/********************************************************************

(-)a/src/core/model/timer.cc (-1 / +1 lines)

Lines 24-30	Link Here

/**

/**

 * \file

 * \file

 * \ingroup timer

 * \ingroup vttimer

 * ns3::Timer implementation.

 * ns3::Timer implementation.

*/

*/





/**
 * \file
 * \ingroup vttimer
 * ns3::Timer class declaration.
 */



/**
 * \ingroup core
 * \defgroup vttimer Virtual Time Timer and Watchdog
 *
 * The Timer and Watchdog objects both facilitate scheduling functions
 * to execute a specified virtual time in the future.

class TimerImpl;

/**
 * \ingroup vttimer
 * \brief A simple virtual Timer class
 *
 * A (virtual time) timer is used to hold together a delay, a function to invoke
 * when the delay expires, and a set of arguments to pass to the function
 * when the delay expires.
 *
 * A Timer can be suspended, resumed, cancelled and queried for the
 * time left, but it can't be extended (except by suspending and
 * resuming).
 *
 * A timer can also be used to enforce a set of predefined event lifetime
 * management policies. These policies are specified at construction time



  /**
   * \tparam Ts \deduced Argument types.
   * \param [in] args arguments
   * Store this argument in this Timer for later use by Timer::Schedule.
   */
  template <typename T1>
  void SetArguments (T1 a1);
  /**
   * \param [in] a1 the first argument
   * \param [in] a2 the second argument
   *
   * Store these arguments in this Timer for later use by Timer::Schedule.
   */
  template <typename... Ts>
  void SetArguments (Ts... args);
  /**
   * \param [in] a1 the first argument
   * \param [in] a2 the second argument
   * \param [in] a3 the third argument
   *
   * Store these arguments in this Timer for later use by Timer::Schedule.
   */
  template <typename T1, typename T2, typename T3>
  void SetArguments (T1 a1, T2 a2, T3 a3);
  /**
   * \param [in] a1 the first argument
   * \param [in] a2 the second argument
   * \param [in] a3 the third argument
   * \param [in] a4 the fourth argument
   *
   * Store these arguments in this Timer for later use by Timer::Schedule.
   */
  template <typename T1, typename T2, typename T3, typename T4>
  void SetArguments (T1 a1, T2 a2, T3 a3, T4 a4);
  /**
   * \param [in] a1 the first argument
   * \param [in] a2 the second argument
   * \param [in] a3 the third argument
   * \param [in] a4 the fourth argument
   * \param [in] a5 the fifth argument
   *
   * Store these arguments in this Timer for later use by Timer::Schedule.
   */
  template <typename T1, typename T2, typename T3, typename T4, typename T5>
  void SetArguments (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);
  /**
   * \param [in] a1 the first argument
   * \param [in] a2 the second argument
   * \param [in] a3 the third argument
   * \param [in] a4 the fourth argument
   * \param [in] a5 the fifth argument
   * \param [in] a6 the sixth argument
   *
   * Store these arguments in this Timer for later use by Timer::Schedule.
   */
  template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
  void SetArguments (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6);

  /**
   * \param [in] delay The delay

  m_impl = MakeTimerImpl (memPtr, objPtr);
}

template <typename... Ts>
void
Timer::SetArguments (Ts... args)
{
  if (m_impl == 0)
    {
      NS_FATAL_ERROR ("You cannot set the arguments of a Timer before setting its function.");
      return;
    }
  m_impl->SetArgs (args...);
}
template <typename T1, typename T2>
void
Timer::SetArguments (T1 a1, T2 a2)
{
  if (m_impl == 0)
    {
      NS_FATAL_ERROR ("You cannot set the arguments of a Timer before setting its function.");
      return;
    }
  m_impl->SetArgs (a1, a2);
}

template <typename T1, typename T2, typename T3>
void
Timer::SetArguments (T1 a1, T2 a2, T3 a3)
{
  if (m_impl == 0)
    {
      NS_FATAL_ERROR ("You cannot set the arguments of a Timer before setting its function.");
      return;
    }
  m_impl->SetArgs (a1, a2, a3);
}

template <typename T1, typename T2, typename T3, typename T4>
void
Timer::SetArguments (T1 a1, T2 a2, T3 a3, T4 a4)
{
  if (m_impl == 0)
    {
      NS_FATAL_ERROR ("You cannot set the arguments of a Timer before setting its function.");
      return;
    }
  m_impl->SetArgs (a1, a2, a3, a4);
}

template <typename T1, typename T2, typename T3, typename T4, typename T5>
void
Timer::SetArguments (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
{
  if (m_impl == 0)
    {
      NS_FATAL_ERROR ("You cannot set the arguments of a Timer before setting its function.");
      return;
    }
  m_impl->SetArgs (a1, a2, a3, a4, a5);
}

template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
void
Timer::SetArguments (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6)
{
  if (m_impl == 0)
    {
      NS_FATAL_ERROR ("You cannot set the arguments of a Timer before setting its function.");
      return;
    }
  m_impl->SetArgs (a1, a2, a3, a4, a5, a6);
}

} // namespace ns3




 * \ingroup tracing
 * \brief Forward calls to a chain of Callback
 *
 * A TracedCallback has almost exactly the same API as a normal
 * Callback but instead of forwarding calls to a single function
 * (as a Callback normally does), it forwards calls to a chain
 * of Callback.  Connect adds a Callback at the end of the chain
 * of callbacks.  Disconnect removes a Callback from the chain of callbacks.
 *
 * This is a functor: the chain of Callbacks is invoked by
 * calling the \c operator() form with the appropriate
 * number of arguments.
 *
 * \tparam Ts \explicit Types of the functor arguments.
 * \tparam T2 \explicit Type of the second argument to the functor.
 * \tparam T3 \explicit Type of the third argument to the functor.
 * \tparam T4 \explicit Type of the fourth argument to the functor.
 * \tparam T5 \explicit Type of the fifth argument to the functor.
 * \tparam T6 \explicit Type of the sixth argument to the functor.
 * \tparam T7 \explicit Type of the seventh argument to the functor.
 * \tparam T8 \explicit Type of the eighth argument to the functor.
 */
template<typename... Ts>
         typename T3 = empty, typename T4 = empty,
         typename T5 = empty, typename T6 = empty,
         typename T7 = empty, typename T8 = empty>
class TracedCallback 
{
public:

   */
  void Disconnect (const CallbackBase & callback, std::string path);
  /**
   * \brief Functor which invokes the chain of Callbacks.
   * \tparam Ts \deduced Types of the functor arguments.
   * \param [in] args The arguments to the functor.
   * at the point where the Callback is invoked in the class
   * which fires the Callback.
   */
  void operator() (Ts... args) const;
  /** Functor which invokes the chain of Callbacks. */
  void operator() (void) const;
  /**
   * \copybrief operator()()
   * \tparam T1 \deduced Type of the first argument to the functor.
   * \param [in] a1 The first argument to the functor.
   */
  void operator() (T1 a1) const;
  /**
   * \copybrief operator()()
   * \tparam T1 \deduced Type of the first argument to the functor.
   * \tparam T2 \deduced Type of the second argument to the functor.
   * \param [in] a1 The first argument to the functor.
   * \param [in] a2 The second argument to the functor.
   */
  void operator() (T1 a1, T2 a2) const;
  /**
   * \copybrief operator()()
   * \tparam T1 \deduced Type of the first argument to the functor.
   * \tparam T2 \deduced Type of the second argument to the functor.
   * \tparam T3 \deduced Type of the third argument to the functor.
   * \param [in] a1 The first argument to the functor.
   * \param [in] a2 The second argument to the functor.
   * \param [in] a3 The third argument to the functor.
   */
  void operator() (T1 a1, T2 a2, T3 a3) const;
  /**
   * \copybrief operator()()
   * \tparam T1 \deduced Type of the first argument to the functor.
   * \tparam T2 \deduced Type of the second argument to the functor.
   * \tparam T3 \deduced Type of the third argument to the functor.
   * \tparam T4 \deduced Type of the fourth argument to the functor.
   * \param [in] a1 The first argument to the functor.
   * \param [in] a2 The second argument to the functor.
   * \param [in] a3 The third argument to the functor.
   * \param [in] a4 The fourth argument to the functor.
   */
  void operator() (T1 a1, T2 a2, T3 a3, T4 a4) const;
  /**
   * \copybrief operator()()
   * \tparam T1 \deduced Type of the first argument to the functor.
   * \tparam T2 \deduced Type of the second argument to the functor.
   * \tparam T3 \deduced Type of the third argument to the functor.
   * \tparam T4 \deduced Type of the fourth argument to the functor.
   * \tparam T5 \deduced Type of the fifth argument to the functor.
   * \param [in] a1 The first argument to the functor.
   * \param [in] a2 The second argument to the functor.
   * \param [in] a3 The third argument to the functor.
   * \param [in] a4 The fourth argument to the functor.
   * \param [in] a5 The fifth argument to the functor.
   */
  void operator() (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5) const;
  /**
   * \copybrief operator()()
   * \tparam T1 \deduced Type of the first argument to the functor.
   * \tparam T2 \deduced Type of the second argument to the functor.
   * \tparam T3 \deduced Type of the third argument to the functor.
   * \tparam T4 \deduced Type of the fourth argument to the functor.
   * \tparam T5 \deduced Type of the fifth argument to the functor.
   * \tparam T6 \deduced Type of the sixth argument to the functor.
   * \param [in] a1 The first argument to the functor.
   * \param [in] a2 The second argument to the functor.
   * \param [in] a3 The third argument to the functor.
   * \param [in] a4 The fourth argument to the functor.
   * \param [in] a5 The fifth argument to the functor.
   * \param [in] a6 The sixth argument to the functor.
   */
  void operator() (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6) const;
  /**
   * \copybrief operator()()
   * \tparam T1 \deduced Type of the first argument to the functor.
   * \tparam T2 \deduced Type of the second argument to the functor.
   * \tparam T3 \deduced Type of the third argument to the functor.
   * \tparam T4 \deduced Type of the fourth argument to the functor.
   * \tparam T5 \deduced Type of the fifth argument to the functor.
   * \tparam T6 \deduced Type of the sixth argument to the functor.
   * \tparam T7 \deduced Type of the seventh argument to the functor.
   * \param [in] a1 The first argument to the functor.
   * \param [in] a2 The second argument to the functor.
   * \param [in] a3 The third argument to the functor.
   * \param [in] a4 The fourth argument to the functor.
   * \param [in] a5 The fifth argument to the functor.
   * \param [in] a6 The sixth argument to the functor.
   * \param [in] a7 The seventh argument to the functor.
   */
  void operator() (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7) const;
  /**
   * \copybrief operator()()
   * \tparam T1 \deduced Type of the first argument to the functor.
   * \tparam T2 \deduced Type of the second argument to the functor.
   * \tparam T3 \deduced Type of the third argument to the functor.
   * \tparam T4 \deduced Type of the fourth argument to the functor.
   * \tparam T5 \deduced Type of the fifth argument to the functor.
   * \tparam T6 \deduced Type of the sixth argument to the functor.
   * \tparam T7 \deduced Type of the seventh argument to the functor.
   * \tparam T8 \deduced Type of the eighth argument to the functor.
   * \param [in] a1 The first argument to the functor.
   * \param [in] a2 The second argument to the functor.
   * \param [in] a3 The third argument to the functor.
   * \param [in] a4 The fourth argument to the functor.
   * \param [in] a5 The fifth argument to the functor.
   * \param [in] a6 The sixth argument to the functor.
   * \param [in] a7 The seventh argument to the functor.
   * \param [in] a8 The eighth argument to the functor.
   */
  void operator() (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8) const;
  /**@}*/

  /**
   *  TracedCallback signature for POD.

  /**
   * Container type for holding the chain of Callbacks.
   *
   * \tparam Ts \deduced Types of the functor arguments.
   * \tparam T2 \deduced Type of the second argument to the functor.
   * \tparam T3 \deduced Type of the third argument to the functor.
   * \tparam T4 \deduced Type of the fourth argument to the functor.
   * \tparam T5 \deduced Type of the fifth argument to the functor.
   * \tparam T6 \deduced Type of the sixth argument to the functor.
   * \tparam T7 \deduced Type of the seventh argument to the functor.
   * \tparam T8 \deduced Type of the eighth argument to the functor.
   */
  typedef std::list<Callback<void,Ts...> > CallbackList;
  /** The chain of Callbacks. */
  CallbackList m_callbackList;
};


namespace ns3 {

template<typename... Ts>
TracedCallback<Ts...>::TracedCallback ()
         typename T5, typename T6,
         typename T7, typename T8>
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::TracedCallback ()
  : m_callbackList () 
{
}
template<typename... Ts>
         typename T3, typename T4,
         typename T5, typename T6,
         typename T7, typename T8>
void
TracedCallback<Ts...>::ConnectWithoutContext (const CallbackBase & callback)
{
  Callback<void,Ts...> cb;
  if (!cb.Assign (callback))
    NS_FATAL_ERROR_NO_MSG();
  m_callbackList.push_back (cb);
}
template<typename... Ts>
         typename T3, typename T4,
         typename T5, typename T6,
         typename T7, typename T8>
void
TracedCallback<Ts...>::Connect (const CallbackBase & callback, std::string path)
{
  Callback<void,std::string,Ts...> cb;
  if (!cb.Assign (callback))
    NS_FATAL_ERROR ("when connecting to " << path);
  Callback<void,Ts...> realCb = cb.Bind (path);
  m_callbackList.push_back (realCb);
}
template<typename... Ts>
         typename T3, typename T4,
         typename T5, typename T6,
         typename T7, typename T8>
void 
TracedCallback<Ts...>::DisconnectWithoutContext (const CallbackBase & callback)
{
  for (typename CallbackList::iterator i = m_callbackList.begin ();
       i != m_callbackList.end (); /* empty */)

        }
    }
}
template<typename... Ts>
         typename T3, typename T4,
         typename T5, typename T6,
         typename T7, typename T8>
void 
TracedCallback<Ts...>::Disconnect (const CallbackBase & callback, std::string path)
{
  Callback<void,std::string,Ts...> cb;
  if (!cb.Assign (callback))
    NS_FATAL_ERROR ("when disconnecting from " << path);
  Callback<void,Ts...> realCb = cb.Bind (path);
  DisconnectWithoutContext (realCb);
}
template<typename... Ts>
         typename T3, typename T4,
         typename T5, typename T6,
         typename T7, typename T8>
void 
TracedCallback<Ts...>::operator() (Ts... args) const
{
  for (typename CallbackList::const_iterator i = m_callbackList.begin ();
       i != m_callbackList.end (); i++)
    {
      (*i)(args...);
    }
}
template<typename T1, typename T2, 
         typename T3, typename T4,
         typename T5, typename T6,
         typename T7, typename T8>
void 
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1) const
{
  for (typename CallbackList::const_iterator i = m_callbackList.begin ();
       i != m_callbackList.end (); i++)
    {
      (*i)(a1);
    }
}
template<typename T1, typename T2, 
         typename T3, typename T4,
         typename T5, typename T6,
         typename T7, typename T8>
void 
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1, T2 a2) const
{
  for (typename CallbackList::const_iterator i = m_callbackList.begin ();
       i != m_callbackList.end (); i++)
    {
      (*i)(a1, a2);
    }
}
template<typename T1, typename T2, 
         typename T3, typename T4,
         typename T5, typename T6,
         typename T7, typename T8>
void 
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1, T2 a2, T3 a3) const
{
  for (typename CallbackList::const_iterator i = m_callbackList.begin ();
       i != m_callbackList.end (); i++)
    {
      (*i)(a1, a2, a3);
    }
}
template<typename T1, typename T2, 
         typename T3, typename T4,
         typename T5, typename T6,
         typename T7, typename T8>
void 
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1, T2 a2, T3 a3, T4 a4) const
{
  for (typename CallbackList::const_iterator i = m_callbackList.begin ();
       i != m_callbackList.end (); i++)
    {
      (*i)(a1, a2, a3, a4);
    }
}
template<typename T1, typename T2, 
         typename T3, typename T4,
         typename T5, typename T6,
         typename T7, typename T8>
void 
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5) const
{
  for (typename CallbackList::const_iterator i = m_callbackList.begin ();
       i != m_callbackList.end (); i++)
    {
      (*i)(a1, a2, a3, a4, a5);
    }
}
template<typename T1, typename T2, 
         typename T3, typename T4,
         typename T5, typename T6,
         typename T7, typename T8>
void 
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6) const
{
  for (typename CallbackList::const_iterator i = m_callbackList.begin ();
       i != m_callbackList.end (); i++)
    {
      (*i)(a1, a2, a3, a4, a5, a6);
    }
}
template<typename T1, typename T2, 
         typename T3, typename T4,
         typename T5, typename T6,
         typename T7, typename T8>
void 
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7) const
{
  for (typename CallbackList::const_iterator i = m_callbackList.begin ();
       i != m_callbackList.end (); i++)
    {
      (*i)(a1, a2, a3, a4, a5, a6, a7);
    }
}
template<typename T1, typename T2, 
         typename T3, typename T4,
         typename T5, typename T6,
         typename T7, typename T8>
void 
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8) const
{
  for (typename CallbackList::const_iterator i = m_callbackList.begin ();
       i != m_callbackList.end (); i++)
    {
      (*i)(a1, a2, a3, a4, a5, a6, a7, a8);
    }
}


(-)a/src/core/model/watchdog.cc (-1 / +1 lines)

Lines 23-29	Link Here

/**

/**

 * \file

 * \file

 * \ingroup timer

 * \ingroup vttimer

 * ns3::Watchdog timer class implementation.

 * ns3::Watchdog timer class implementation.

*/

*/





/**
 * \file
 * \ingroup vttimer
 * ns3::Watchdog timer class declaration.
 */


class TimerImpl;

/**
 * \ingroup vttimer
 * \brief A very simple watchdog operating in virtual time.
 *
 * The watchdog timer is started by calling Ping with a delay value.

   */
  /**@{*/
  /**
   * \tparam Ts \deduced Argument types.
   * \param [in] args arguments
   */
  template <typename... Ts>
  void SetArguments (Ts&&... args);
  /**
   * \tparam T1 \deduced Type of the first argument.
   * \tparam T2 \deduced Type of the second argument.
   * \param [in] a1 the first argument
   * \param [in] a2 the second argument
   */
  template <typename T1, typename T2>
  void SetArguments (T1 a1, T2 a2);
  /**
   * \tparam T1 \deduced Type of the first argument.
   * \tparam T2 \deduced Type of the second argument.
   * \tparam T3 \deduced Type of the third argument.
   * \param [in] a1 the first argument
   * \param [in] a2 the second argument
   * \param [in] a3 the third argument
   */
  template <typename T1, typename T2, typename T3>
  void SetArguments (T1 a1, T2 a2, T3 a3);
  /**
   * \tparam T1 \deduced Type of the first argument.
   * \tparam T2 \deduced Type of the second argument.
   * \tparam T3 \deduced Type of the third argument.
   * \tparam T4 \deduced Type of the fourth argument.
   * \param [in] a1 the first argument
   * \param [in] a2 the second argument
   * \param [in] a3 the third argument
   * \param [in] a4 the fourth argument
   */
  template <typename T1, typename T2, typename T3, typename T4>
  void SetArguments (T1 a1, T2 a2, T3 a3, T4 a4);
  /**
   * \tparam T1 \deduced Type of the first argument.
   * \tparam T2 \deduced Type of the second argument.
   * \tparam T3 \deduced Type of the third argument.
   * \tparam T4 \deduced Type of the fourth argument.
   * \tparam T5 \deduced Type of the fifth argument.
   * \param [in] a1 the first argument
   * \param [in] a2 the second argument
   * \param [in] a3 the third argument
   * \param [in] a4 the fourth argument
   * \param [in] a5 the fifth argument
   */
  template <typename T1, typename T2, typename T3, typename T4, typename T5>
  void SetArguments (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);
  /**
   * \tparam T1 \deduced Type of the first argument.
   * \tparam T2 \deduced Type of the second argument.
   * \tparam T3 \deduced Type of the third argument.
   * \tparam T4 \deduced Type of the fourth argument.
   * \tparam T5 \deduced Type of the fifth argument.
   * \tparam T6 \deduced Type of the sixth argument.
   * \param [in] a1 the first argument
   * \param [in] a2 the second argument
   * \param [in] a3 the third argument
   * \param [in] a4 the fourth argument
   * \param [in] a5 the fifth argument
   * \param [in] a6 the sixth argument
   */
  template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
  void SetArguments (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6);
  /**@}*/

private:

  m_impl = MakeTimerImpl (memPtr, objPtr);
}

template <typename... Ts>
void 
Watchdog::SetArguments (Ts&&... args)
{
  if (m_impl == 0)
    {
      NS_FATAL_ERROR ("You cannot set the arguments of a Watchdog before setting its function.");
      return;
    }
  m_impl->SetArgs (std::forward<Ts>(args)...);
}
template <typename T1, typename T2>
void 
Watchdog::SetArguments (T1 a1, T2 a2)
{
  if (m_impl == 0)
    {
      NS_FATAL_ERROR ("You cannot set the arguments of a Watchdog before setting its function.");
      return;
    }
  m_impl->SetArgs (a1, a2);
}

template <typename T1, typename T2, typename T3>
void 
Watchdog::SetArguments (T1 a1, T2 a2, T3 a3)
{
  if (m_impl == 0)
    {
      NS_FATAL_ERROR ("You cannot set the arguments of a Watchdog before setting its function.");
      return;
    }
  m_impl->SetArgs (a1, a2, a3);
}

template <typename T1, typename T2, typename T3, typename T4>
void 
Watchdog::SetArguments (T1 a1, T2 a2, T3 a3, T4 a4)
{
  if (m_impl == 0)
    {
      NS_FATAL_ERROR ("You cannot set the arguments of a Watchdog before setting its function.");
      return;
    }
  m_impl->SetArgs (a1, a2, a3, a4);
}

template <typename T1, typename T2, typename T3, typename T4, typename T5>
void 
Watchdog::SetArguments (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
{
  if (m_impl == 0)
    {
      NS_FATAL_ERROR ("You cannot set the arguments of a Watchdog before setting its function.");
      return;
    }
  m_impl->SetArgs (a1, a2, a3, a4, a5);
}

template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
void 
Watchdog::SetArguments (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6)
{
  if (m_impl == 0)
    {
      NS_FATAL_ERROR ("You cannot set the arguments of a Watchdog before setting its function.");
      return;
    }
  m_impl->SetArgs (a1, a2, a3, a4, a5, a6);
}

} // namespace ns3

(-)a/src/core/wscript (-1 lines)

Lines 148-154	Link Here

148

        'model/timer.cc',

148

        'model/timer.cc',

149

        'model/watchdog.cc',

149

        'model/watchdog.cc',

150

        'model/synchronizer.cc',

150

        'model/synchronizer.cc',

151

        'model/make-event.cc',

152

        'model/log.cc',

151

        'model/log.cc',

153

        'model/breakpoint.cc',

152

        'model/breakpoint.cc',

154

        'model/type-id.cc',

153

        'model/type-id.cc',

Return to bug 2457