Attachment #2505 for bug #2457

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




 * \tparam T \explicit The type of the derived object to construct.
 * \return The derived object.
 */
template <typename T, typename... Args>
Ptr<T> CreateObject (Args... 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));
}
/**@}*/





 */
/** @{ */
/**
 * \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 argument.
 * \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>




}


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)
{




   *
   * @tparam MEM @deduced Class method function signature type.
   * @tparam OBJ @deduced Class type of the object.
   * @tparam Ts @deduced Argument types.
   * @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] args Arguments to pass to the invoked method
   * @returns The id for the scheduled event.
   */
  template <typename MEM, typename OBJ, typename... Ts>
  static EventId Schedule (Time const &delay, MEM mem_ptr, OBJ obj, Ts... args);

  /**
   * @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.
   * @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 type of the function arguments.
   * @tparam Ts @deduced Actual type of the function arguments.
   * @returns The id for the scheduled event.
   */
  static EventId Schedule (Time const &delay, void (*f)(void));

  /**
   * @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... 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 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);

  /** @} */

  /**

   * @see Schedule(const Time&,MEM,OBJ)
   * @tparam MEM @deduced Class method function signature type.
   * @tparam OBJ @deduced Class type of the object.
   * @tparam Ts @deduced Argument types.
   * @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
   */
  template <typename MEM, typename OBJ>
  static void ScheduleWithContext (uint32_t context, Time const &delay, MEM mem_ptr, OBJ obj);

  /**
   * @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... Ts>
  static void ScheduleWithContext (uint32_t context, Time const &delay, MEM mem_ptr, OBJ obj, 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.
   * @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.

   * function will be invoked with any supplied arguments.
   *
   * This method is thread-safe: it can be called from any thread.
   * @tparam Us @deduced Formal type of the function arguments.
   * @tparam Ts @deduced Actual type of the function arguments.
   * @param [in] f The function to invoke
   */
  static void ScheduleWithContext (uint32_t context, Time const &delay, void (*f)(void));

  /**
   * @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... Us, typename... Ts>
  static void ScheduleWithContext (uint32_t context, Time const &delay, void (*f)(Us...), Ts... args);
  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.
   */

   *
   * @tparam MEM @deduced Class method function signature type.
   * @tparam OBJ @deduced Class type of the object.
   * @tparam T1 @deduced Argument types.
   * @param [in] mem_ptr Member method pointer to invoke
   * @param [in] obj The object on which to invoke the member method
   * @param [in] args Arguments to pass to the invoked method
   * @return The EventId of the scheduled event.
   */
  template <typename MEM, typename OBJ, typename... Ts>
  static EventId ScheduleNow (MEM mem_ptr, OBJ obj, Ts... args);

  /**
   * @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.
   * @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
   * @return The EventId of the scheduled event.
   */
  template <typename MEM, typename OBJ, 
            typename T1>
  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.
   * @tparam Us @deduced Formal type of the function arguments.
   * @tparam Ts @deduced Actual type of the function arguments.
   * @param [in] f The function to invoke
   * @param [in] args Arguments to pass to the function to invoke
   * @return The EventId of the scheduled event.
   */
  template <typename... Us, typename... Ts>
  static EventId ScheduleNow (void (*f)(Us...), Ts... args);
  /**
   * @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);

  /** @} */

  /**

   * 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 MEM @deduced Class method function signature type.
   * @tparam OBJ @deduced Class type of the object.
   * @tparam Ts @deduced Argument types.
   * @param [in] mem_ptr Member method pointer to invoke
   * @param [in] obj The object on which to invoke the member method
   * @param [in] args Arguments to pass to the invoked method
   * @return The EventId of the scheduled event.
   */
  template <typename MEM, typename OBJ, typename... Ts>
  static EventId ScheduleDestroy (MEM mem_ptr, OBJ obj, Ts... args);

  /**
   * @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.
   * @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
   * @return The EventId of the scheduled event.
   */
  template <typename MEM, typename OBJ, 
            typename T1>
  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.
   * @tparam Us @deduced Formal types of the function arguments.
   * @tparam Ts @deduced Actual types of the function arguments.
   * @param [in] f The function to invoke
   * @param [in] args Arguments to pass to the function to invoke
   * @return The EventId of the scheduled event.
   */
  template <typename... Us, typename... Ts>
  static EventId ScheduleDestroy (void (*f)(Us...), Ts... args);
  /**
   * @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 MEM, typename OBJ, typename... Ts>
EventId Simulator::Schedule (Time const &delay, MEM mem_ptr, OBJ obj, Ts... args)
{
  return DoSchedule (delay, MakeEvent (mem_ptr, obj, 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, args...));
}




template <typename MEM, typename OBJ, typename... Ts>
void Simulator::ScheduleWithContext (uint32_t context, Time const &delay, MEM mem_ptr, OBJ obj, Ts... args)
{
  return ScheduleWithContext (context, delay, MakeEvent (mem_ptr, obj, 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, args...));
}




template <typename MEM, typename OBJ, typename... Ts>
EventId
Simulator::ScheduleNow (MEM mem_ptr, OBJ obj, Ts... args) 
{
  return DoScheduleNow (MakeEvent (mem_ptr, obj, 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, args...));
}



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

template <typename... Us, typename... Ts>
EventId
Simulator::ScheduleDestroy (void (*f)(Us...), Ts... args)
{
  return DoScheduleDestroy (MakeEvent (f, 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




 * 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 Type of the fuctor 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 Type of the functor arguments.
   * The version selected is determined by the number of arguments
   * at the point where the Callback is invoked in the class
   * which fires the Callback.
   */
  /**@{*/
  /** 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() (Ts... args) 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);
    }
}





   */
  /**@{*/
  /**
   * \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 (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

Return to bug 2457