Attachment #1266 for bug #938

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




# The PROJECT_NAME tag is a single word (or a sequence of words surrounded
# by quotes) that should identify the project.

PROJECT_NAME           = "ns-3 "

# The PROJECT_NUMBER tag can be used to enter a project or revision number.
# This could be handy for archiving the generated documentation or

# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90

FILE_PATTERNS          = *.h \
                         *.cc
                         node-list.cc

# The RECURSIVE tag can be used to turn specify whether or not subdirectories
# should be searched for input files as well. Possible values are YES and NO.

# excluded from the INPUT source files. This way you can easily exclude a
# subdirectory from a directory tree whose root is specified with the INPUT tag.

EXCLUDE                =
                         src/olsr/model/olsr-repositories.h \
                         src/core/model/high-precision.h \
                         src/core/model/high-precision-128.h \
                         src/core/model/high-precision-double.h

# The EXCLUDE_SYMLINKS tag can be used select whether or not files or
# directories that are symbolic links (a Unix filesystem feature) are excluded

# directories that contain example code fragments that are included (see
# the \include command).

EXAMPLE_PATH           = src/aodv/examples \
                         src/bridge/examples \
                         src/click/examples \
                         src/config-store/examples \
                         src/core/examples \
                         src/csma/examples \
                         src/csma-layout/examples \
                         src/dsdv/examples \
                         src/emu/examples \
                         src/energy/examples \
                         src/flow-monitor/examples \
                         src/internet/examples \
                         src/lte/examples \
                         src/mesh/examples \
                         src/mobility/examples \
                         src/mpi/examples \
                         src/netanim/examples \
                         src/network/examples \
                         src/nix-vector-routing/examples \
                         src/olsr/examples \
                         src/openflow/examples \
                         src/point-to-point/examples \
                         src/propagation/examples \
                         src/spectrum/examples \
                         src/tap-bridge/examples \
                         src/template/examples \
                         src/tools/examples \
                         src/topology-read/examples \
                         src/uan/examples \
                         src/virtual-net-device/examples \
                         src/visualizer/examples \
                         src/wifi/examples \
                         src/wimax/examples

# If the value of the EXAMPLE_PATH tag contains directories, you can use the
# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp




  void SetRoutingTableElement (Ptr<Node> node, std::string rt);
private:
  /**
   * \brief Enable pcap output the indicated Ipv4 and interface pair.
   * \internal
   *
   * \param prefix Filename prefix to use for pcap files.
   * \param ipv4 Ptr to the Ipv4 interface on which you want to enable tracing.
   * \param interface Interface ID on the Ipv4 on which you want to enable tracing.
   */
  virtual void EnablePcapIpv4Internal (std::string prefix,
                                       Ptr<Ipv4> ipv4,

                                       bool explicitFilename);

  /**
   * \brief Enable ascii trace output on the indicated Ipv4 and interface pair.
   * \internal
   *
   * \param stream An OutputStreamWrapper representing an existing file to use
   *               when writing trace data.
   * \param prefix Filename prefix to use for ascii trace files.
   * \param ipv4 Ptr to the Ipv4 interface on which you want to enable tracing.
   * \param interface Interface ID on the Ipv4 on which you want to enable tracing.
   */
  virtual void EnableAsciiIpv4Internal (Ptr<OutputStreamWrapper> stream,
                                        std::string prefix,

(-)a/src/core/model/cairo-wideint.c (-1 / +1 lines)

Lines 659-665	Link Here

659

 * dividend and 64 bit divisor.  If the quotient doesn't fit into 32

659

 * dividend and 64 bit divisor.  If the quotient doesn't fit into 32

660

 * bits then the returned remainder is equal to the divisor, and the

660

 * bits then the returned remainder is equal to the divisor, and the

661

 * quotient is the largest representable 64 bit integer.  It is an

661

 * quotient is the largest representable 64 bit integer.  It is an

662

 * error to call this function with the high 32 bits of @num being

662

 * error to call this function with the high 32 bits of \num being

663

 * non-zero. */

663

 * non-zero. */

664

cairo_uquorem64_t

664

cairo_uquorem64_t

665

_cairo_uint_96by64_32x64_divrem (cairo_uint128_t num,

665

_cairo_uint_96by64_32x64_divrem (cairo_uint128_t num,

(-)a/src/core/model/command-line.h (-3 / +9 lines)

Lines 37-45	Link Here

 * CommandLine::AddValue but the most important functionality

 * CommandLine::AddValue but the most important functionality

 * provided by this class is that it can be used to set the

 * provided by this class is that it can be used to set the

 * 'initial value' of every attribute in the system with the

 * 'initial value' of every attribute in the system with the

 * '\--TypeIdName::AttributeName=value' syntax and it can be used

 * \verbatim

 * to set the value of every GlobalValue in the system with

 *   --TypeIdName::AttributeName=value

 * the \--GlobalValueName=value syntax.

 * \endverbatim

 * syntax and it can be used to set the value of every GlobalValue

 * in the system with the

 * \verbatim

 *   --GlobalValueName=value

 * \endverbatim

 * syntax.

*/

*/

class CommandLine

class CommandLine




  /** 
   * finds the GlobalValue with the given name and returns its value
   * 
   * \param name the name of the GlobalValue to be found
   * \param value where to store the value of the found GlobalValue
   * 
   * \return true if the GlobalValue was found, false otherwise
   */
  static bool GetValueByNameFailSafe (std::string name, AttributeValue &value);


   * value. This method cannot fail, i.e., it will trigger a
   * NS_FATAL_ERROR if the requested GlobalValue is not found.
   * 
   * \param name the name of the GlobalValue to be found
   * \param value where to store the value of the found GlobalValue
   * 
   */
  static void GetValueByName (std::string name, AttributeValue &value);

(-)a/src/core/model/names.cc (-2 / +2 lines)

Lines 463-470	Link Here

463

  NameNode *node = &m_root;

463

  NameNode *node = &m_root;

464

465

//

465

//

466

  // The string <remaining> is now composed entirely of path segments in the

466

  // The string <remaining> is now composed entirely of path segments in

467

  // /Names name space and we have eaten the leading slash. e.g.,

467

  // the /Names name space and we have eaten the leading slash. e.g.,

468

  // remaining = "ClientNode/eth0"

468

  // remaining = "ClientNode/eth0"

469

//

469

//

470

  // The start of the search is always at the root of the name space.

470

  // The start of the search is always at the root of the name space.




  }

  /**
   * \return an approximation in seconds of the time stored in this
   *          instance.
   */
  inline double GetSeconds (void) const

  }

  /**
   * \return an approximation in milliseconds of the time stored in this
   *          instance.
   */
  inline int64_t GetMilliSeconds (void) const

    return ToInteger (Time::MS);
  }
  /**
   * \return an approximation in microseconds of the time stored in this
   *          instance.
   */
  inline int64_t GetMicroSeconds (void) const

    return ToInteger (Time::US);
  }
  /**
   * \return an approximation in nanoseconds of the time stored in this
   *          instance.
   */
  inline int64_t GetNanoSeconds (void) const

    return ToInteger (Time::NS);
  }
  /**
   * \return an approximation in picoseconds of the time stored in this
   *          instance.
   */
  inline int64_t GetPicoSeconds (void) const

    return ToInteger (Time::PS);
  }
  /**
   * \return an approximation in femtoseconds of the time stored in this
   *          instance.
   */
  inline int64_t GetFemtoSeconds (void) const

    return ToInteger (Time::FS);
  }
  /**
   * \return an approximation of the time stored in this
   *          instance in the units specified in m_tsPrecision.
   */
  inline int64_t GetTimeStep (void) const

   */
  static void SetResolution (enum Unit resolution);
  /**
   * \return the current global resolution.
   */
  static enum Unit GetResolution (void);
  /**

  }
  /**
   * \param timeUnit the unit of the value to return
   * \return int64_t time value
   *
   * Convert the input time into an integer value according to the requested
   * time unit.

  }
  /**
   * \param timeUnit the unit of the value to return
   * \return double time value
   *
   * Convert the input time into a floating point value according to the requested
   * time unit.

(-)a/src/core/model/random-variable.h (-1 / +1 lines)

Lines 91-97	Link Here

  static void SetRun (uint32_t run);

  static void SetRun (uint32_t run);

/**

/**

   * \returns the current run number

   * \returns the current run number

   * @sa SetRun

   * \sa SetRun

*/

*/

  static uint32_t GetRun (void);

  static uint32_t GetRun (void);




   * 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 time the stop time, relative to the current time.
   */
  virtual void Stop (Time const &time) = 0;
  /**

   * 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 ev the event to remove from the list of scheduled events.
   */
  virtual void Remove (const EventId &ev) = 0;
  /**

   * 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 ev the event to cancel
   */
  virtual void Cancel (const EventId &ev) = 0;
  /**

   * which means that if the code executed by the event calls
   * this function, it will get true.
   *
   * \param ev the event to test for expiration
   * \returns true if the event has expired, false otherwise.
   */
  virtual bool IsExpired (const EventId &ev) const = 0;
  /**




   * 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 time the stop time, relative to the current time.
   */
  static void Stop (Time const &time);


   * When the event expires (when it becomes due to be run), the 
   * input method will be invoked on the input object.
   *
   * \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
   * \returns an id for the scheduled event.
   */
  template <typename MEM, typename OBJ>
  static EventId Schedule (Time const &time, MEM mem_ptr, OBJ obj);

  /**
   * \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
   * \returns an id for the scheduled event.
   */
  template <typename MEM, typename OBJ, typename T1>
  static EventId Schedule (Time const &time, MEM mem_ptr, OBJ obj, T1 a1);

  /**
   * \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
   * \returns an id for the scheduled event.
   */
  template <typename MEM, typename OBJ, typename T1, typename T2>
  static EventId Schedule (Time const &time, MEM mem_ptr, OBJ obj, T1 a1, T2 a2);

  /**
   * \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
   * \returns an id for the scheduled event.
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2, typename T3>
  static EventId Schedule (Time const &time, MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3);

  /**
   * \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
   * \returns an id for the scheduled event.
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2, typename T3, typename T4>
  static EventId Schedule (Time const &time, MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3, T4 a4);

  /**
   * \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
   * \returns an 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 &time, 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 f the function to invoke
   * \returns an id for the scheduled event.
   */
  static EventId Schedule (Time const &time, void (*f)(void));

  /**
   * \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
   * \returns an id for the scheduled event.
   */
  template <typename U1, typename T1>
  static EventId Schedule (Time const &time, void (*f)(U1), T1 a1);

  /**
   * \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
   * \returns an id for the scheduled event.
   */
  template <typename U1, typename U2, typename T1, typename T2>
  static EventId Schedule (Time const &time, void (*f)(U1,U2), T1 a1, T2 a2);

  /**
   * \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
   * \returns an id for the scheduled event.
   */
  template <typename U1, typename U2, typename U3, typename T1, typename T2, typename T3>
  static EventId Schedule (Time const &time, void (*f)(U1,U2,U3), T1 a1, T2 a2, T3 a3);

  /**
   * \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
   * \returns an 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 &time, void (*f)(U1,U2,U3,U4), T1 a1, T2 a2, T3 a3, T4 a4);

  /**
   * \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
   * \returns an 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>

   * Schedule an event with the given context.
   * A context of 0xffffffff means no context is specified.
   *
   * \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
   */
  template <typename MEM, typename OBJ>
  static void ScheduleWithContext (uint32_t context, Time const &time, MEM mem_ptr, OBJ obj);

  /**
   * \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
   */
  template <typename MEM, typename OBJ, typename T1>
  static void ScheduleWithContext (uint32_t context, Time const &time, MEM mem_ptr, OBJ obj, T1 a1);

  /**
   * \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
   */
  template <typename MEM, typename OBJ, typename T1, typename T2>
  static void ScheduleWithContext (uint32_t context, Time const &time, MEM mem_ptr, OBJ obj, T1 a1, T2 a2);

  /**
   * \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
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2, typename T3>
  static void ScheduleWithContext (uint32_t context, Time const &time, MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3);

  /**
   * \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
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2, typename T3, typename T4>
  static void ScheduleWithContext (uint32_t context, Time const &time, MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3, T4 a4);

  /**
   * \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
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2, typename T3, typename T4, typename T5>
  static void ScheduleWithContext (uint32_t context, Time const &time, 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 context user-specified context parameter
   * \param f the function to invoke
   */
  static void ScheduleWithContext (uint32_t context, Time const &time, void (*f)(void));

  /**
   * \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
   */
  template <typename U1, typename T1>
  static void ScheduleWithContext (uint32_t context, Time const &time, void (*f)(U1), T1 a1);

  /**
   * \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
   */
  template <typename U1, typename U2, typename T1, typename T2>
  static void ScheduleWithContext (uint32_t context, Time const &time, void (*f)(U1,U2), T1 a1, T2 a2);

  /**
   * \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
   */
  template <typename U1, typename U2, typename U3, typename T1, typename T2, typename T3>
  static void ScheduleWithContext (uint32_t context, Time const &time, void (*f)(U1,U2,U3), T1 a1, T2 a2, T3 a3);

  /**
   * \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
   */
  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 &time, void (*f)(U1,U2,U3,U4), T1 a1, T2 a2, T3 a3, T4 a4);

  /**
   * \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
   */
  template <typename U1, typename U2, typename U3, typename U4, typename U5,
            typename T1, typename T2, typename T3, typename T4, typename T5>

   * to expire "Now" are scheduled FIFO, after all normal events
   * have expired. 
   *
   * \param mem_ptr member method pointer to invoke
   * \param obj the object on which to invoke the member method
   */
  template <typename MEM, typename OBJ>
  static EventId ScheduleNow (MEM mem_ptr, OBJ obj);

  /**
   * \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
   */
  template <typename MEM, typename OBJ, 
            typename T1>
  static EventId ScheduleNow (MEM mem_ptr, OBJ obj, T1 a1);

  /**
   * \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
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2>
  static EventId ScheduleNow (MEM mem_ptr, OBJ obj, T1 a1, T2 a2);

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

  /**
   * \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
   */
  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);
  /**
   * \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
   */
  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 f the function to invoke
   */
  static EventId ScheduleNow (void (*f)(void));

  /**
   * \param f the function to invoke
   * \param a1 the first argument to pass to the function to invoke
   */
  template <typename U1,
            typename T1>
  static EventId ScheduleNow (void (*f)(U1), T1 a1);

  /**
   * \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
   */
  template <typename U1, typename U2,
            typename T1, typename T2>
  static EventId ScheduleNow (void (*f)(U1,U2), T1 a1, T2 a2);

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

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

  /**
   * \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
   */
  template <typename U1, typename U2, typename U3, typename U4, typename U5,
            typename T1, typename T2, typename T3, typename T4, typename T5>

   * after all normal events have expired and only when 
   * Simulator::Destroy is invoked.
   *
   * \param mem_ptr member method pointer to invoke
   * \param obj the object on which to invoke the member method
   */
  template <typename MEM, typename OBJ>
  static EventId ScheduleDestroy (MEM mem_ptr, OBJ obj);

  /**
   * \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
   */
  template <typename MEM, typename OBJ, 
            typename T1>
  static EventId ScheduleDestroy (MEM mem_ptr, OBJ obj, T1 a1);

  /**
   * \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
   */
  template <typename MEM, typename OBJ,
            typename T1, typename T2>
  static EventId ScheduleDestroy (MEM mem_ptr, OBJ obj, T1 a1, T2 a2);

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

  /**
   * \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
   */
  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);
  /**
   * \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
   */
  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 f the function to invoke
   */
  static EventId ScheduleDestroy (void (*f)(void));

  /**
   * \param f the function to invoke
   * \param a1 the first argument to pass to the function to invoke
   */
  template <typename U1,
            typename T1>
  static EventId ScheduleDestroy (void (*f)(U1), T1 a1);

  /**
   * \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
   */
  template <typename U1, typename U2,
            typename T1, typename T2>
  static EventId ScheduleDestroy (void (*f)(U1,U2), T1 a1, T2 a2);

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

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

  /**
   * \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
   */
  template <typename U1, typename U2, typename U3, typename U4, typename U5,
            typename T1, typename T2, typename T3, typename T4, typename T5>

   * 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 id the event to remove from the list of scheduled events.
   */
  static void Remove (const EventId &id);


   * 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 id the event to cancel
   */
  static void Cancel (const EventId &id);


   * which means that if the code executed by the event calls
   * this function, it will get true.
   *
   * \param id the event to test for expiration
   * \returns true if the event has expired, false otherwise.
   */
  static bool IsExpired (const EventId &id);





namespace ns3 {

/**
 * \brief Base class used for synchronizing the simulation events to some
 * real time "wall clock."
 *
 * The simulation clock is maintained as a 64-bit integer in a unit specified

  virtual ~Synchronizer ();

/**
 * \brief Return true if this synchronizer is actually synchronizing to a
 * realtime clock.  The simulator sometimes needs to know this.
 * \returns True if locked with realtime, false if not.
 */
  bool Realtime (void);

/**
 * \brief Retrieve the value of the origin of the underlying normalized wall
 * clock time in simulator timestep units.
 *
 * \returns The normalized wall clock time (in simulator timestep units).
 * \see TimeStepPrecision::Get
 * \see Synchronizer::SetOrigin
 */
  uint64_t GetCurrentRealtime (void);

/**
 * \brief Establish a correspondence between a simulation time and the
 * synchronizer real time.
 *
 * This method is expected to be called at the "instant" before simulation

 * virtual method to do the actual real-time-clock-specific work of making the 
 * correspondence mentioned above.
 *
 * \param ts The simulation time we should use as the origin (in simulator
 * timestep units).
 * \see TimeStepPrecision::Get
 * \see TimeStepPrecision::DoSetOrigin
 */
  void SetOrigin (uint64_t ts);

/**
 * \brief Retrieve the value of the origin of the simulation time in 
 * simulator timestep units.
 *
 * \returns The simulation time used as the origin (in simulator timestep
 * units).
 * \see TimeStepPrecision::Get
 * \see Synchronizer::SetOrigin
 */
  uint64_t GetOrigin (void);

/**
 * \brief Retrieve the difference between the real time clock used to 
 * synchronize the simulation and the simulation time (in simulator timestep
 * units).
 *
 * \param ts Simulation timestep from the simulator interpreted as current time
 * in the simulator.
 * \returns Simulation timestep (in simulator timestep units) minus origin 
 * time (stored internally in nanosecond units).
 * \see TimeStepPrecision::Get
 * \see Synchronizer::SetOrigin
 * \see Synchronizer::DoGetDrift
 */
  int64_t GetDrift (uint64_t ts);

/**
 * \brief Wait until the real time is in sync with the specified simulation
 * time or until the synchronizer is Sigalled.
 *
 * This is where the real work of synchronization is done.  The Time passed

 * (either busy-waiting or sleeping, or some combination thereof) until the
 * requested simulation time.
 *
 * \param tsCurrent The current simulation time (in simulator timestep units).
 * \param tsDelay The simulation time we need to wait for (in simulator
 * timestep units).
 * \returns True if the function ran to completion, false if it was interrupted
 * by a Signal.
 * \see TimeStepPrecision::Get
 * \see Synchronizer::DoSynchronize
 * \see Synchronizer::Signal
 */
  bool Synchronize (uint64_t tsCurrent, uint64_t tsDelay);

/**
 * \brief Tell a possible simulator thread waiting in the Synchronize method
 * that an event has happened which demands a reevaluation of the wait time.
 * This will cause the thread to wake and return to the simulator proper
 * where it can get its bearings.
 *
 * \see Synchronizer::Synchronize
 * \see Synchronizer::DoSignal
 */
  void Signal (void);

/**
 * \brief Set the condition variable that tells a possible simulator thread 
 * waiting in the Synchronize method that an event has happened which demands
 * a reevaluation of the wait time.
 *
 * \see Synchronizer::Signal
 */
  void SetCondition (bool);

/**
 * \brief Ask the synchronizer to remember what time it is.  Typically used
 * with EventEnd to determine the real execution time of a simulation event.
 *
 * \see Synchronizer::EventEnd
 * \see TimeStepPrecision::Get
 */
  void EventStart (void);

/**
 * \brief Ask the synchronizer to return the time step between the instant
 * remembered during EventStart and now.  Used in conjunction with EventStart
 * to determine the real execution time of a simulation event.
 *
 * \see Synchronizer::EventStart
 * \see TimeStepPrecision::Get
 */
  uint64_t EventEnd (void);

protected:
/**
 * \brief Establish a correspondence between a simulation time and a 
 * wall-clock (real) time.
 *
 * \internal
 *
 * There are three timelines involved here:  the simulation time, the 
 * (absolute) wall-clock time and the (relative) synchronizer real time.

 * for example, this is where the differences between Time parameters and
 * parameters to clock_nanosleep would be dealt with. 
 *
 * \param ns The simulation time we need to use as the origin (normalized to
 * nanosecond units).
 * \see Synchronizer::SetOrigin
 * \see TimeStepPrecision::Get
 */
  virtual void DoSetOrigin (uint64_t ns) = 0;

/**
 * \brief Return true if this synchronizer is actually synchronizing to a
 * realtime clock.  The simulator sometimes needs to know this.
 *
 * \internal
 *
 * Subclasses are expected to implement this method to tell the outside world
 * whether or not they are synchronizing to a realtime clock.
 *
 * \returns True if locked with realtime, false if not.
 */
  virtual bool DoRealtime (void) = 0;

/**
 * \brief Retrieve the value of the origin of the underlying normalized wall
 * clock time in simulator timestep units.
 *
 * \internal
 *
 * Subclasses are expected to implement this method to do the actual
 * real-time-clock-specific work of getting the current time.
 *
 * \returns The normalized wall clock time (in nanosecond units).
 * \see TimeStepPrecision::Get
 * \see Synchronizer::SetOrigin
 */
  virtual uint64_t DoGetCurrentRealtime (void) = 0;

/**
 * \brief Wait until the real time is in sync with the specified simulation
 * time.
 *
 * \internal
 *
 * This is where the real work of synchronization is done.  The Time passed
 * in as a parameter is the simulation time.  The job of Synchronize is to

 * real-time-clock-specific work of waiting (either busy-waiting or sleeping,
 * or some combination) until the requested simulation time.
 *
 * \param nsCurrent The current simulation time (normalized to nanosecond
 * units).
 * \param nsDelay The simulation time we need to wait for (normalized to 
 * nanosecond units).
 * \returns True if the function ran to completion, false if it was interrupted
 * by a Signal.
 * \see Synchronizer::Synchronize
 * \see TimeStepPrecision::Get
 * \see Synchronizer::Signal
 */
  virtual bool DoSynchronize (uint64_t nsCurrent, uint64_t nsDelay) = 0;

/**
 * \brief Declaration of the method used to tell a possible simulator thread 
 * waiting in the DoSynchronize method that an event has happened which
 * demands a reevaluation of the wait time.
 *
 * \see Synchronizer::Signal
 */
  virtual void DoSignal (void) = 0;

/**
 * \brief Declaration of the method used to set the condition variable that 
 * tells a possible simulator thread waiting in the Synchronize method that an
 * event has happened which demands a reevaluation of the wait time.
 *
 * \see Synchronizer::SetCondition
 */
  virtual void DoSetCondition (bool) = 0;

/**
 * \brief Declaration of method used to retrieve drift between the real time
 * clock used to synchronize the simulation and the current simulation time.
 *
 * \internal
 *
 * \param ns Simulation timestep from the simulator normalized to nanosecond 
 * steps.
 * \returns Drift in nanosecond units.
 * \see TimeStepPrecision::Get
 * \see Synchronizer::SetOrigin
 * \see Synchronizer::GetDrift
 */
  virtual int64_t DoGetDrift (uint64_t ns) = 0;



private:
/**
 * \brief Convert a simulator time step (which can be steps of time in a 
 * user-specified unit) to a normalized time step in nanosecond units.
 *
 * \internal
 *
 * \param ts The simulation time step to be normalized.
 * \returns The simulation time step normalized to nanosecond units.
 * \see TimeStepPrecision::Get
 */
  uint64_t TimeStepToNanosecond (uint64_t ts);

/**
 * \brief Convert a normalized nanosecond count into a simulator time step
 * (which can be steps of time in a user-specified unit).
 *
 * \internal
 *
 * \param ns The nanosecond count step to be converted
 * \returns The simulation time step to be interpreted in appropriate units.
 * \see TimeStepPrecision::Get
 */
  uint64_t NanosecondToTimeStep (uint64_t ns);
};

(-)a/src/core/model/system-condition.h (-1 / +1 lines)

Lines 26-32	Link Here

class SystemConditionPrivate;

class SystemConditionPrivate;

/**

/**

 * @brief A class which provides a relatively platform-independent

 * \brief A class which provides a relatively platform-independent

 * conditional-wait thread synchronization primitive.

 * conditional-wait thread synchronization primitive.

 * It is often desirable to have a mechanism by which a thread can suspend its

 * It is often desirable to have a mechanism by which a thread can suspend its




class SystemMutexPrivate;

/**
 * \brief A class which provides a relatively platform-independent Mutual
 * Exclusion thread synchronization primitive.
 *
 * When more than one thread needs to access a shared resource (data structure

 * SystemThread, the calling SystemThread is blocked until the current owner
 * releases the SystemMutex by calling Unlock.
 *
 * \see CriticalSection
 */
class SystemMutex 
{

};

/**
 * \brief A class which provides a simple way to implement a Critical Section.
 *
 * When more than one SystemThread needs to access a shared resource, we
 * control access by acquiring a SystemMutex.  The CriticalSection class uses

 * The critical section is exited when the CriticalSection object goes out of
 * scope at the end of block.
 *
 * \see SystemMutex
 */
class CriticalSection
{




class SystemThreadImpl;

/**
 * \brief A class which provides a relatively platform-independent thread
 * primitive.
 *
 * This class allows for creation of multiple threads of execution in a

{
public:
  /**
   * \brief Create a SystemThread object.
   *
   * A system thread object is not created running.  A thread of execution
   * must be explicitly started by calling the Start method.  When the 

   * method provided to do this is Join (). If you call Join() you will block
   * until the SystemThread run method returns.
   *
   * \param callback entry point of the thread
   * 
   * \warning The SystemThread uses SIGALRM to wake threads that are possibly
   * blocked on IO.
   * \see Shutdown
   *
   * \warning I've made the system thread class look like a normal ns3 object
   * with smart pointers, and living in the heap.  This makes it very easy to
   * manage threads from a single master thread context.  You should be very
   * aware though that I have not made Ptr multithread safe!  This means that

  SystemThread(Callback<void> callback);

  /**
   * \brief Destroy a SystemThread object.
   *
   */
  ~SystemThread();

  /**
   * \brief Start a thread of execution, running the provided callback.
   */
  void Start (void);

  /**
   * \brief Suspend the caller until the thread of execution, running the 
   * provided callback, finishes.
   */
  void Join (void);

  /**
   * \brief Indicates to a managed thread doing cooperative multithreading that
   * its managing thread wants it to exit.
   *
   * It is often the case that we want a thread to be off doing work until such

   * read somehow.  This method also provides that functionality, by sending a
   * SIGALRM signal to the possibly blocked thread.
   *
   * \warning Uses SIGALRM to notify threads possibly blocked on IO.  Beware
   * if you are using signals.
   * \see Break
   */
  void Shutdown (void);

  /**
   * \brief Indicates to a thread doing cooperative multithreading that
   * its managing thread wants it to exit.
   *
   * It is often the case that we want a thread to be off doing work until such

   * Typically, the worker thread is running in a forever-loop, and will need to
   * "break" out of that loop to exit -- thus the name.
   *
   * \see Shutdown
   * \returns true if thread is expected to exit (break out of the forever-loop)
   */
  bool Break (void);


(-)a/src/core/model/test.h (-1 / +1 lines)

Lines 937-943	Link Here

937

938

public:

938

public:

939

/**

939

/**

940

   * \enum TestType

940

   * \enum Type

941

   * \brief Type of test.

941

   * \brief Type of test.

942

*/

942

*/

943

  enum Type {

943

  enum Type {




namespace ns3 {

/**
 * \brief Class used for synchronizing the simulation events to a real-time
 * "wall clock" using Posix Clock functions.
 *
 * Enable this synchronizer using:


protected:
/**
 * \brief Return true if this synchronizer is actually synchronizing to a
 * realtime clock.  The simulator sometimes needs to know this.
 *
 * \internal
 *
 * Subclasses are expected to implement this method to tell the outside world
 * whether or not they are synchronizing to a realtime clock.
 *
 * \returns True if locked with realtime, false if not.
 */
  virtual bool DoRealtime (void);

/**
 * \brief Retrieve the value of the origin of the underlying normalized wall
 * clock time in nanosecond units.
 *
 * \internal
 *
 * Subclasses are expected to implement this method to do the actual
 * real-time-clock-specific work of getting the current time.
 *
 * \returns The normalized wall clock time (in nanosecond units).
 * \see TimeStepPrecision::Get
 * \see Synchronizer::SetOrigin
 */
  virtual uint64_t DoGetCurrentRealtime (void);

/**
 * \brief Establish a correspondence between a simulation time and a 
 * wall-clock (real) time.
 *
 * \internal
 *
 * There are three timelines involved here:  the simulation time, the 
 * (absolute) wall-clock time and the (relative) synchronizer real time.

 * for example, this is where the differences between Time parameters and
 * parameters to clock_nanosleep would be dealt with. 
 *
 * \param ns The simulation time we need to use as the origin (normalized to
 * nanosecond units).
 */
  virtual void DoSetOrigin (uint64_t ns);

/**
 * \brief Declaration of method used to retrieve drift between the real time
 * clock used to synchronize the simulation and the current simulation time.
 *
 * \internal
 *
 * \param ns Simulation timestep from the simulator normalized to nanosecond 
 * steps.
 * \returns Drift in nanosecond units.
 * \see TimeStepPrecision::Get
 * \see Synchronizer::SetOrigin
 * \see Synchronizer::GetDrift
 */
  virtual int64_t DoGetDrift (uint64_t ns);

/**
 * \brief Wait until the real time is in sync with the specified simulation
 * time.
 *
 * \internal
 *
 * This is where the real work of synchronization is done.  The Time passed
 * in as a parameter is the simulation time.  The job of Synchronize is to

 * real-time-clock-specific work of waiting (either busy-waiting or sleeping,
 * or some combination) until the requested simulation time.
 *
 * \param ns The simulation time we need to wait for (normalized to nanosecond
 * units).
 * \see TimeStepPrecision::Get
 */
  virtual bool DoSynchronize (uint64_t nsCurrent, uint64_t nsDelay);
  virtual void DoSignal (void);




public:
  typedef Ipv4RoutingProtocol::UnicastForwardCallback UnicastForwardCallback;
  typedef Ipv4RoutingProtocol::ErrorCallback ErrorCallback;
  /// c-tor
  QueueEntry (Ptr<const Packet> pa = 0, Ipv4Header const & h = Ipv4Header (),
              UnicastForwardCallback ucb = UnicastForwardCallback (),
              ErrorCallback ecb = ErrorCallback ())

  {
    return ((m_packet == o.m_packet) && (m_header.GetDestination () == o.m_header.GetDestination ()) && (m_expire == o.m_expire));
  }
  ///\name Fields
  // \{
  UnicastForwardCallback GetUnicastForwardCallback () const
  {

  }
  // \}
private:
  /// Data packet
  Ptr<const Packet> m_packet;
  /// IP header
  Ipv4Header m_header;
  /// Unicast forward callback
  UnicastForwardCallback m_ucb;
  /// Error callback
  ErrorCallback m_ecb;
  /// Expire time for queue entry
  Time m_expire;
};
/**

class PacketQueue
{
public:
  /// Default c-tor
  PacketQueue ()
  {
  }
  /// Push entry in queue, if there is no entry with the same packet and destination address in queue.
  bool Enqueue (QueueEntry & entry);
  /// Return first found (the earliest) entry for given destination
  bool Dequeue (Ipv4Address dst, QueueEntry & entry);
  /// Remove all packets with destination IP address dst
  void DropPacketWithDst (Ipv4Address dst);
  /// Finds whether a packet with destination dst exists in the queue
  bool Find (Ipv4Address dst);
  /// Get count of packets with destination dst in the queue
  uint32_t
  GetCountForPacketsWithDst (Ipv4Address dst);
  /// Number of entries
  uint32_t GetSize ();
  ///\name Fields
  // \{
  uint32_t GetMaxQueueLen () const
  {


private:
  std::vector<QueueEntry> m_queue;
  /// Remove all expired entries
  void Purge ();
  /// Notify that packet is dropped from queue by timeout
  void Drop (QueueEntry en, std::string reason);
  /// The maximum number of packets that we allow a routing protocol to buffer.
  uint32_t m_maxLen;
  /// The maximum number of packets that we allow per destination to buffer.
  uint32_t m_maxLenPerDst;
  /// The maximum period of time that a routing protocol is allowed to buffer a packet for, seconds.
  Time m_queueTimeout;
  static bool IsEqual (QueueEntry en, const Ipv4Address dst)
  {

(-)a/src/dsdv/model/dsdv-packet.h (-3 / +3 lines)

Lines 98-106	Link Here

    return m_dstSeqNo;

    return m_dstSeqNo;

100

private:

100

private:

101

  Ipv4Address m_dst;     // /< Destination IP Address

101

  Ipv4Address m_dst; ///< Destination IP Address

102

  uint32_t m_hopCount;     // /< Number of Hops

102

  uint32_t m_hopCount; ///< Number of Hops

103

  uint32_t m_dstSeqNo;     // /< Destination Sequence Number

103

  uint32_t m_dstSeqNo; ///< Destination Sequence Number

104

};

104

};

105

static inline std::ostream & operator<< (std::ostream& os, const DsdvHeader & packet)

105

static inline std::ostream & operator<< (std::ostream& os, const DsdvHeader & packet)

106




namespace dsdv {
NS_OBJECT_ENSURE_REGISTERED (RoutingProtocol);

/// UDP Port for DSDV control traffic
const uint32_t RoutingProtocol::DSDV_PORT = 269;

/// Tag used by DSDV implementation
struct DeferredRouteOutputTag : public Tag
{
  /// Positive if output device is fixed in RouteOutput
  int32_t oif;

  DeferredRouteOutputTag (int32_t o = -1)




  GetTypeId (void);
  static const uint32_t DSDV_PORT;

  /// c-tor
  RoutingProtocol ();
  virtual
  ~RoutingProtocol ();
  virtual void
  DoDispose ();

  ///\name From Ipv4RoutingProtocol
  // \{
  Ptr<Ipv4Route> RouteOutput (Ptr<Packet> p, const Ipv4Header &header, Ptr<NetDevice> oif, Socket::SocketErrno &sockerr);
  bool RouteInput (Ptr<const Packet> p, const Ipv4Header &header, Ptr<const NetDevice> idev, UnicastForwardCallback ucb,

  virtual void NotifyRemoveAddress (uint32_t interface, Ipv4InterfaceAddress address);
  virtual void SetIpv4 (Ptr<Ipv4> ipv4);
  // \}
  ///\name Methods to handle protocol parameters
  // \{
  void SetEnableBufferFlag (bool f);
  bool GetEnableBufferFlag () const;

  // \}

private:
  ///\name Protocol parameters.
  // \{
  /// Holdtimes is the multiplicative factor of PeriodicUpdateInterval for which the node waits since the last update
  /// before flushing a route from the routing table. If PeriodicUpdateInterval is 8s and Holdtimes is 3, the node
  /// waits for 24s since the last update to flush this route from its routing table.
  uint32_t Holdtimes;
  /// PeriodicUpdateInterval specifies the periodic time interval between which the a node broadcasts
  /// its entire routing table.
  Time m_periodicUpdateInterval;
  /// SettlingTime specifies the time for which a node waits before propagating an update.
  /// It waits for this time interval in hope of receiving an update with a better metric.
  // /\}
  Time m_settlingTime;
  /// Nodes IP address
  Ipv4Address m_mainAddress;
  /// IP protocol
  Ptr<Ipv4> m_ipv4;
  /// Raw socket per each IP interface, map socket -> iface address (IP + mask)
  std::map<Ptr<Socket>, Ipv4InterfaceAddress> m_socketAddresses;
  /// Loopback device used to defer route requests until a route is found
  Ptr<NetDevice> m_lo;
  /// Main Routing table for the node
  RoutingTable m_routingTable;
  /// Advertised Routing table for the node
  RoutingTable m_advRoutingTable;
  /// The maximum number of packets that we allow a routing protocol to buffer.
  uint32_t m_maxQueueLen;
  /// The maximum number of packets that we allow per destination to buffer.
  uint32_t m_maxQueuedPacketsPerDst;
  /// The maximum period of time that a routing protocol is allowed to buffer a packet for.
  Time m_maxQueueTime;
  /// A "drop front on full" queue used by the routing layer to buffer packets to which it does not have a route.
  PacketQueue m_queue;
  /// Flag that is used to enable or disable buffering
  bool EnableBuffering;
  /// Flag that is used to enable or disable Weighted Settling Time
  bool EnableWST;
  /// This is the wighted factor to determine the weighted settling time
  double m_weightedFactor;
  /// This is a flag to enable route aggregation. Route aggregation will aggregate all routes for
  /// 'RouteAggregationTime' from the time an update is received by a node and sends them as a single update .
  bool EnableRouteAggregation;
  /// Parameter that holds the route aggregation time interval
  Time m_routeAggregationTime;
  /// Unicast callback for own packets
  UnicastForwardCallback m_scb;
  /// Error callback for own packets
  ErrorCallback m_ecb;
  // \}

private:
  /// Start protocol operation
  void
  Start ();
  /// Queue packet untill we find a route
  void
  DeferredRouteOutput (Ptr<const Packet> p, const Ipv4Header & header, UnicastForwardCallback ucb, ErrorCallback ecb);
  /// Look for any queued packets to send them out
  void
  LookForQueuedPackets (void);
  /**

   */
  void
  SendPacketFromQueue (Ipv4Address dst, Ptr<Ipv4Route> route);
  /// Find socket with local interface address iface
  Ptr<Socket>
  FindSocketWithInterfaceAddress (Ipv4InterfaceAddress iface) const;
  ///\name Receive dsdv control packets
  // \{
  /// Receive and process dsdv control packet
  void
  RecvDsdv (Ptr<Socket> socket);
  // \}
  void
  Send (Ptr<Ipv4Route>, Ptr<const Packet>, const Ipv4Header &);
  /// Create loopback route for given header
  Ptr<Ipv4Route>
  LoopbackRoute (const Ipv4Header & header, Ptr<NetDevice> oif) const;
  /**

   */
  Time
  GetSettlingTime (Ipv4Address dst);
  /// Sends trigger update from a node
  void
  SendTriggeredUpdate ();
  /// Broadcasts the entire routing table for every PeriodicUpdateInterval
  void
  SendPeriodicUpdate ();
  void
  MergeTriggerPeriodicUpdates ();
  /// Notify that packet is dropped for some reason
  void
  Drop (Ptr<const Packet>, const Ipv4Header &, Socket::SocketErrno);
  /// Timer to trigger periodic updates from a node
  Timer m_periodicUpdateTimer;
  /// Timer used by the trigger updates in case of Weighted Settling Time is used
  Timer m_triggeredExpireTimer;
};





class RoutingTableEntry
{
public:
  /// c-tor
  RoutingTableEntry (Ptr<NetDevice> dev = 0, Ipv4Address dst = Ipv4Address (), u_int32_t m_seqNo = 0,
                     Ipv4InterfaceAddress iface = Ipv4InterfaceAddress (), u_int32_t hops = 0, Ipv4Address nextHop = Ipv4Address (),
                     Time lifetime = Simulator::Now (), Time SettlingTime = Simulator::Now (), bool changedEntries = false);

  Print (Ptr<OutputStreamWrapper> stream) const;

private:
  ///\name Fields
  // \{
  /// Destination Sequence Number
  uint32_t m_seqNo;
  /// Hop Count (number of hops needed to reach destination)
  uint32_t m_hops;
  /**
   * \brief Expiration or deletion time of the route

   *   - output device
   */
  Ptr<Ipv4Route> m_ipv4Route;
  /// Output interface address
  Ipv4InterfaceAddress m_iface;
  /// Routing flags: valid, invalid or in search
  RouteFlags m_flag;
  /// Time for which the node retains an update with changed metric before broadcasting it.
  /// A node does that in hope of receiving a better update.
  Time m_settlingTime;
  /// Flag to show if any of the routing table entries were changed with the routing update.
  uint32_t m_entriesChanged;
  //\}
};

/**

class RoutingTable
{
public:
  /// c-tor
  RoutingTable ();
  /**
   * Add routing table entry if it doesn't yet exist in routing table

  LookupRoute (Ipv4Address id, RoutingTableEntry & rt, bool forRouteInput);
  /**
   * Updating the routing Table with routing table entry rt
   * \param rt routing table entry
   * \return true on success
   */
  bool
  Update (RoutingTableEntry & rt);
  /**
   * Lookup list of addresses for which nxtHp is the next Hop address
   * \param nxtHp nexthop's address for which we want the list of destinations
   * \param dstList is the list that will hold all these destination addresses
   */
  void

   */
  void
  GetListOfAllRoutes (std::map<Ipv4Address, RoutingTableEntry> & allRoutes);
  /// Delete all route from interface with address iface
  void
  DeleteAllRoutesFromInterface (Ipv4InterfaceAddress iface);
  /// Delete all entries from routing table
  void
  Clear ()
  {
    m_ipv4AddressEntry.clear ();
  }
  /// Delete all outdated entries if Lifetime is expired
  void
  Purge (std::map<Ipv4Address, RoutingTableEntry> & removedAddresses);
  /// Print routing table
  void
  Print (Ptr<OutputStreamWrapper> stream) const;
  /// Provides the number of routes present in that nodes routing table.
  uint32_t
  RoutingTableSize ();
  /**
  * Add an event for a destination address so that the update to for that destination is sent
  * after the event is completed.
  * \param address destination address for which this event is running.
  * \param id unique eventid that was generated.
  */
  bool
  AddIpv4Event (Ipv4Address address, EventId id);
  /**
  * Clear up the entry from the map after the event is completed
  * \param address destination address for which this event is running.
  * \return true on success
  */
  bool

  /**
  * Force delete an update waiting for settling time to complete as a better update to
  * same destination was received.
  * \param address destination address for which this event is running.
  * \return true on success
  */
  bool

  /**
  * Force delete an update waiting for settling time to complete as a better update to
  * same destination was received.
  * \param address destination address for which this event is running.
  * \return true on finding out that an event is already running for that destination address.
  */
  bool
  ForceDeleteIpv4Event (Ipv4Address address);
  /**
    * Get the EcentId associated with that address.
    * \param address destination address for which this event is running.
    * \return EventId on finding out an event is associated else return NULL.
    */
  EventId
  GetEventId (Ipv4Address address);
  ///\name Handle life time of invalid route
  // \{
  Time Getholddowntime () const
  {

  // \}

private:
  ///\name Fields
  // \{
  /// an entry in the routing table.
  std::map<Ipv4Address, RoutingTableEntry> m_ipv4AddressEntry;
  /// an entry in the event table.
  std::map<Ipv4Address, EventId> m_ipv4Events;
  ///
  Time m_holddownTime;
  // \}
};




  /**
   * Set the Data Rate used for transmission of packets.
   *
   * \see Attach ()
   * \param bps the data rate at which this object operates
   */
  void SetDataRate (DataRate bps);

  /**
   * Set a start time for the device.
   *
   * \param tStart the start time
   */
  void Start (Time tStart);

  /**
   * Set a stop time for the device.
   *
   * \param tStop the stop time
   */
  void Stop (Time tStop);


   * The EmuNetDevice "owns" a queue that implements a queueing 
   * method such as DropTail or RED.
   *
   * \see Queue
   * \see DropTailQueue
   * \param queue Ptr to the new queue.
   */
  void SetQueue (Ptr<Queue> queue);

  /**
   * Get a copy of the attached Queue.
   *
   * \returns Ptr to the queue.
   */
  Ptr<Queue> GetQueue (void) const;



  /**
   * Start Sending a Packet Down the Wire.
   * \param p packet to send
   * \returns true if success, false on failure
   */
  bool TransmitStart (Ptr<Packet> p);


   * The Queue which this EmuNetDevice uses as a packet source.
   * Management of this Queue has been delegated to the EmuNetDevice
   * and it has the responsibility for deletion.
   * \see class Queue
   * \see class DropTailQueue
   */
  Ptr<Queue> m_queue;






private:
  /**
   * \brief Enable pcap output the indicated Ipv4 and interface pair.
   * \internal
   *
   * \param prefix Filename prefix to use for pcap files.
   * \param ipv4 Ptr to the Ipv4 interface on which you want to enable tracing.
   * \param interface Interface ID on the Ipv4 on which you want to enable tracing.
   */
  virtual void EnablePcapIpv4Internal (std::string prefix, 
                                       Ptr<Ipv4> ipv4, 

                                       bool explicitFilename);

  /**
   * \brief Enable ascii trace output on the indicated Ipv4 and interface pair.
   * \internal
   *
   * \param stream An OutputStreamWrapper representing an existing file to use
   *               when writing trace data.
   * \param prefix Filename prefix to use for ascii trace files.
   * \param ipv4 Ptr to the Ipv4 interface on which you want to enable tracing.
   * \param interface Interface ID on the Ipv4 on which you want to enable tracing.
   */
  virtual void EnableAsciiIpv4Internal (Ptr<OutputStreamWrapper> stream, 
                                        std::string prefix, 

                                        bool explicitFilename);

  /**
   * \brief Enable pcap output the indicated Ipv4 and interface pair.
   * \internal
   *
   * \param prefix Filename prefix to use for pcap files.
   * \param ipv4 Ptr to the Ipv4 interface on which you want to enable tracing.
   * \param interface Interface ID on the Ipv4 on which you want to enable tracing.
   */
  virtual void EnablePcapIpv6Internal (std::string prefix, 
                                       Ptr<Ipv6> ipv6, 

                                       bool explicitFilename);

  /**
   * \brief Enable ascii trace output on the indicated Ipv4 and interface pair.
   * \internal
   *
   * \param stream An OutputStreamWrapper representing an existing file to use
   *               when writing trace data.
   * \param prefix Filename prefix to use for ascii trace files.
   * \param ipv4 Ptr to the Ipv4 interface on which you want to enable tracing.
   * \param interface Interface ID on the Ipv4 on which you want to enable tracing.
   */
  virtual void EnableAsciiIpv6Internal (Ptr<OutputStreamWrapper> stream, 
                                        std::string prefix, 




namespace ns3 {

/**
 * \brief Base class providing common user-level pcap operations for helpers
 * representing IPv4 protocols .
 */
class PcapHelperForIpv4
{
public:
  /**
   * \brief Construct a PcapHelperForIpv4.
   */
  PcapHelperForIpv4 () {}

  /**
   * \brief Destroy a PcapHelperForIpv4.
   */
  virtual ~PcapHelperForIpv4 () {}

  /**
   * \brief Enable pcap output the indicated Ipv4 and interface pair.
   * \internal
   *
   * \param prefix Filename prefix to use for pcap files.
   * \param ipv4 Ptr<Ipv4> on which you want to enable tracing.
   * \param interface Interface on ipv4 on which you want to enable tracing.
   * \param explicitFilename Treat the prefix as an explicit filename if true
   */
  virtual void EnablePcapIpv4Internal (std::string prefix, 
                                       Ptr<Ipv4> ipv4, 

                                       bool explicitFilename) = 0;

  /**
   * \brief Enable pcap output the indicated Ipv4 and interface pair.
   *
   * \param prefix Filename prefix to use for pcap files.
   * \param ipv4 Ptr<Ipv4> on which you want to enable tracing.
   * \param interface Interface on ipv4 on which you want to enable tracing.
   * \param explicitFilename Treat the prefix as an explicit filename if true.
   */
  void EnablePcapIpv4 (std::string prefix, Ptr<Ipv4> ipv4, uint32_t interface, bool explicitFilename = false);

  /**
   * \brief Enable pcap output the indicated Ipv4 and interface pair using a
   * Ptr<Ipv4> previously named using the ns-3 object name service.
   *
   * \param prefix filename prefix to use for pcap files.
   * \param ipv4Name Name of the Ptr<Ipv4> on which you want to enable tracing.
   * \param interface Interface on ipv4 on which you want to enable tracing.
   * \param explicitFilename Treat the prefix as an explicit filename if true.
   */
  void EnablePcapIpv4 (std::string prefix, std::string ipv4Name, uint32_t interface, bool explicitFilename = false);

  /**
   * \brief Enable pcap output on each Ipv4 and interface pair in the container.
   *
   * \param prefix Filename prefix to use for pcap files.
   * \param c Ipv4InterfaceContainer of Ipv4 and interface pairs
   */
  void EnablePcapIpv4 (std::string prefix, Ipv4InterfaceContainer c);

  /**
   * \brief Enable pcap output on all Ipv4 and interface pairs existing in the
   * nodes provided in the container.
   *
   * \param prefix Filename prefix to use for pcap files.

  void EnablePcapIpv4 (std::string prefix, NodeContainer n);

  /**
   * \brief Enable pcap output on the Ipv4 and interface pair specified by a 
   * global node-id (of a previously created node) and interface.  Since there
   * can be only one Ipv4 aggregated to a node, the node-id unambiguously 
   * determines the Ipv4.
   *
   * \param prefix Filename prefix to use for pcap files.
   * \param nodeid The node identifier/number of the node on which to enable tracing.
   * \param interface Interface on ipv4 on which you want to enable tracing.
   * \param explicitFilename Treat the prefix as an explicit filename if true
   */
  void EnablePcapIpv4 (std::string prefix, uint32_t nodeid, uint32_t interface, bool explicitFilename);

  /**
   * \brief Enable pcap output on all Ipv4 and interface pairs existing in the 
   * set of all nodes created in the simulation.
   *
   * \param prefix Filename prefix to use for pcap files.
   */
  void EnablePcapIpv4All (std::string prefix);

};

/**
 * \brief Base class providing common user-level ascii trace operations for 
 * helpers representing IPv4 protocols .
 */
class AsciiTraceHelperForIpv4
{
public:
  /**
   * \brief Construct an AsciiTraceHelperForIpv4.
   */
  AsciiTraceHelperForIpv4 () {}

  /**
   * \brief Destroy an AsciiTraceHelperForIpv4
   */
  virtual ~AsciiTraceHelperForIpv4 () {}

  /**
   * \brief Enable ascii trace output on the indicated Ipv4 and interface pair.
   * \internal
   *
   * The implementation is expected to use a provided Ptr<OutputStreamWrapper>
   * if it is non-null.  If the OutputStreamWrapper is null, the implementation

   * context could be important, so the helper implementation is expected to 
   * TraceConnect.
   *
   * \param stream An OutputStreamWrapper representing an existing file to use
   *               when writing trace data.
   * \param prefix Filename prefix to use for ascii trace files.
   * \param ipv4 Ptr<Ipv4> on which you want to enable tracing.
   * \param interface The interface on which you want to enable tracing.
   * \param explicitFilename Treat the prefix as an explicit filename if true.
   */
  virtual void EnableAsciiIpv4Internal (Ptr<OutputStreamWrapper> stream, 
                                        std::string prefix, 

                                        bool explicitFilename) = 0;

  /**
   * \brief Enable ascii trace output on the indicated Ipv4 and interface pair.
   *
   * \param prefix Filename prefix to use for ascii files.
   * \param ipv4 Ptr<Ipv4> on which you want to enable tracing.
   * \param interface The interface on which you want to enable tracing.
   * \param explicitFilename Treat the prefix as an explicit filename if true.
   */
  void EnableAsciiIpv4 (std::string prefix, Ptr<Ipv4> ipv4, uint32_t interface, bool explicitFilename = false);

  /**
   * \brief Enable ascii trace output on the indicated Ipv4 and interface pair.
   *
   * \param stream An OutputStreamWrapper representing an existing file to use
   *               when writing trace data.
   * \param ipv4 Ptr<Ipv4> on which you want to enable tracing.
   * \param interface The interface on which you want to enable tracing.
   */
  void EnableAsciiIpv4 (Ptr<OutputStreamWrapper> stream, Ptr<Ipv4> ipv4, uint32_t interface);

  /**
   * \brief Enable ascii trace output the indicated Ipv4 and interface pair
   * using an Ipv4 previously named using the ns-3 object name service.
   *
   * \param prefix filename prefix to use for ascii files.
   * \param ipv4Name The name of the Ipv4 on which you want to enable tracing.
   * \param interface The interface on which you want to enable tracing.
   * \param explicitFilename Treat the prefix as an explicit filename if true.
   */
  void EnableAsciiIpv4 (std::string prefix, std::string ipv4Name, uint32_t interface, bool explicitFilename = false);

  /**
   * \brief Enable ascii trace output the indicated net device using a device 
   * previously named using the ns-3 object name service.
   *
   * \param stream An OutputStreamWrapper representing an existing file to use
   *               when writing trace data.
   * \param ipv4Name The name of the Ipv4 on which you want to enable tracing.
   * \param interface The interface on which you want to enable tracing.
   */
  void EnableAsciiIpv4 (Ptr<OutputStreamWrapper> stream, std::string ipv4Name, uint32_t interface);

  /**
   * \brief Enable ascii trace output on each Ipv4 and interface pair in the 
   * container
   *
   * \param prefix Filename prefix to use for ascii files.
   * \param c Ipv4InterfaceContainer of Ipv4 and interface pairs on which to 
   *          enable tracing.
   */
  void EnableAsciiIpv4 (std::string prefix, Ipv4InterfaceContainer c);

  /**
   * \brief Enable ascii trace output on each device in the container which is
   * of the appropriate type.
   *
   * \param stream An OutputStreamWrapper representing an existing file to use
   *               when writing trace data.
   * \param c Ipv4InterfaceContainer of Ipv4 and interface pairs on which to 
   *          enable tracing.
   */
  void EnableAsciiIpv4 (Ptr<OutputStreamWrapper> stream, Ipv4InterfaceContainer c);

  /**
   * \brief Enable ascii trace output on all Ipv4 and interface pairs existing
   * in the nodes provided in the container.
   *
   * \param prefix Filename prefix to use for ascii files.

  void EnableAsciiIpv4 (std::string prefix, NodeContainer n);

  /**
   * \brief Enable ascii trace output on all Ipv4 and interface pairs existing
   * in the nodes provided in the container.
   *
   * \param stream An OutputStreamWrapper representing an existing file to use
   *               when writing trace data.
   * \param n container of nodes.
   */
  void EnableAsciiIpv4 (Ptr<OutputStreamWrapper> stream, NodeContainer n);

  /**
   * \brief Enable ascii trace output on all Ipv4 and interface pairs existing
   * in the set of all nodes created in the simulation.
   *
   * \param prefix Filename prefix to use for ascii files.
   */
  void EnableAsciiIpv4All (std::string prefix);

  /**
   * \brief Enable ascii trace output on each device (which is of the
   * appropriate type) in the set of all nodes created in the simulation.
   *
   * \param stream An OutputStreamWrapper representing an existing file to use
   *               when writing trace data.
   */
  void EnableAsciiIpv4All (Ptr<OutputStreamWrapper> stream);

  /**
   * \brief Enable pcap output on the Ipv4 and interface pair specified by a 
   * global node-id (of a previously created node) and interface.  Since there
   * can be only one Ipv4 aggregated to a node, the node-id unambiguously 
   * determines the Ipv4.
   *
   * \param prefix Filename prefix to use when creating ascii trace files
   * \param nodeid The node identifier/number of the node on which to enable
   *               ascii tracing
   * \param deviceid The device identifier/index of the device on which to enable
   *                 ascii tracing
   * \param explicitFilename Treat the prefix as an explicit filename if true
   */
  void EnableAsciiIpv4 (std::string prefix, uint32_t nodeid, uint32_t deviceid, bool explicitFilename);

  /**
   * \brief Enable pcap output on the Ipv4 and interface pair specified by a 
   * global node-id (of a previously created node) and interface.  Since there
   * can be only one Ipv4 aggregated to a node, the node-id unambiguously 
   * determines the Ipv4.
   *
   * \param stream An OutputStreamWrapper representing an existing file to use
   *               when writing trace data.
   * \param nodeid The node identifier/number of the node on which to enable
   *               ascii tracing
   * \param interface The interface on which you want to enable tracing.
   * \param explicitFilename Treat the prefix as an explicit filename if true
   */
  void EnableAsciiIpv4 (Ptr<OutputStreamWrapper> stream, uint32_t nodeid, uint32_t interface, bool explicitFilename);

private:
  /**
   * \internal Avoid code duplication.
   */
  void EnableAsciiIpv4Impl (Ptr<OutputStreamWrapper> stream, 
                            std::string prefix, 

                            bool explicitFilename);

  /**
   * \internal Avoid code duplication.
   */
  void EnableAsciiIpv4Impl (Ptr<OutputStreamWrapper> stream, std::string prefix, NodeContainer n);

  /**
   * \internal Avoid code duplication.
   */
  void EnableAsciiIpv4Impl (Ptr<OutputStreamWrapper> stream, std::string prefix, Ipv4InterfaceContainer c);

  /**
   * \internal Avoid code duplication.
   */
  void EnableAsciiIpv4Impl (Ptr<OutputStreamWrapper> stream, 
                            std::string prefix, 

                            bool explicitFilename);

  /**
   * \internal Avoid code duplication.
   */
  void EnableAsciiIpv4Impl (Ptr<OutputStreamWrapper> stream, 
                            std::string prefix, 

};

/**
 * \brief Base class providing common user-level pcap operations for helpers
 * representing IPv6 protocols .
 */
class PcapHelperForIpv6
{
public:
  /**
   * \brief Construct a PcapHelperForIpv6.
   */
  PcapHelperForIpv6 () {}

  /**
   * \brief Destroy a PcapHelperForIpv6
   */
  virtual ~PcapHelperForIpv6 () {}

  /**
   * \brief Enable pcap output the indicated Ipv6 and interface pair.
   * \internal
   *
   * \param prefix Filename prefix to use for pcap files.
   * \param ipv6 Ptr<Ipv6> on which you want to enable tracing.
   * \param interface Interface on ipv6 on which you want to enable tracing.
   * \param explicitFilename Treat the prefix as an explicit filename if true.
   */
  virtual void EnablePcapIpv6Internal (std::string prefix, 
                                       Ptr<Ipv6> ipv6, 

                                       bool explicitFilename) = 0;

  /**
   * \brief Enable pcap output the indicated Ipv6 and interface pair.
   *
   * \param prefix Filename prefix to use for pcap files.
   * \param ipv6 Ptr<Ipv6> on which you want to enable tracing.
   * \param interface Interface on ipv6 on which you want to enable tracing.
   * \param explicitFilename Treat the prefix as an explicit filename if true.
   */
  void EnablePcapIpv6 (std::string prefix, Ptr<Ipv6> ipv6, uint32_t interface, bool explicitFilename = false);

  /**
   * \brief Enable pcap output the indicated Ipv6 and interface pair using a
   * Ptr<Ipv6> previously named using the ns-3 object name service.
   *
   * \param prefix filename prefix to use for pcap files.
   * \param ipv6Name Name of the Ptr<Ipv6> on which you want to enable tracing.
   * \param interface Interface on ipv6 on which you want to enable tracing.
   * \param explicitFilename Treat the prefix as an explicit filename if true.
   */
  void EnablePcapIpv6 (std::string prefix, std::string ipv6Name, uint32_t interface, bool explicitFilename = false);

  /**
   * \brief Enable pcap output on each Ipv6 and interface pair in the container.
   *
   * \param prefix Filename prefix to use for pcap files.
   * \param c Ipv6InterfaceContainer of Ipv6 and interface pairs
   */
  void EnablePcapIpv6 (std::string prefix, Ipv6InterfaceContainer c);

  /**
   * \brief Enable pcap output on all Ipv6 and interface pairs existing in the
   * nodes provided in the container.
   *
   * \param prefix Filename prefix to use for pcap files.

  void EnablePcapIpv6 (std::string prefix, NodeContainer n);

  /**
   * \brief Enable pcap output on the Ipv6 and interface pair specified by a 
   * global node-id (of a previously created node) and interface.  Since there
   * can be only one Ipv6 aggregated to a node, the node-id unambiguously 
   * determines the Ipv6.
   *
   * \param prefix Filename prefix to use for pcap files.
   * \param nodeid The node identifier/number of the node on which to enable tracing.
   * \param interface Interface on ipv6 on which you want to enable tracing.
   * \param explicitFilename Treat the prefix as an explicit filename if true
   */
  void EnablePcapIpv6 (std::string prefix, uint32_t nodeid, uint32_t interface, bool explicitFilename);

  /**
   * \brief Enable pcap output on all Ipv6 and interface pairs existing in the 
   * set of all nodes created in the simulation.
   *
   * \param prefix Filename prefix to use for pcap files.
   */
  void EnablePcapIpv6All (std::string prefix);
};

/**
 * \brief Base class providing common user-level ascii trace operations for
 * helpers representing IPv6 protocols .
 */
class AsciiTraceHelperForIpv6
{
public:
  /**
   * \brief Construct an AsciiTraceHelperForIpv6.
   */
  AsciiTraceHelperForIpv6 () {}

  /**
   * \brief Destroy an AsciiTraceHelperForIpv6
   */
  virtual ~AsciiTraceHelperForIpv6 () {}

  /**
   * \brief Enable ascii trace output on the indicated Ipv6 and interface pair.
   * \internal
   *
   * The implementation is expected to use a provided Ptr<OutputStreamWrapper>
   * if it is non-null.  If the OutputStreamWrapper is null, the implementation

   * context could be important, so the helper implementation is expected to 
   * TraceConnect.
   *
   * \param stream An OutputStreamWrapper representing an existing file to use
   *               when writing trace data.
   * \param prefix Filename prefix to use for ascii trace files.
   * \param ipv6 Ptr<Ipv6> on which you want to enable tracing.
   * \param interface The interface on which you want to enable tracing.
   * \param explicitFilename Treat the prefix as an explicit filename if true.
   */
  virtual void EnableAsciiIpv6Internal (Ptr<OutputStreamWrapper> stream, 
                                        std::string prefix, 

                                        bool explicitFilename) = 0;

  /**
   * \brief Enable ascii trace output on the indicated Ipv6 and interface pair.
   *
   * \param prefix Filename prefix to use for ascii files.
   * \param ipv6 Ptr<Ipv6> on which you want to enable tracing.
   * \param interface The interface on which you want to enable tracing.
   * \param explicitFilename Treat the prefix as an explicit filename if true.
   */
  void EnableAsciiIpv6 (std::string prefix, Ptr<Ipv6> ipv6, uint32_t interface, bool explicitFilename = false);

  /**
   * \brief Enable ascii trace output on the indicated Ipv6 and interface pair.
   *
   * \param stream An OutputStreamWrapper representing an existing file to use
   *               when writing trace data.
   * \param ipv6 Ptr<Ipv6> on which you want to enable tracing.
   * \param interface The interface on which you want to enable tracing.
   */
  void EnableAsciiIpv6 (Ptr<OutputStreamWrapper> stream, Ptr<Ipv6> ipv6, uint32_t interface);

  /**
   * \brief Enable ascii trace output the indicated Ipv6 and interface pair
   * using an Ipv6 previously named using the ns-3 object name service.
   *
   * \param prefix filename prefix to use for ascii files.
   * \param ipv6Name The name of the Ipv6 on which you want to enable tracing.
   * \param interface The interface on which you want to enable tracing.
   * \param explicitFilename Treat the prefix as an explicit filename if true.
   */
  void EnableAsciiIpv6 (std::string prefix, std::string ipv6Name, uint32_t interface, bool explicitFilename = false);

  /**
   * \brief Enable ascii trace output the indicated net device using a device 
   * previously named using the ns-3 object name service.
   *
   * \param stream An OutputStreamWrapper representing an existing file to use
   *               when writing trace data.
   * \param ipv6Name The name of the Ipv6 on which you want to enable tracing.
   * \param interface The interface on which you want to enable tracing.
   */
  void EnableAsciiIpv6 (Ptr<OutputStreamWrapper> stream, std::string ipv6Name, uint32_t interface); 

  /**
   * \brief Enable ascii trace output on each Ipv6 and interface pair in the 
   * container
   *
   * \param prefix Filename prefix to use for ascii files.
   * \param c Ipv6InterfaceContainer of Ipv6 and interface pairs on which to 
   *          enable tracing.
   */
  void EnableAsciiIpv6 (std::string prefix, Ipv6InterfaceContainer c);

  /**
   * \brief Enable ascii trace output on each device in the container which is
   * of the appropriate type.
   *
   * \param stream An OutputStreamWrapper representing an existing file to use
   *               when writing trace data.
   * \param c Ipv6InterfaceContainer of Ipv6 and interface pairs on which to 
   *          enable tracing.
   */
  void EnableAsciiIpv6 (Ptr<OutputStreamWrapper> stream, Ipv6InterfaceContainer c);

  /**
   * \brief Enable ascii trace output on all Ipv6 and interface pairs existing
   * in the nodes provided in the container.
   *
   * \param prefix Filename prefix to use for ascii files.

  void EnableAsciiIpv6 (std::string prefix, NodeContainer n);

  /**
   * \brief Enable ascii trace output on all Ipv6 and interface pairs existing
   * in the nodes provided in the container.
   *
   * \param stream An OutputStreamWrapper representing an existing file to use
   *               when writing trace data.
   * \param n container of nodes.
   */
  void EnableAsciiIpv6 (Ptr<OutputStreamWrapper> stream, NodeContainer n);

  /**
   * \brief Enable pcap output on the Ipv6 and interface pair specified by a 
   * global node-id (of a previously created node) and interface.  Since there
   * can be only one Ipv6 aggregated to a node, the node-id unambiguously 
   * determines the Ipv6.
   *
   * \param prefix Filename prefix to use when creating ascii trace files
   * \param nodeid The node identifier/number of the node on which to enable
   *               ascii tracing
   * \param interface The device identifier/index of the device on which to enable
   *               ascii tracing
   * \param explicitFilename Treat the prefix as an explicit filename if true.
   */
  void EnableAsciiIpv6 (std::string prefix, uint32_t nodeid, uint32_t interface, bool explicitFilename);

  /**
   * \brief Enable pcap output on the Ipv6 and interface pair specified by a 
   * global node-id (of a previously created node) and interface.  Since there
   * can be only one Ipv6 aggregated to a node, the node-id unambiguously 
   * determines the Ipv6.
   *
   * \param stream An OutputStreamWrapper representing an existing file to use
   *               when writing trace data.
   * \param nodeid The node identifier/number of the node on which to enable
   *               ascii tracing
   * \param interface The interface on which you want to enable tracing.
   */
  void EnableAsciiIpv6 (Ptr<OutputStreamWrapper> stream, uint32_t nodeid, uint32_t interface);

  /**
   * \brief Enable ascii trace output on all Ipv6 and interface pairs existing
   * in the set of all nodes created in the simulation.
   *
   * \param prefix Filename prefix to use for ascii files.
   */
  void EnableAsciiIpv6All (std::string prefix);

  /**
   * \brief Enable ascii trace output on each device (which is of the
   * appropriate type) in the set of all nodes created in the simulation.
   *
   * \param stream An OutputStreamWrapper representing an existing file to use
   *               when writing trace data.
   */
  void EnableAsciiIpv6All (Ptr<OutputStreamWrapper> stream);

private:
  /**
   * \internal Avoid code duplication.
   */
  void EnableAsciiIpv6Impl (Ptr<OutputStreamWrapper> stream, 
                            std::string prefix, 

                            bool explicitFilename);

  /**
   * \internal Avoid code duplication.
   */
  void EnableAsciiIpv6Impl (Ptr<OutputStreamWrapper> stream, std::string prefix, NodeContainer n);

  /**
   * \internal Avoid code duplication.
   */
  void EnableAsciiIpv6Impl (Ptr<OutputStreamWrapper> stream, std::string prefix, Ipv6InterfaceContainer c);

  /**
   * \internal Avoid code duplication.
   */
  void EnableAsciiIpv6Impl (Ptr<OutputStreamWrapper> stream, 
                            std::string prefix, 

                            bool explicitFilename);

  /**
   * \internal Avoid code duplication.
   */
  void EnableAsciiIpv6Impl (Ptr<OutputStreamWrapper> stream, 
                            std::string prefix, 




namespace ns3 {

/**
 * \brief A helper class to make life easier while doing simple IPv4 address
 * assignment in scripts.
 *
 * This class is a very simple IPv4 address generator.  You can think of it

 * We do call into the global address generator to make sure that there are
 * no duplicate addresses generated.
 *
 * \see Ipv4AddressGenerator
 */
class Ipv4AddressHelper
{
public:
/**
 * \brief Construct a helper class to make life easier while doing simple IPv4
 * address assignment in scripts.
 */
  Ipv4AddressHelper ();

/**
 * \brief Construct a helper class to make life easier while doing simple IPv4
 * address assignment in scripts.  This version sets the base and mask
 * in the constructor
 */

                     Ipv4Address base = "0.0.0.1");

/**
 * \brief Set the base network number, network mask and base address.
 *
 * The address helper allocates IP addresses based on a given network number
 * and mask combination along with an initial IP address.

 *
 * and the first address generated will be 192.168.1.1.
 *
 * \param network The Ipv4Address containing the initial network number to
 * use during allocation.  The bits outside the network mask are not used.
 * \param mask The Ipv4Mask containing one bits in each bit position of the 
 * network number.
 * \param base An optional Ipv4Address containing the initial address used for 
 * IP address allocation.  Will be combined (ORed) with the network number to
 * generate the first IP address.  Defaults to 0.0.0.1.
 * \returns Nothing.
 */
  void SetBase (Ipv4Address network, Ipv4Mask mask, 
                Ipv4Address base = "0.0.0.1");

/**
 * \brief Increment the network number and reset the IP address counter to 
 * the base value provided in the SetBase method.
 *
 * The address helper allocates IP addresses based on a given network number

 * allocated addresses returned by NewAddress would be 192.168.2.3, 
 * 192.168.2.4, etc.
 *
 * \returns The value of the incremented network number that will be used in
 * following address allocations.
 * \see SetBase
 * \see NewAddress
 */
  Ipv4Address NewNetwork (void);

/**
 * \brief Increment the IP address counter used to allocate IP addresses
 *
 * The address helper allocates IP addresses based on a given network number
 * and initial IP address.  In order to separate the network number and IP 

 * 192.168.0.4, etc., until the 253rd call which would assert due to an address
 * overflow.
 *
 * \returns The value of the newly allocated IP address.
 * \see SetBase
 * \see NewNetwork
 */
  Ipv4Address NewAddress (void);

/**
 * \brief Assign IP addresses to the net devices specified in the container
 * based on the current network prefix and address base.
 *
 * The address helper allocates IP addresses based on a given network number

 * the addresses overflow the number of bits allocated for them by the network 
 * mask in the SetBase method, the system will NS_ASSERT and halt.
 *
 * \param c The NetDeviceContainer holding the collection of net devices we
 * are asked to assign Ipv4 addresses to.
 *
 * \returns Nothing
 * \see SetBase
 * \see NewNetwork
 */
  Ipv4InterfaceContainer Assign (const NetDeviceContainer &c);

private:
  /**
   * \internal
   */
  uint32_t NumAddressBits (uint32_t maskbits) const;





 * an identical index into the Ipv4InterfaceContainer that has a std::pair with
 * the Ptr<Ipv4> and interface index you need to play with the interface.
 *
 * \see Ipv4AddressHelper
 * \see Ipv4
 */
class Ipv4InterfaceContainer
{

   * \param ipv4 pointer to Ipv4 object
   * \param interface interface index of the Ipv4Interface to add to the container
   *
   * \see Ipv4InterfaceContainer
   */
  void Add (Ptr<Ipv4> ipv4, uint32_t interface);


   *
   * \param ipInterfacePair the pair of a pointer to Ipv4 object and interface index of the Ipv4Interface to add to the container
   *
   * \see Ipv4InterfaceContainer
   */
  void Add (std::pair<Ptr<Ipv4>, uint32_t> ipInterfacePair);


   *        has been previously named using the Object Name Service.
   * \param interface interface index of the Ipv4Interface to add to the container
   *
   * \see Ipv4InterfaceContainer
   */
  void Add (std::string ipv4Name, uint32_t interface);


   *
   * \param i the index of the entery to retrieve.
   *
   * \see Ipv4InterfaceContainer
   */
  std::pair<Ptr<Ipv4>, uint32_t> Get (uint32_t i) const;





{
public:
/**
 * \brief Create an empty SPF Candidate Queue.
 * \internal
 *
 * \see SPFVertex
 */
  CandidateQueue ();

/**
 * \internal Destroy an SPF Candidate Queue and release any resources held 
 * by the contents.
 * \internal
 *
 * \see SPFVertex
 */
  virtual ~CandidateQueue ();

/**
 * \brief Empty the Candidate Queue and release all of the resources 
 * associated with the Shortest Path First Vertex pointers in the queue.
 * \internal
 *
 * \see SPFVertex
 */
  void Clear (void);

/**
 * \brief Push a Shortest Path First Vertex pointer onto the queue according
 * to the priority scheme.
 * \internal
 * 
 * On completion, the top of the queue will hold the Shortest Path First
 * Vertex pointer that points to a vertex having lowest value of the field
 * m_distanceFromRoot.  Remaining vertices are ordered according to 
 * increasing distance.
 *
 * \see SPFVertex
 * \param vNew The Shortest Path First Vertex to add to the queue.
 */
  void Push (SPFVertex *vNew);

/**
 * \brief Pop the Shortest Path First Vertex pointer at the top of the queue.
 * \internal
 *
 * The caller is given the responsibility for releasing the resources 
 * associated with the vertex.
 *
 * \see SPFVertex
 * \see Top ()
 * \returns The Shortest Path First Vertex pointer at the top of the queue.
 */
  SPFVertex* Pop (void);

/**
 * \brief Return the Shortest Path First Vertex pointer at the top of the 
 * queue.
 * \internal
 *
 * This method does not pop the SPFVertex* off of the queue, it simply 
 * returns the pointer.
 *
 * \see SPFVertex
 * \see Pop ()
 * \returns The Shortest Path First Vertex pointer at the top of the queue.
 */
  SPFVertex* Top (void) const;

/**
 * \brief Test the Candidate Queue to determine if it is empty.
 * \internal
 *
 * \returns True if the queue is empty, false otherwise.
 */
  bool Empty (void) const;

/**
 * \brief Return the number of Shortest Path First Vertex pointers presently
 * stored in the Candidate Queue.
 * \internal
 *
 * \see SPFVertex
 * \returns The number of SPFVertex* pointers in the Candidate Queue.
 */
  uint32_t Size (void) const;

/**
 * \brief Searches the Candidate Queue for a Shortest Path First Vertex 
 * pointer that points to a vertex having the given IP address.
 * \internal
 *
 * \see SPFVertex
 * \param addr The IP address to search for.
 * \returns The SPFVertex* pointer corresponding to the given IP address.
 */
  SPFVertex* Find (const Ipv4Address addr) const;

/**
 * \brief Reorders the Candidate Queue according to the priority scheme.
 * \internal
 * 
 * On completion, the top of the queue will hold the Shortest Path First
 * Vertex pointer that points to a vertex having lowest value of the field

 * This method is provided in case the values of m_distanceFromRoot change
 * during the routing calculations.
 *
 * \see SPFVertex
 */
  void Reorder (void);





class Ipv4GlobalRouting;

/**
 * \brief Vertex used in shortest path first (SPF) computations. See RFC 2328,
 * Section 16.
 *
 * Each router in the simulation is associated with an SPFVertex object.  When

{
public:
/**
 * \brief Enumeration of the possible types of SPFVertex objects.
 * \internal
 *
 * Currently we use VertexRouter to identify objects that represent a router 
 * in the simulation topology, and VertexNetwork to identify objects that 

  };

/**
 * \brief Construct an empty ("uninitialized") SPFVertex (Shortest Path First 
 * Vertex).
 * \internal
 *
 * The Vertex Type is set to VertexUnknown, the Vertex ID is set to 
 * 255.255.255.255, and the distance from root is set to infinity 

 * infinity, the next hop address is set to 0.0.0.0 and the list of children
 * of the SPFVertex is initialized to empty.
 *
 * \see VertexType
 */
  SPFVertex();

/**
 * \brief Construct an initialized SPFVertex (Shortest Path First Vertex).
 * \internal
 *
 * The Vertex Type is initialized to VertexRouter and the Vertex ID is found
 * from the Link State ID of the Link State Advertisement (LSA) passed as a

 * these members, initialization is as in the default constructor.
 * of the SPFVertex is initialized to empty.
 *
 * \see SPFVertex::SPFVertex ()
 * \see VertexType
 * \see GlobalRoutingLSA
 * \param lsa The Link State Advertisement used for finding initial values.
 */
  SPFVertex(GlobalRoutingLSA* lsa);

/**
 * \brief Destroy an SPFVertex (Shortest Path First Vertex).
 * \internal
 *
 * The children vertices of the SPFVertex are recursively deleted.
 *
 * \see SPFVertex::SPFVertex ()
 */
  ~SPFVertex();

/**
 * \brief Get the Vertex Type field of a SPFVertex object.
 * \internal
 *
 * The Vertex Type describes the kind of simulation object a given SPFVertex
 * represents.
 *
 * \see VertexType
 * \returns The VertexType of the current SPFVertex object.
 */
  VertexType GetVertexType (void) const;

/**
 * \brief Set the Vertex Type field of a SPFVertex object.
 * \internal
 *
 * The Vertex Type describes the kind of simulation object a given SPFVertex
 * represents.
 *
 * \see VertexType
 * \param type The new VertexType for the current SPFVertex object.
 */
  void SetVertexType (VertexType type);

/**
 * \brief Get the Vertex ID field of a SPFVertex object.
 * \internal
 *
 * The Vertex ID uniquely identifies the simulation object a given SPFVertex
 * represents.  Typically, this is the Router ID for SPFVertex objects 

 * beginning at 0.0.0.0 and monotonically increasing as new routers are
 * instantiated.
 *
 * \returns The Ipv4Address Vertex ID of the current SPFVertex object.
 */
  Ipv4Address GetVertexId (void) const;

/**
 * \brief Set the Vertex ID field of a SPFVertex object.
 * \internal
 *
 * The Vertex ID uniquely identifies the simulation object a given SPFVertex
 * represents.  Typically, this is the Router ID for SPFVertex objects 

 * instantiated.  This method is an explicit override of the automatically
 * generated value.
 *
 * \param id The new Ipv4Address Vertex ID for the current SPFVertex object.
 */
  void SetVertexId (Ipv4Address id);

/**
 * \brief Get the Global Router Link State Advertisement returned by the 
 * Global Router represented by this SPFVertex during the route discovery 
 * process.
 * \internal
 *
 * \see GlobalRouter
 * \see GlobalRoutingLSA
 * \see GlobalRouter::DiscoverLSAs ()
 * \returns A pointer to the GlobalRoutingLSA found by the router represented
 * by this SPFVertex object.
 */
  GlobalRoutingLSA* GetLSA (void) const;

/**
 * \brief Set the Global Router Link State Advertisement returned by the 
 * Global Router represented by this SPFVertex during the route discovery 
 * process.
 * \internal
 *
 * \see SPFVertex::GetLSA ()
 * \see GlobalRouter
 * \see GlobalRoutingLSA
 * \see GlobalRouter::DiscoverLSAs ()
 * \warning Ownership of the LSA is transferred to the "this" SPFVertex.  You
 * must not delete the LSA after calling this method.
 * \param lsa A pointer to the GlobalRoutingLSA.
 */
  void SetLSA (GlobalRoutingLSA* lsa);

/**
 * \brief Get the distance from the root vertex to "this" SPFVertex object.
 * \internal
 *
 * Each router in the simulation is associated with an SPFVertex object.  When
 * calculating routes, each of these routers is, in turn, chosen as the "root"

 * The distance is calculated during route discovery and is stored in a
 * member variable.  This method simply fetches that value.
 *
 * \returns The distance, in hops, from the root SPFVertex to "this" SPFVertex.
 */
  uint32_t GetDistanceFromRoot (void) const;

/**
 * \brief Set the distance from the root vertex to "this" SPFVertex object.
 * \internal
 *
 * Each router in the simulation is associated with an SPFVertex object.  When
 * calculating routes, each of these routers is, in turn, chosen as the "root"

 * we're asking for is the number of hops from the root vertex to the vertex
 * in question.
 *
 * \param distance The distance, in hops, from the root SPFVertex to "this"
 * SPFVertex.
 */
  void SetDistanceFromRoot (uint32_t distance);

/**
 * \brief Set the IP address and outgoing interface index that should be used 
 * to begin forwarding packets from the root SPFVertex to "this" SPFVertex.
 * \internal
 *
 * Each router node in the simulation is associated with an SPFVertex object.
 * When calculating routes, each of these routers is, in turn, chosen as the 

 * In this method we are telling the root node which exit direction it should send
 * should I send a packet to the network or host represented by 'this' SPFVertex.
 *
 * \see GlobalRouter
 * \see GlobalRoutingLSA
 * \see GlobalRoutingLinkRecord
 * \param nextHop The IP address to use when forwarding packets to the host
 * or network represented by "this" SPFVertex.
 * \param id The interface index to use when forwarding packets to the host or
 * network represented by "this" SPFVertex.
 */
  void SetRootExitDirection (Ipv4Address nextHop, int32_t id = SPF_INFINITY);
  typedef std::pair<Ipv4Address, int32_t> NodeExit_t;
/**
 * \brief Set the IP address and outgoing interface index that should be used 
 * to begin forwarding packets from the root SPFVertex to "this" SPFVertex.
 * \internal
 *
 * Each router node in the simulation is associated with an SPFVertex object.
 * When calculating routes, each of these routers is, in turn, chosen as the 

 * In this method we are telling the root node which exit direction it should send
 * should I send a packet to the network or host represented by 'this' SPFVertex.
 *
 * \see GlobalRouter
 * \see GlobalRoutingLSA
 * \see GlobalRoutingLinkRecord
 * \param nextHop The IP address to use when forwarding packets to the host
 * or network represented by "this" SPFVertex.
 * \param exit The pair of next-hop-IP and outgoing-interface-index to use when 
 * forwarding packets to the host or network represented by "this" SPFVertex.
 */
  void SetRootExitDirection (SPFVertex::NodeExit_t exit);

  uint32_t GetNRootExitDirections () const;

/**
 * \brief Get a pointer to the SPFVector that is the parent of "this" 
 * SPFVertex.
 * \internal
 *
 * Each router node in the simulation is associated with an SPFVertex object.
 * When calculating routes, each of these routers is, in turn, chosen as the 

 * This method returns a pointer to the parent node of "this" SPFVertex
 * (both of which reside in that SPF tree).
 *
 * \param i The index to one of the parents
 * \returns A pointer to the SPFVertex that is the parent of "this" SPFVertex
 * in the SPF tree.
 */
  SPFVertex* GetParent (uint32_t i = 0) const;

/**
 * \brief Set the pointer to the SPFVector that is the parent of "this" 
 * SPFVertex.
 * \internal
 *
 * Each router node in the simulation is associated with an SPFVertex object.
 * When calculating routes, each of these routers is, in turn, chosen as the 

 * This method sets the parent pointer of "this" SPFVertex (both of which
 * reside in that SPF tree).
 *
 * \param parent A pointer to the SPFVertex that is the parent of "this" 
 * SPFVertex* in the SPF tree.
 */
  void SetParent (SPFVertex* parent);

  void MergeParent (const SPFVertex* v);

/**
 * \brief Get the number of children of "this" SPFVertex.
 * \internal
 *
 * Each router node in the simulation is associated with an SPFVertex object.
 * When calculating routes, each of these routers is, in turn, chosen as the 

 * This method returns the number of children of "this" SPFVertex (which 
 * reside in the SPF tree).
 *
 * \returns The number of children of "this" SPFVertex (which reside in the
 * SPF tree).
 */
  uint32_t GetNChildren (void) const;

/**
 * \brief Get a borrowed SPFVertex pointer to the specified child of "this" 
 * SPFVertex.
 * \internal
 *
 * Each router node in the simulation is associated with an SPFVertex object.
 * When calculating routes, each of these routers is, in turn, chosen as the 

 * This method the number of children of "this" SPFVertex (which reside in
 * the SPF tree.
 *
 * \see SPFVertex::GetNChildren
 * \param n The index (from 0 to the number of children minus 1) of the 
 * child SPFVertex to return.
 * \warning The pointer returned by GetChild () is a borrowed pointer.  You
 * do not have any ownership of the underlying object and must not delete
 * that object.
 * \returns A pointer to the specified child SPFVertex (which resides in the
 * SPF tree).
 */
  SPFVertex* GetChild (uint32_t n) const;

/**
 * \brief Get a borrowed SPFVertex pointer to the specified child of "this" 
 * SPFVertex.
 * \internal
 *
 * Each router node in the simulation is associated with an SPFVertex object.
 * When calculating routes, each of these routers is, in turn, chosen as the 

 * This method the number of children of "this" SPFVertex (which reside in
 * the SPF tree.
 *
 * \see SPFVertex::GetNChildren
 * \warning Ownership of the pointer added to the children of "this" 
 * SPFVertex is transferred to the "this" SPFVertex.  You must not delete the
 * (now) child SPFVertex after calling this method.
 * \param child A pointer to the SPFVertex (which resides in the SPF tree) to
 * be added to the list of children of "this" SPFVertex.
 * \returns The number of children of "this" SPFVertex after the addition of
 * the new child.
 */
  uint32_t AddChild (SPFVertex* child);

  /**
   * \brief Set the value of the VertexProcessed flag
   *
   * Flag to note whether vertex has been processed in stage two of 
   * SPF computation
   * \param value boolean value to set the flag
   */ 
  void SetVertexProcessed (bool value);

  /**
   * \brief Check the value of the VertexProcessed flag
   *
   * Flag to note whether vertex has been processed in stage two of 
   * SPF computation
   * \returns value of underlying flag
   */ 
  bool IsVertexProcessed (void) const;


  bool m_vertexProcessed; 

/**
 * \brief The SPFVertex copy construction is disallowed.  There's no need for
 * it and a compiler provided shallow copy would be wrong.
 */
  SPFVertex (SPFVertex& v);

/**
 * \brief The SPFVertex copy assignment operator is disallowed.  There's no 
 * need for it and a compiler provided shallow copy would be wrong.
 */
  SPFVertex& operator= (SPFVertex& v);

};

/**
 * \brief The Link State DataBase (LSDB) of the Global Route Manager.
 *
 * Each node in the simulation participating in global routing has a
 * GlobalRouter interface.  The primary job of this interface is to export

{
public:
/**
 * \brief Construct an empty Global Router Manager Link State Database.
 * \internal
 *
 * The database map composing the Link State Database is initialized in
 * this constructor.

  GlobalRouteManagerLSDB ();

/**
 * \brief Destroy an empty Global Router Manager Link State Database.
 * \internal
 *
 * The database map is walked and all of the Link State Advertisements stored
 * in the database are freed; then the database map itself is clear ()ed to

  ~GlobalRouteManagerLSDB ();

/**
 * \brief Insert an IP address / Link State Advertisement pair into the Link
 * State Database.
 * \internal
 *
 * The IPV4 address and the GlobalRoutingLSA given as parameters are converted
 * to an STL pair and are inserted into the database map.
 *
 * \see GlobalRoutingLSA
 * \see Ipv4Address
 * \param addr The IP address associated with the LSA.  Typically the Router 
 * ID.
 * \param lsa A pointer to the Link State Advertisement for the router.
 */
  void Insert (Ipv4Address addr, GlobalRoutingLSA* lsa);

/**
 * \brief Look up the Link State Advertisement associated with the given
 * link state ID (address).
 * \internal
 *
 * The database map is searched for the given IPV4 address and corresponding
 * GlobalRoutingLSA is returned.
 *
 * \see GlobalRoutingLSA
 * \see Ipv4Address
 * \param addr The IP address associated with the LSA.  Typically the Router 
 * ID.
 * \returns A pointer to the Link State Advertisement for the router specified
 * by the IP address addr.
 */
  GlobalRoutingLSA* GetLSA (Ipv4Address addr) const;
/**
 * \brief Look up the Link State Advertisement associated with the given
 * link state ID (address).  This is a variation of the GetLSA call
 * to allow the LSA to be found by matching addr with the LinkData field
 * of the TransitNetwork link record.
 * \internal
 *
 * \see GetLSA
 * \param addr The IP address associated with the LSA.  Typically the Router 
 * \returns A pointer to the Link State Advertisement for the router specified
 * by the IP address addr.
 * ID.
 */
  GlobalRoutingLSA* GetLSAByLinkData (Ipv4Address addr) const;

/**
 * \brief Set all LSA flags to an initialized state, for SPF computation
 * \internal
 *
 * This function walks the database and resets the status flags of all of the
 * contained Link State Advertisements to LSA_SPF_NOT_EXPLORED.  This is done
 * prior to each SPF calculation to reset the state of the SPFVertex structures
 * that will reference the LSAs during the calculation.
 *
 * \see GlobalRoutingLSA
 * \see SPFVertex
 */
  void Initialize ();


  std::vector<GlobalRoutingLSA*> m_extdatabase;

/**
 * \brief GlobalRouteManagerLSDB copy construction is disallowed.  There's no 
 * need for it and a compiler provided shallow copy would be wrong.
 */
  GlobalRouteManagerLSDB (GlobalRouteManagerLSDB& lsdb);

/**
 * \brief The SPFVertex copy assignment operator is disallowed.  There's no 
 * need for it and a compiler provided shallow copy would be wrong.
 */
  GlobalRouteManagerLSDB& operator= (GlobalRouteManagerLSDB& lsdb);
};

/**
 * \brief A global router implementation.
 *
 * This singleton object can query interface each node in the system
 * for a GlobalRouter interface.  For those nodes, it fetches one or

  GlobalRouteManagerImpl ();
  virtual ~GlobalRouteManagerImpl ();
/**
 * \brief Delete all static routes on all nodes that have a
 * GlobalRouterInterface
 *
 * TODO:  separate manually assigned static routes from static routes that
 * the global routing code injects, and only delete the latter
 * \internal
 *
 */
  virtual void DeleteGlobalRoutes ();

/**
 * \brief Build the routing database by gathering Link State Advertisements
 * from each node exporting a GlobalRouter interface.
 * \internal
 */
  virtual void BuildGlobalRoutingDatabase ();

/**
 * \brief Compute routes using a Dijkstra SPF computation and populate
 * per-node forwarding tables
 * \internal
 */
  virtual void InitializeRoutes ();

/**
 * \brief Debugging routine; allow client code to supply a pre-built LSDB
 * \internal
 */
  void DebugUseLsdb (GlobalRouteManagerLSDB*);

/**
 * \brief Debugging routine; call the core SPF from the unit tests
 * \internal
 */
  void DebugSPFCalculate (Ipv4Address root);

private:
/**
 * \brief GlobalRouteManagerImpl copy construction is disallowed.
 * There's no  need for it and a compiler provided shallow copy would be 
 * wrong.
 */
  GlobalRouteManagerImpl (GlobalRouteManagerImpl& srmi);

/**
 * \brief Global Route Manager Implementation assignment operator is
 * disallowed.  There's no  need for it and a compiler provided shallow copy
 * would be hopelessly wrong.
 */




namespace ns3 {

/**
 * \brief A global global router
 *
 * This singleton object can query interface each node in the system
 * for a GlobalRouter interface.  For those nodes, it fetches one or

{
public:
/**
 * \brief Allocate a 32-bit router ID from monotonically increasing counter.
 */
  static uint32_t AllocateRouterId ();

/**
 * \brief Delete all static routes on all nodes that have a 
 * GlobalRouterInterface
 *
 */
  static void DeleteGlobalRoutes ();

/**
 * \brief Build the routing database by gathering Link State Advertisements
 * from each node exporting a GlobalRouter interface.
 * \internal
 *
 */
  static void BuildGlobalRoutingDatabase ();

/**
 * \brief Compute routes using a Dijkstra SPF computation and populate
 * per-node forwarding tables
 * \internal
 */
  static void InitializeRoutes ();

private:
/**
 * \brief Global Route Manager copy construction is disallowed.  There's no 
 * need for it and a compiler provided shallow copy would be wrong.
 *
 */
  GlobalRouteManager (GlobalRouteManager& srm);

/**
 * \brief Global Router copy assignment operator is disallowed.  There's no 
 * need for it and a compiler provided shallow copy would be wrong.
 */
  GlobalRouteManager& operator= (GlobalRouteManager& srm);




class Ipv4GlobalRouting;

/**
 * \brief A single link record for a link state advertisement.
 *
 * The GlobalRoutingLinkRecord is modeled after the OSPF link record field of
 * a Link State Advertisement.  Right now we will only see two types of link

public:
  friend class GlobalRoutingLSA;
/**
 * \enum LinkType
 * \brief Enumeration of the possible types of Global Routing Link Records.
 *
 * These values are defined in the OSPF spec.  We currently only use 
 * PointToPoint and StubNetwork types.

  };

/**
 * \brief Construct an empty ("uninitialized") Global Routing Link Record.
 *
 * The Link ID and Link Data Ipv4 addresses are set to "0.0.0.0";
 * The Link Type is set to Unknown;

/**
 * Construct an initialized Global Routing Link Record.
 *
 * \param linkType The type of link record to construct.
 * \param linkId The link ID for the record.
 * \param linkData The link data field for the record.
 * \param metric The metric field for the record.
 * \see LinkType
 * \see SetLinkId
 * \see SetLinkData
 */
  GlobalRoutingLinkRecord (
    LinkType    linkType, 

    uint16_t    metric);

/**
 * \brief Destroy a Global Routing Link Record.
 *
 * Currently does nothing.  Here as a placeholder only.
 */

 * For an OSPF type 3 link (StubNetwork), the Link ID will be the adjacent
 * neighbor's IP address
 *
 * \returns The Ipv4Address corresponding to the Link ID field of the record.
 */
  Ipv4Address GetLinkId (void) const;

/**
 * \brief Set the Link ID field of the Global Routing Link Record.
 *
 * For an OSPF type 1 link (PointToPoint) the Link ID must be the Router ID
 * of the neighboring router.

 * For an OSPF type 3 link (StubNetwork), the Link ID must be the adjacent
 * neighbor's IP address
 *
 * \param addr An Ipv4Address to store in the Link ID field of the record.
 */
  void SetLinkId (Ipv4Address addr);

/**
 * \brief Get the Link Data field of the Global Routing Link Record.
 *
 * For an OSPF type 1 link (PointToPoint) the Link Data will be the IP
 * address of the node of the local side of the link.

 * For an OSPF type 3 link (StubNetwork), the Link Data will be the
 * network mask
 *
 * \returns The Ipv4Address corresponding to the Link Data field of the record.
 */
  Ipv4Address GetLinkData (void) const;

/**
 * \brief Set the Link Data field of the Global Routing Link Record.
 *
 * For an OSPF type 1 link (PointToPoint) the Link Data must be the IP
 * address of the node of the local side of the link.

 * For an OSPF type 3 link (StubNetwork), the Link Data must be set to the
 * network mask
 *
 * \param addr An Ipv4Address to store in the Link Data field of the record.
 */
  void SetLinkData (Ipv4Address addr);

/**
 * \brief Get the Link Type field of the Global Routing Link Record.
 *
 * The Link Type describes the kind of link a given record represents.  The
 * values are defined by OSPF.
 *
 * \see LinkType
 * \returns The LinkType of the current Global Routing Link Record.
 */
  LinkType GetLinkType (void) const;

/**
 * \brief Set the Link Type field of the Global Routing Link Record.
 *
 * The Link Type describes the kind of link a given record represents.  The
 * values are defined by OSPF.
 *
 * \see LinkType
 * \param linkType The new LinkType for the current Global Routing Link Record.
 */
  void SetLinkType (LinkType linkType);

/**
 * \brief Get the Metric Data field of the Global Routing Link Record.
 *
 * The metric is an abstract cost associated with forwarding a packet across
 * a link.  A sum of metrics must have a well-defined meaning.  That is, you

 * two hops relate to the cost of sending a packet); rather you should use
 * something like delay.
 *
 * \returns The metric field of the Global Routing Link Record.
 */
  uint16_t GetMetric (void) const;

/**
 * \brief Set the Metric Data field of the Global Routing Link Record.
 *
 * The metric is an abstract cost associated with forwarding a packet across
 * a link.  A sum of metrics must have a well-defined meaning.  That is, you

 * two hops relate to the cost of sending a packet); rather you should use
 * something like delay.
 *
 * \param metric The new metric for the current Global Routing Link Record.
 */
  void SetMetric (uint16_t metric);


};

/**
 * \brief a Link State Advertisement (LSA) for a router, used in global 
 * routing.
 * 
 * Roughly equivalent to a global incarnation of the OSPF link state header

{
public:
/**
 * \enum LSType
 * \brief corresponds to LS type field of RFC 2328 OSPF LSA header
 */
  enum LSType {
    Unknown = 0,        /**< Uninitialized Type */

    ASExternalLSAs
  };
/**
 * \enum SPFStatus
 * \brief Enumeration of the possible values of the status flag in the Routing 
 * Link State Advertisements.
 */
  enum SPFStatus {

    LSA_SPF_IN_SPFTREE          /**< Vertex is in the SPF tree */
  };
/**
 * \brief Create a blank Global Routing Link State Advertisement.
 *
 * On completion Ipv4Address variables initialized to 0.0.0.0 and the 
 * list of Link State Records is empty.

  GlobalRoutingLSA();

/**
 * \brief Create an initialized Global Routing Link State Advertisement.
 *
 * On completion the list of Link State Records is empty.
 *
 * \param status The status to of the new LSA.
 * \param linkStateId The Ipv4Address for the link state ID field.
 * \param advertisingRtr The Ipv4Address for the advertising router field.
 */
  GlobalRoutingLSA(SPFStatus status, Ipv4Address linkStateId, 
                   Ipv4Address advertisingRtr);

/**
 * \brief Copy constructor for a Global Routing Link State Advertisement.
 *
 * Takes a piece of memory and constructs a semantically identical copy of
 * the given LSA.
 *
 * \param lsa The existing LSA to be used as the source.
 */
  GlobalRoutingLSA (GlobalRoutingLSA& lsa);

/**
 * \brief Destroy an existing Global Routing Link State Advertisement.
 *
 * Any Global Routing Link Records present in the list are freed.
 */
  ~GlobalRoutingLSA();

/**
 * \brief Assignment operator for a Global Routing Link State Advertisement.
 *
 * Takes an existing Global Routing Link State Advertisement and overwrites
 * it to make a semantically identical copy of a given prototype LSA.

 * If there are any Global Routing Link Records present in the existing 
 * LSA, they are freed before the assignment happens.
 *
 * \param lsa The existing LSA to be used as the source.
 * \returns Reference to the overwritten LSA.
 */
  GlobalRoutingLSA& operator= (const GlobalRoutingLSA& lsa);

/**
 * \brief Copy any Global Routing Link Records in a given Global Routing Link
 * State Advertisement to the current LSA.
 * 
 * Existing Link Records are not deleted -- this is a concatenation of Link 
 * Records.
 *
 * \see ClearLinkRecords ()
 * \param lsa The LSA to copy the Link Records from.
 */
  void CopyLinkRecords (const GlobalRoutingLSA& lsa);

/**
 * \brief Add a given Global Routing Link Record to the LSA.
 *
 * \param lr The Global Routing Link Record to be added.
 * \returns The number of link records in the list.
 */
  uint32_t AddLinkRecord (GlobalRoutingLinkRecord* lr);

/**
 * \brief Return the number of Global Routing Link Records in the LSA.
 *
 * \returns The number of link records in the list.
 */
  uint32_t GetNLinkRecords (void) const;

/**
 * \brief Return a pointer to the specified Global Routing Link Record.
 *
 * \param n The LSA number desired.
 * \returns The number of link records in the list.
 */
  GlobalRoutingLinkRecord* GetLinkRecord (uint32_t n) const;

/**
 * \brief Release all of the Global Routing Link Records present in the Global
 * Routing Link State Advertisement and make the list of link records empty.
 */
  void ClearLinkRecords (void);

/**
 * \brief Check to see if the list of Global Routing Link Records present in the
 * Global Routing Link State Advertisement is empty.
 *
 * \returns True if the list is empty, false otherwise.
 */
  bool IsEmpty (void) const;

/**
 * \brief Print the contents of the Global Routing Link State Advertisement and
 * any Global Routing Link Records present in the list.  Quite verbose.
 */
  void Print (std::ostream &os) const;

/**
 * \brief Return the LSType field of the LSA 
 */
  LSType GetLSType (void) const;
/**
 * \brief Set the LS type field of the LSA
 */
  void SetLSType (LSType typ);

/**
 * \brief Get the Link State ID as defined by the OSPF spec.  We always set it
 * to the router ID of the router making the advertisement.
 *
 * \see RoutingEnvironment::AllocateRouterId ()
 * \see GlobalRouting::GetRouterId ()
 * \returns The Ipv4Address stored as the link state ID.
 */
  Ipv4Address GetLinkStateId (void) const;

/**
 * \brief Set the Link State ID is defined by the OSPF spec.  We always set it
 * to the router ID of the router making the advertisement.
 * \param addr IPv4 address which will act as ID
 * \see RoutingEnvironment::AllocateRouterId ()
 * \see GlobalRouting::GetRouterId ()
 */
  void SetLinkStateId (Ipv4Address addr);

/**
 * \brief Get the Advertising Router as defined by the OSPF spec.  We always
 * set it to the router ID of the router making the advertisement.
 *
 * \see RoutingEnvironment::AllocateRouterId ()
 * \see GlobalRouting::GetRouterId ()
 * \returns The Ipv4Address stored as the advertising router.
 */
  Ipv4Address GetAdvertisingRouter (void) const;

/**
 * \brief Set the Advertising Router as defined by the OSPF spec.  We always
 * set it to the router ID of the router making the advertisement.
 *
 * \param rtr ID of the router making advertisement
 * \see RoutingEnvironment::AllocateRouterId ()
 * \see GlobalRouting::GetRouterId ()
 */
  void SetAdvertisingRouter (Ipv4Address  rtr);

/**
 * \brief For a Network LSA, set the Network Mask field that precedes
 * the list of attached routers.
 */
  void SetNetworkLSANetworkMask (Ipv4Mask mask);

/**
 * \brief For a Network LSA, get the Network Mask field that precedes
 * the list of attached routers.
 * 
 * \returns the NetworkLSANetworkMask 
 */
  Ipv4Mask GetNetworkLSANetworkMask (void) const;

/**
 * \brief Add an attached router to the list in the NetworkLSA
 *
 * \param addr The Ipv4Address of the interface on the network link
 * \returns The number of addresses in the list.
 */
  uint32_t AddAttachedRouter (Ipv4Address addr);

/**
 * \brief Return the number of attached routers listed in the NetworkLSA
 *
 * \returns The number of attached routers.
 */
  uint32_t GetNAttachedRouters (void) const;

/**
 * \brief Return an Ipv4Address corresponding to the specified attached router
 *
 * \param n The attached router number desired (number in the list).
 * \returns The Ipv4Address of the requested router
 */
  Ipv4Address GetAttachedRouter (uint32_t n) const;

/**
 * \brief Get the SPF status of the advertisement.
 *
 * \see SPFStatus
 * \returns The SPFStatus of the LSA.
 */
  SPFStatus GetStatus (void) const;

/**
 * \brief Set the SPF status of the advertisement
 * \param status SPF status to set
 * \see SPFStatus
 */
  void SetStatus (SPFStatus status);

/**
 * \brief Get the Node pointer of the node that originated this LSA
 * \returns Node pointer
 */
  Ptr<Node> GetNode (void) const;

/**
 * \brief Set the Node pointer of the node that originated this LSA
 * \param node Node pointer
 */
  void SetNode (Ptr<Node> node);


 * The Link State ID is defined by the OSPF spec.  We always set it to the
 * router ID of the router making the advertisement.
 *
 * \see RoutingEnvironment::AllocateRouterId ()
 * \see GlobalRouting::GetRouterId ()
 */
  Ipv4Address  m_linkStateId;


 * The Advertising Router is defined by the OSPF spec.  We always set it to 
 * the router ID of the router making the advertisement.
 *
 * \see RoutingEnvironment::AllocateRouterId ()
 * \see GlobalRouting::GetRouterId ()
 */
  Ipv4Address  m_advertisingRtr;


 * m_linkRecords is an STL list container to hold the Link Records that have
 * been discovered and prepared for the advertisement.
 *
 * \see GlobalRouting::DiscoverLSAs ()
 */
  ListOfLinkRecords_t m_linkRecords;


 * m_attachedRouters is an STL list container to hold the addresses that have
 * been discovered and prepared for the advertisement.
 *
 * \see GlobalRouting::DiscoverLSAs ()
 */
  ListOfAttachedRouters_t m_attachedRouters;


std::ostream& operator<< (std::ostream& os, GlobalRoutingLSA& lsa);

/**
 * \brief An interface aggregated to a node to provide global routing info
 *
 * An interface aggregated to a node that provides global routing information
 * to a global route manager.  The presence of the interface indicates that

{
public:
/**
 * \brief The Interface ID of the Global Router interface.
 *
 * \see Object::GetObject ()
 */
  static TypeId GetTypeId (void);

/**
 * \brief Create a Global Router class 
 */
  GlobalRouter ();


  Ptr<Ipv4GlobalRouting> GetRoutingProtocol (void);

/**
 * \brief Get the Router ID associated with this Global Router.
 *
 * The Router IDs are allocated in the RoutingEnvironment -- one per Router, 
 * starting at 0.0.0.1 and incrementing with each instantiation of a router.
 *
 * \see RoutingEnvironment::AllocateRouterId ()
 * \returns The Router ID associated with the Global Router.
 */
  Ipv4Address GetRouterId (void) const;

/**
 * \brief Walk the connected channels, discover the adjacent routers and build
 * the associated number of Global Routing Link State Advertisements that 
 * this router can export.
 *

 * advertisements after a network topology change by calling DiscoverLSAs 
 * and then by reading those advertisements.
 *
 * \see GlobalRoutingLSA
 * \see GlobalRouter::GetLSA ()
 * \returns The number of Global Routing Link State Advertisements.
 */
  uint32_t DiscoverLSAs (void);

/**
 * \brief Get the Number of Global Routing Link State Advertisements that this
 * router can export.
 *
 * To get meaningful information you must have previously called DiscoverLSAs.
 * After you know how many LSAs are present in the router, you may call 
 * GetLSA () to retrieve the actual advertisement.
 *
 * \see GlobalRouterLSA
 * \see GlobalRouting::DiscoverLSAs ()
 * \see GlobalRouting::GetLSA ()
 * \returns The number of Global Routing Link State Advertisements.
 */
  uint32_t GetNumLSAs (void) const;

/**
 * \brief Get a Global Routing Link State Advertisements that this router has 
 * said that it can export.
 *
 * This is a fairly inexpensive expensive operation in that the hard work

 * The parameter n (requested LSA number) must be in the range 0 to 
 * GetNumLSAs() - 1.
 *
 * \see GlobalRoutingLSA
 * \see GlobalRouting::GetNumLSAs ()
 * \param n The index number of the LSA you want to read.
 * \param lsa The GlobalRoutingLSA class to receive the LSA information.
 * \returns The number of Global Router Link State Advertisements.
 */
  bool GetLSA (uint32_t n, GlobalRoutingLSA &lsa) const;

/**
 * \brief Inject a route to be circulated to other routers as an external
 * route
 *
 * \param network The Network to inject
 * \param networkMask The Network Mask to inject
 */
  void InjectRoute (Ipv4Address network, Ipv4Mask networkMask);

/**
 * \brief Get the number of injected routes that have been added
 * to the routing table.
 * \return number of injected routes
 */
  uint32_t GetNInjectedRoutes (void);

/**
 * \brief Return the injected route indexed by i
 * \param i the index of the route
 * \return a pointer to that Ipv4RoutingTableEntry is returned
 *
 */
  Ipv4RoutingTableEntry *GetInjectedRoute (uint32_t i);

/**
 * \brief Withdraw a route from the global unicast routing table.
 *
 * Calling this function will cause all indexed routes numbered above
 * index i to have their index decremented.  For instance, it is possible to
 * remove N injected routes by calling RemoveInjectedRoute (0) N times.
 *
 * \param i The index (into the injected routing list) of the route to remove.
 *
 * \see GlobalRouter::WithdrawRoute ()
 */
  void RemoveInjectedRoute (uint32_t i);

/**
 * \brief Withdraw a route from the global unicast routing table.
 *
 * \param network The Network to withdraw
 * \param networkMask The Network Mask to withdraw
 * \return whether the operation succeeded (will return false if no such route)
 *
 * \see GlobalRouter::RemoveInjectedRoute ()
 */
  bool WithdrawRoute (Ipv4Address network, Ipv4Mask networkMask);


  virtual void DoDispose (void);

/**
 * \brief Global Router copy construction is disallowed.
 */
  GlobalRouter (GlobalRouter& sr);

/**
 * \brief Global Router assignment operator is disallowed.
 */
  GlobalRouter& operator= (GlobalRouter& sr);
};

(-)a/src/internet/model/ipv4-header.h (-1 / +1 lines)

Lines 111-117	Link Here

111

};

111

};

112

/**

112

/**

113

   * \brief Set ECN Field

113

   * \brief Set ECN Field

114

   * \param ECN Type

114

   * \param ecn ECN Type

115

*/

115

*/

116

  void SetEcn (EcnType ecn);

116

  void SetEcn (EcnType ecn);

117

/**

117

/**

(-)a/src/internet/model/nsc-tcp-socket-impl.cc (-1 / +1 lines)

Lines 136-142	Link Here

136

       * when DeAllocate is called, it will call into

136

       * when DeAllocate is called, it will call into

137

       * Ipv4EndPointDemux::Deallocate which triggers

137

       * Ipv4EndPointDemux::Deallocate which triggers

138

       * a delete of the associated endPoint which triggers

138

       * a delete of the associated endPoint which triggers

139

       * in turn a call to the method ::Destroy below

139

       * in turn a call to the method NscTcpSocketImpl::Destroy below

140

       * will will zero the m_endPoint field.

140

       * will will zero the m_endPoint field.

141

*/

141

*/

142

      NS_ASSERT (m_endPoint != 0);

142

      NS_ASSERT (m_endPoint != 0);

(-)a/src/internet/model/sim_interface.h (-1 / +1 lines)

Lines 125-131	Link Here

125

126

  /** Simple interface to support sending any textual command to a stack

126

  /** Simple interface to support sending any textual command to a stack

127

128

   * @returns 0 on success

128

   * \returns 0 on success

129

*/

129

*/

130

  virtual int cmd (const char *)

130

  virtual int cmd (const char *)

131

(-)a/src/internet/model/udp-socket-impl.cc (-1 / +1 lines)

Lines 84-90	Link Here

       * when DeAllocate is called, it will call into

       * when DeAllocate is called, it will call into

       * Ipv4EndPointDemux::Deallocate which triggers

       * Ipv4EndPointDemux::Deallocate which triggers

       * a delete of the associated endPoint which triggers

       * a delete of the associated endPoint which triggers

       * in turn a call to the method ::Destroy below

       * in turn a call to the method UdpSocketImpl::Destroy below

       * will will zero the m_endPoint field.

       * will will zero the m_endPoint field.

*/

*/

      NS_ASSERT (m_endPoint != 0);

      NS_ASSERT (m_endPoint != 0);





private:
  /**
   * \param txPower set of values vs frequency representing the
   * transmission power. See SpectrumChannel for details.
   *
   * \param a sender mobility
   * \param b receiver mobility
   *
   * \return set of values vs frequency representing the received
   * power in the same units used for the txPower parameter.
   */
  Ptr<SpectrumValue> DoCalcRxPowerSpectralDensity (Ptr<const SpectrumValue> txPsd,




  /**
   * Get the SpectrumType used by this PHY
   *
   * \return
   */
  SpectrumType GetSpectrumType ();


  /**
   * set the Power Spectral Density of outgoing signals in W/Hz.
   *
   * \param txPsd
   */
  void SetTxPowerSpectralDensity (Ptr<SpectrumValue> txPsd);

  /**
   * \brief set the noise power spectral density
   * \param noisePsd the Noise Power Spectral Density in power units
   * (Watt, Pascal...) per Hz.
   */
  void SetNoisePowerSpectralDensity (Ptr<const SpectrumValue> noisePsd);

  /**
   * \brief get the noise power spectral density
   * \return the Noise Power Spectral Density
   */
  Ptr<const SpectrumValue> GetNoisePowerSpectralDensity (void);


   * Start a transmission
   *
   *
   * \param pb the burst of packets to be transmitted
   *
   * \return true if an error occurred and the transmission was not
   * started, false otherwise.
   */
  bool StartTx (Ptr<PacketBurst> pb);

   * set the callback for the end of a TX, as part of the
   * interconnections betweenthe PHY and the MAC
   *
   * \param c the callback
   */
  void SetGenericPhyTxEndCallback (GenericPhyTxEndCallback c);


   * set the callback for the start of RX, as part of the
   * interconnections betweenthe PHY and the MAC
   *
   * \param c the callback
   */
  void SetGenericPhyRxStartCallback (GenericPhyRxStartCallback c);


   * set the callback for the end of a RX in error, as part of the
   * interconnections betweenthe PHY and the MAC
   *
   * \param c the callback
   */
  void SetGenericPhyRxEndErrorCallback (GenericPhyRxEndErrorCallback c);


   * set the callback for the successful end of a RX, as part of the
   * interconnections betweenthe PHY and the MAC
   *
   * \param c the callback
   */
  void SetGenericPhyRxEndOkCallback (GenericPhyRxEndOkCallback c);


(-)a/src/mesh/helper/mesh-stack-installer.h (-1 / +2 lines)

Lines 28-34	Link Here

 * \brief Prototype for class, which helps to install MAC-layer

 * \brief Prototype for class, which helps to install MAC-layer

 * routing stack to ns3::MeshPointDevice

 * routing stack to ns3::MeshPointDevice

 * \details You need to create a  MeshPointDevice and attach all

 * You need to create a MeshPointDevice and attach all

 * interfaces to it, than call Install method

 * interfaces to it, than call Install method

*/

*/

class MeshStack : public Object

class MeshStack : public Object




/**
 * \ingroup dot11s
 *
 * \brief Airtime link metric calculator
 *
 * Airtime link metric is defined in 11B.10 of 802.11s Draft D3.0 as:
 *
 * airtime = (O + Bt/r)* (1 + average retry counter), where:
 * - o  -- the PHY dependent channel access which includes frame headers, training sequences,
 * o  -- the PHY dependent channel access which includes frame headers, training sequences,
 *       access protocol frames, etc.
 * - bt -- the test packet length in bits (8192 by default),
 * - r  -- the current bitrate of the packet,
 *
 * Final result is expressed in units of 0.01 Time Unit = 10.24 us (as required by 802.11s draft)
 */

(-)a/src/mesh/model/dot11s/hwmp-tag.h (-1 / +1 lines)

Lines 34-40	Link Here

 * \brief Hwmp tag implements interaction between HWMP

 * \brief Hwmp tag implements interaction between HWMP

 * protocol and MeshWifiMac

 * protocol and MeshWifiMac

 * \details Hwmp tag keeps the following:

 * Hwmp tag keeps the following:

 * 1. When packet is passed from Hwmp to 11sMAC:

 * 1. When packet is passed from Hwmp to 11sMAC:

 *  - retransmitter address,

 *  - retransmitter address,

 *  - TTL value,

 *  - TTL value,

(-)a/src/mesh/model/dot11s/peer-link-frame.h (-3 / +3 lines)

Lines 34-42	Link Here

/**

/**

 * \ingroup dot11s

 * \ingroup dot11s

 * \brief 802.11s Peer link management frame:

 * \brief 802.11s Peer link management frame

 * \details included the following (see chapters 7.4.12.1-7.4.12.3 of

 * 802.11s):

 * Peer link management frame included the following (see chapters 7.4.12.1-7.4.12.3 of 802.11s):

 * - Subtype field

 * - Subtype field

 * - Association ID field

 * - Association ID field

 * - Supported rates

 * - Supported rates




  PeerLink& operator= (const PeerLink &);
  PeerLink (const PeerLink &);

  /// The number of interface I am associated with
  uint32_t m_interface;
  /// pointer to MAC plugin, which is responsible for peer management
  Ptr<PeerManagementProtocolMac> m_macPlugin;
  /// Peer address
  Mac48Address m_peerAddress;
  /// Mesh point address, equal to peer address in case of single
  /// interface mesh point
  Mac48Address m_peerMeshPointAddress;
  /// My ID of this link
  uint16_t m_localLinkId;

  EventId  m_beaconLossTimer;
  uint16_t m_maxBeaconLoss;
  uint16_t m_maxPacketFail;
  // \}
  /// How to report my status change
  SignalStatusCallback m_linkStatusCallback;
};




  PeerManagementProtocolMac (uint32_t interface, Ptr<PeerManagementProtocol> protocol);
  ~PeerManagementProtocolMac ();
  ///\name Inherited from plugin abstract class
  // \{
  void SetParent (Ptr<MeshWifiInterfaceMac> parent);
  bool Receive (Ptr<Packet> packet, const WifiMacHeader & header);
  bool UpdateOutcomingFrame (Ptr<Packet> packet, WifiMacHeader & header, Mac48Address from, Mac48Address to);
  void UpdateBeacon (MeshWifiBeacon & beacon) const;
  // \}
  ///\name Statistics
  // \{
  void Report (std::ostream &) const;
  void ResetStats ();
  uint32_t GetLinkMetric (Mac48Address peerAddress);
  // \}
private:
  PeerManagementProtocolMac& operator= (const PeerManagementProtocolMac &);
  PeerManagementProtocolMac (const PeerManagementProtocolMac &);

  friend class PeerManagementProtocol;
  friend class PeerLink;
  ///\name Create peer link management frames
  // \{
  /**
   * \brief This structure keeps all fields in peer link management frame,
   * which are not subclasses of WifiInformationElement
   */
  struct PlinkFrameStart
  {
    uint8_t subtype;

  Ptr<Packet> CreatePeerLinkOpenFrame ();
  Ptr<Packet> CreatePeerLinkConfirmFrame ();
  Ptr<Packet> CreatePeerLinkCloseFrame ();
  /// Parses the start of the frame, where no WifiInformationElements exist
   * \brief This structure keeps all fields in peer link management frame,
   * which are not subclasses of WifiInformationElement
   */
  /// \name Parses the start of the frame, where there are no
  /// WifiInformationElements exist
  PlinkFrameStart ParsePlinkFrame (Ptr<const Packet> packet);
  // \}
  ///  Closes link when a proper number of successive transmissions have failed
  void TxError (WifiMacHeader const &hdr);
  void TxOk (WifiMacHeader const &hdr);
  /// BCA functionality
  void SetBeaconShift (Time shift);
  void SetPeerManagerProtcol (Ptr<PeerManagementProtocol> protocol);
  void SendPeerLinkManagementFrame (

    IePeerManagement peerElement,
    IeConfiguration meshConfig
    );
  ///\brief debug only, used to print established links
  Mac48Address GetAddress () const;
  ///\name Statistics
  // \{
  struct Statistics
  {
    uint16_t txOpen;

  struct Statistics m_stats;
  ///\}
  ///\name Information about MAC and protocol:
  // \{
  Ptr<MeshWifiInterfaceMac> m_parent;
  uint32_t m_ifIndex;
  Ptr<PeerManagementProtocol> m_protocol;
  // \}
};

} // namespace dot11s




   * \param beaconTiming beacon timing element (needed by BCA)
   */
  void ReceiveBeacon (uint32_t interface, Mac48Address peerAddress, Time beaconInterval, Ptr<IeBeaconTiming> beaconTiming);
  // \}
  /**
   * \brief Methods that handle Peer link management frames
   * interaction:

   * \brief Checks if there is established link
   */
  bool IsActiveLink (uint32_t interface, Mac48Address peerAddress);
  // \}
  ///\name Interface to other protocols (MLME)
  // \{
  /// Set peer link status change callback
  void SetPeerLinkStatusCallback (Callback<void, Mac48Address, Mac48Address, uint32_t, bool> cb);
  /// Find active peer link by my interface and peer interface MAC

  void Report (std::ostream &) const;
  void ResetStats ();
private:
  /**
   * \name Private structures
   * \{
   */
  /// Keeps information about beacon of peer station: beacon interval, association ID, last time we have received a beacon

  typedef std::map<uint32_t, BeaconsOnInterface> BeaconInfoMap;
  ///\brief this vector keeps pointers to MAC-plugins
  typedef std::map<uint32_t, Ptr<PeerManagementProtocolMac> > PeerManagementProtocolMacMap;
  // \}
private:
  PeerManagementProtocol& operator= (const PeerManagementProtocol &);
  PeerManagementProtocol (const PeerManagementProtocol &);

   */
  Time TuToTime (uint32_t x);
  uint32_t TimeToTu (Time x);
  // \}

  /// Aux. method to register open links
  void NotifyLinkOpen (Mac48Address peerMp, Mac48Address peerIface, Mac48Address myIface, uint32_t interface);

  bool m_enableBca;
  /// Beacon can be shifted at [-m_maxBeaconShift; +m_maxBeaconShift] TUs
