/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2005 INRIA
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
 */

#ifndef SIMULATOR_H
#define SIMULATOR_H

#include "event-id.h"
#include "event-impl.h"
#include "make-event.h"
#include "nstime.h"

#include "object-factory.h"

#include <stdint.h>
#include <string>

/**
 * @file
 * @ingroup simulator
 * ns3::Simulator declaration.
 */

namespace ns3 {

class SimulatorImpl;
class Scheduler;

/**
 * @ingroup core
 * @defgroup simulator Simulator
 * @brief Control the virtual time and the execution of simulation events. 
 */
/**
 * @ingroup simulator
 *
 * @brief Control the scheduling of simulation events. 
 *
 * The internal simulation clock is maintained
 * as a 64-bit integer in a unit specified by the user
 * through the Time::SetResolution function. This means that it is
 * not possible to specify event expiration times with anything better
 * than this user-specified accuracy. Events whose expiration time is
 * the same modulo this accuracy are scheduled in FIFO order: the 
 * first event inserted in the scheduling queue is scheduled to 
 * expire first.
 * 
 * A simple example of how to use the Simulator class to schedule events
 * is shown in sample-simulator.cc:
 * @include src/core/examples/sample-simulator.cc
 */
class Simulator 
{
public:
  /**
   * @param [in] impl A new simulator implementation.
   *
   * The simulator provides a mechanism to swap out different implementations.
   * For example, the default implementation is a single-threaded simulator
   * that performs no realtime synchronization.  By calling this method, you
   * can substitute in a new simulator implementation that might be multi-
   * threaded and synchronize events to a realtime clock.
   *
   * The simulator implementation can be set when the simulator is not 
   * running.
   */
  static void SetImplementation (Ptr<SimulatorImpl> impl);

  /**
   * @brief Get the SimulatorImpl singleton.
   *
   * @internal
   * If the SimulatorImpl singleton hasn't been created yet,
   * this function does so.  At the same time it also creates
   * the Scheduler.  Both of these respect the global values
   * which may have been set from the command line or through
   * the Config system.
   *
   * As a side effect we also call LogSetTimePrinter() and
   * LogSetNodePrinter() with the default implementations
   * since we can't really do any logging until we have
   * a SimulatorImpl and Scheduler.
   
   * @return The SimulatorImpl singleton.
   */
  static Ptr<SimulatorImpl> GetImplementation (void);

  /**
   * @brief Set the scheduler type with an ObjectFactory.
   * @param [in] schedulerFactory The configured ObjectFactory.
   *
   * The event scheduler can be set at any time: the events scheduled
   * in the previous scheduler will be transfered to the new scheduler
   * before we start to use it.
   */
  static void SetScheduler (ObjectFactory schedulerFactory);

  /**
   * Execute the events scheduled with ScheduleDestroy().
   *
   * This method is typically invoked at the end of a simulation
   * to avoid false-positive reports by a leak checker.
   * After this method has been invoked, it is actually possible
   * to restart a new simulation with a set of calls to Simulator::Run,
   * Simulator::Schedule and Simulator::ScheduleWithContext.
   */
  static void Destroy (void);

  /**
   * Check if the simulation should finish.
   *
   * Reasons to finish are because there are
   * no more events lefts to be scheduled, or if simulation
   * time has already reached the "stop time" (see Simulator::Stop()).
   *
   * @return @c true if no more events or stop time reached.
   */
  static bool IsFinished (void);

  /**
   * Run the simulation.
   *
   * The simulation will run until one of:
   *   - No events are present anymore
   *   - The user called Simulator::Stop
   *   - The user called Simulator::Stop with a stop time and the
   *     expiration time of the next event to be processed
   *     is greater than or equal to the stop time.
   */
  static void Run (void);

  /**
   * Tell the Simulator the calling event should be the last one
   * executed.
   *
   * If a running event invokes this method, it will be the last
   * event executed by the Simulator::Run method before
   * returning to the caller.
   */
  static void Stop (void);

  /**
   * Schedule the time delay until the Simulator should stop.
   *
   * Force the Simulator::Run method to return to the caller when the
   * expiration time of the next event to be processed is greater than
   * or equal to the stop time.  The stop time is relative to the
   * current simulation time.
   * @param [in] delay The stop time, relative to the current time.
   */
  static void Stop (const Time &delay);

  /**
   * Get the current simulation context.
   *
   * The simulation context is the ns-3 notion of a Logical Process.
   * Events in a single context should only modify state associated with
   * that context. Events for objects in other contexts should be
   * scheduled with ScheduleWithContext() to track the context switches.
   * In other words, events in different contexts should be mutually
   * thread safe, by not modify overlapping model state.
   *
   * In circumstances where the context can't be determined, such as
   * during object initialization, the \c enum value \c NO_CONTEXT
   * should be used.
   *
   * @return The current simulation context
   */
  static uint32_t GetContext (void);

  /**
   * Context enum values.
   *
   * \internal
   * This enum type is fixed to match the representation size
   * of simulation context.
   */
  enum : uint32_t {
    /**
     * Flag for events not associated with any particular context.
     */
    NO_CONTEXT = 0xffffffff
  };
  
  /**
   * @name Schedule events (in the same context) to run at a future time.
   */
  /** @{ */
  /**
   * 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
   * parameter.
   *
   * When the event expires (when it becomes due to be run), the 
   * 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] mem_ptr Member method pointer to invoke
   * @param [in] obj The object on which to invoke the member method
   * @returns The id for the scheduled event.
   */
  template <typename MEM, typename OBJ>
  static EventId Schedule (Time const &delay, MEM mem_ptr, OBJ obj);

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

  /**
   * @param time the relative expiration time of the event.
   * @param mem_ptr member method pointer to invoke
   * @param obj the object on which to invoke the member method
   * @param a1 the first argument to pass to the invoked method
   * @param a2 the second argument to pass to the invoked method
   * @param a3 the third argument to pass to the invoked method
   * @param a4 the fourth argument to pass to the invoked method
   * @param a5 the fifth argument to pass to the invoked method
   * @param a6 the sixth argument to pass to the invoked method
   * @returns an id for the scheduled event.
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
  static EventId Schedule (Time const &time, MEM mem_ptr, OBJ obj, 
                           T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6);

  /**
   * 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
   * parameter.
   *
   * When the event expires (when it becomes due to be run), the
   * function will be invoked with any supplied arguments.
   * @param [in] delay The relative expiration time of the event.
   * @param [in] f The function to invoke
   * @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 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);

  /**
   * @param time the relative expiration time of the event.
   * @param f the function to invoke
   * @param a1 the first argument to pass to the function to invoke
   * @param a2 the second argument to pass to the function to invoke
   * @param a3 the third argument to pass to the function to invoke
   * @param a4 the fourth argument to pass to the function to invoke
   * @param a5 the fifth argument to pass to the function to invoke
   * @param a6 the sixth argument to pass to the function to invoke
   * @returns an id for the scheduled event.
   */
  template <typename U1, typename U2, typename U3, typename U4, typename U5, typename U6,
            typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
  static EventId Schedule (Time const &time, void (*f)(U1,U2,U3,U4,U5,U6), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6);


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

  /**
   * @name Schedule events (in a different context) to run now or at a future time.
   *
   * See @ref main-test-sync.cc for example usage.
   */
  /** @{ */
  /**
   * 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.
   *
   * @see Schedule(const Time&,MEM,OBJ)
   * @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] 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 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);

  /**
   * This method is thread-safe: it can be called from any thread.
   *
   * @param time the relative expiration time of the event.
   * @param context user-specified context parameter
   * @param mem_ptr member method pointer to invoke
   * @param obj the object on which to invoke the member method
   * @param a1 the first argument to pass to the invoked method
   * @param a2 the second argument to pass to the invoked method
   * @param a3 the third argument to pass to the invoked method
   * @param a4 the fourth argument to pass to the invoked method
   * @param a5 the fifth argument to pass to the invoked method
   * @param a6 the sixth argument to pass to the invoked method
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
  static void ScheduleWithContext (uint32_t context, Time const &time, MEM mem_ptr, OBJ obj, 
                                   T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6);
  
  /**
   * 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.
   *
   * When the event expires (when it becomes due to be run), the
   * function will be invoked with any supplied arguments.
   *
   * 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
   */
  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 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);

  /**
   * This method is thread-safe: it can be called from any thread.
   *
   * @param time the relative expiration time of the event.
   * @param context user-specified context parameter
   * @param f the function to invoke
   * @param a1 the first argument to pass to the function to invoke
   * @param a2 the second argument to pass to the function to invoke
   * @param a3 the third argument to pass to the function to invoke
   * @param a4 the fourth argument to pass to the function to invoke
   * @param a5 the fifth argument to pass to the function to invoke
   * @param a6 the sixth argument to pass to the function to invoke
   */
  template <typename U1, typename U2, typename U3, typename U4, typename U5, typename U6,
            typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
  static void ScheduleWithContext (uint32_t context, Time const &time, void (*f)(U1,U2,U3,U4,U5,U6), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6);

  /** @} */  // Schedule events (in a different context) to run now or at a future time.
  
  /**
   * @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 MEM @deduced Class method function signature type.
   * @tparam OBJ @deduced Class type of the object.
   * @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 MEM, typename OBJ>
  static EventId ScheduleNow (MEM mem_ptr, OBJ obj);

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

  /**
   * @param mem_ptr member method pointer to invoke
   * @param obj the object on which to invoke the member method
   * @param a1 the first argument to pass to the invoked method
   * @param a2 the second argument to pass to the invoked method
   * @param a3 the third argument to pass to the invoked method
   * @param a4 the fourth argument to pass to the invoked method
   * @param a5 the fifth argument to pass to the invoked method
   * @param a6 the sixth 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, typename T6>
  static EventId ScheduleNow (MEM mem_ptr, OBJ obj, 
                              T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6);

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

  /**
   * @param f the function to invoke
   * @param a1 the first argument to pass to the function to invoke
   * @param a2 the second argument to pass to the function to invoke
   * @param a3 the third argument to pass to the function to invoke
   * @param a4 the fourth argument to pass to the function to invoke
   * @param a5 the fifth argument to pass to the function to invoke
   * @param a6 the sixth 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 U6,
            typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
  static EventId ScheduleNow (void (*f)(U1,U2,U3,U4,U5,U6), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6);

  /** @} */  // Schedule events (in the same context) to run now.

  /**
   * @name Schedule events to run at the end of the simulation, when Simulator:Destroy() is called.
   */
  /** @{ */
  /**
   * Schedule an event to expire 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 MEM @deduced Class method function signature type.
   * @tparam OBJ @deduced Class type of the object.
   * @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 MEM, typename OBJ>
  static EventId ScheduleDestroy (MEM mem_ptr, OBJ obj);

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

  /**
   * @param mem_ptr member method pointer to invoke
   * @param obj the object on which to invoke the member method
   * @param a1 the first argument to pass to the invoked method
   * @param a2 the second argument to pass to the invoked method
   * @param a3 the third argument to pass to the invoked method
   * @param a4 the fourth argument to pass to the invoked method
   * @param a5 the fifth argument to pass to the invoked method
   * @param a6 the sixth 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, typename T6>
  static EventId ScheduleDestroy (MEM mem_ptr, OBJ obj, 
                                  T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6);

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

  /**
   * @param f the function to invoke
   * @param a1 the first argument to pass to the function to invoke
   * @param a2 the second argument to pass to the function to invoke
   * @param a3 the third argument to pass to the function to invoke
   * @param a4 the fourth argument to pass to the function to invoke
   * @param a5 the fifth argument to pass to the function to invoke
   * @param a6 the sixth 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 U6,
            typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
  static EventId ScheduleDestroy (void (*f)(U1,U2,U3,U4,U5,U6), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6);

  /** @} */  // Schedule events to run when Simulator:Destroy() is called.

  /**
   * Remove an event from the event list. 
   * 
   * This method has the same visible effect as the 
   * ns3::EventId::Cancel method
   * but its algorithmic complexity is much higher: it has often 
   * O(log(n)) complexity, sometimes O(n), sometimes worse.
   * Note that it is not possible to remove events which were scheduled
   * for the "destroy" time. Doing so will result in a program error (crash).
   *
   * @param [in] id The event to remove from the list of scheduled events.
   */
  static void Remove (const EventId &id);

  /**
   * Set the cancel bit on this event: the event's associated function
   * will not be invoked when it expires.
   *
   * This method has the same visible effect as the 
   * ns3::Simulator::Remove method but its algorithmic complexity is 
   * much lower: it has O(1) complexity.
   * This method has the exact same semantics as ns3::EventId::Cancel.
   * Note that it is not possible to cancel events which were scheduled
   * for the "destroy" time. Doing so will result in a program error (crash).
   * 
   * @param [in] id the event to cancel
   */
  static void Cancel (const EventId &id);

  /**
   * Check if an event has already run or been cancelled.
   *
   * This method has O(1) complexity.
   * Note that it is not possible to test for the expiration of
   * events which were scheduled for the "destroy" time. Doing so
   * will result in a program error (crash).
   * An event is said to "expire" when it starts being scheduled
   * which means that if the code executed by the event calls
   * this function, it will get true.
   *
   * @param [in] id The event to test for expiration.
   * @returns @c true if the event has expired, false otherwise.
   */
  static bool IsExpired (const EventId &id);

  /**
   * Return the current simulation virtual time.
   *
   * @returns The current virtual time.
   */
  static Time Now (void);

  /**
   * Get the remaining time until this event will execute.
   *
   * @param [in] id The event id to analyse.
   * @return The delay left until the input event id expires.
   *          if the event is not running, this method returns
   *          zero.
   */
  static Time GetDelayLeft (const EventId &id);

  /**
   * Get the maximum representable simulation time.
   *
   * @return The maximum simulation time at which an event 
   *          can be scheduled.
   *
   * The returned value will always be bigger than or equal to Simulator::Now.
   */
  static Time GetMaximumSimulationTime (void);

  /**
   * Schedule a future event execution (in the same context).
   *
   * @param [in] delay Delay until the event expires.
   * @param [in] event The event to schedule.
   * @returns A unique identifier for the newly-scheduled event.
   */
  static EventId Schedule (const Time &delay, const Ptr<EventImpl> &event);

  /**
   * Schedule a future event execution (in a different context).
   * This method is thread-safe: it can be called from any thread.
   *
   * @param [in] delay Delay until the event expires.
   * @param [in] context Event context.
   * @param [in] event The event to schedule.
   * @returns A unique identifier for the newly-scheduled event.
   */
  static void ScheduleWithContext (uint32_t context, const Time &delay, EventImpl *event);

  /**
   * Schedule an event to run at the end of the simulation, after
   * the Stop() time or condition has been reached.
   *
   * @param [in] event The event to schedule.
   * @returns A unique identifier for the newly-scheduled event.
   */
  static EventId ScheduleDestroy (const Ptr<EventImpl> &event);

  /**
   * Schedule an event to run at the current virtual time.
   *
   * @param [in] event The event to schedule.
   * @returns A unique identifier for the newly-scheduled event.
   */
  static EventId ScheduleNow (const Ptr<EventImpl> &event);

  /**
   * Get the system id of this simulator.
   *
   * The system id is the identifier for this simulator instance
   * in a distributed simulation.  For MPI this is the MPI rank.
   * @return The system id for this simulator.
   */
  static uint32_t GetSystemId (void);
  
private:
  /** Default constructor. */
  Simulator ();
  /** Destructor. */
  ~Simulator ();

  /**
   * Implementation of the various Schedule methods.
   * @param [in] delay Delay until the event should execute.
   * @param [in] event The event to execute.
   * @return The EventId.
   */
  static EventId DoSchedule (Time const &delay, EventImpl *event);
  /**
   * Implementation of the various ScheduleNow methods.
   * @param [in] event The event to execute.
   * @return The EventId.
   */
  static EventId DoScheduleNow (EventImpl *event);
  /**
   * Implementation of the various ScheduleDestroy methods.
   * @param [in] event The event to execute.
   * @return The EventId.
   */
  static EventId DoScheduleDestroy (EventImpl *event);
};

/**
 * @ingroup simulator
 * @brief create an ns3::Time instance which contains the
 *        current simulation time.
 *
 * This is really a shortcut for the ns3::Simulator::Now method.
 * It is typically used as shown below to schedule an event
 * which expires at the absolute time "2 seconds":
 * @code
 *   Simulator::Schedule (Seconds (2.0) - Now (), &my_function);
 * @endcode
 * @return The current simulation time.
 */
Time Now (void);

} // namespace ns3


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

namespace ns3 {

// Doxygen has trouble with static template functions in a class:
// it treats the in-class declaration as different from the
// out of class definition, so makes two entries in the member list.  Ugh
  
template <typename MEM, typename OBJ>
EventId Simulator::Schedule (Time const &delay, MEM mem_ptr, OBJ obj) 
{
  return DoSchedule (delay, MakeEvent (mem_ptr, obj));
}


template <typename MEM, typename OBJ,
          typename T1>
EventId Simulator::Schedule (Time const &delay, MEM mem_ptr, OBJ obj, T1 a1) 
{
  return DoSchedule (delay, MakeEvent (mem_ptr, obj, a1));
}

template <typename MEM, typename OBJ, 
          typename T1, typename T2>
EventId Simulator::Schedule (Time const &delay, MEM mem_ptr, OBJ obj, T1 a1, T2 a2)
{
  return DoSchedule (delay, MakeEvent (mem_ptr, obj, a1, a2));
}

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

template <typename MEM, typename OBJ, 
          typename T1, typename T2, typename T3, typename T4>
EventId Simulator::Schedule (Time const &delay, MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3, T4 a4) 
{
  return DoSchedule (delay, 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::Schedule (Time const &delay, MEM mem_ptr, OBJ obj, 
                             T1 a1, T2 a2, T3 a3, T4 a4, T5 a5) 
{
  return DoSchedule (delay, MakeEvent (mem_ptr, obj, a1, a2, a3, a4, a5));
}

template <typename MEM, typename OBJ, 
          typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
EventId Simulator::Schedule (Time const &time, MEM mem_ptr, OBJ obj, 
                             T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6) 
{
  return DoSchedule (time, MakeEvent (mem_ptr, obj, a1, a2, a3, a4, a5, a6));
}

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

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

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 U1, typename U2, typename U3, typename U4, typename U5, typename U6,
          typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
EventId Simulator::Schedule (Time const &time, void (*f)(U1,U2,U3,U4,U5,U6), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6)
{
  return DoSchedule (time, MakeEvent (f, a1, a2, a3, a4, a5, a6));
}


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 MEM, typename OBJ,
          typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
void Simulator::ScheduleWithContext (uint32_t context, Time const &time, MEM mem_ptr, OBJ obj,
                                     T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6)
{
  return ScheduleWithContext (context, time, MakeEvent (mem_ptr, obj, a1, a2, a3, a4, a5, a6));
}

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 U1, typename U2, typename U3, typename U4, typename U5, typename U6,
          typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
void Simulator::ScheduleWithContext (uint32_t context, Time const &time, void (*f)(U1,U2,U3,U4,U5,U6), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6)
{
  return ScheduleWithContext (context, time, MakeEvent (f, a1, a2, a3, a4, a5, a6));
}


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 MEM, typename OBJ, 
          typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
EventId
Simulator::ScheduleNow (MEM mem_ptr, OBJ obj, 
                        T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6) 
{
  return DoScheduleNow (MakeEvent (mem_ptr, obj, a1, a2, a3, a4, a5, a6));
}

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 U1, typename U2, typename U3, typename U4, typename U5, typename U6,
          typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
EventId
Simulator::ScheduleNow (void (*f)(U1,U2,U3,U4,U5,U6), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6)
{
  return DoScheduleNow (MakeEvent (f, a1, a2, a3, a4, a5, a6));
}


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 MEM, typename OBJ, 
          typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
EventId
Simulator::ScheduleDestroy (MEM mem_ptr, OBJ obj, 
                            T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6) 
{
  return DoScheduleDestroy (MakeEvent (mem_ptr, obj, a1, a2, a3, a4, a5, a6));
}

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));
}

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

} // namespace ns3

#endif /* SIMULATOR_H */