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
  uint16_t m_maxBeaconShift;
  /// Last beacon at each interface
  std::map<uint32_t, Time> m_lastBeacon;
  /// Beacon interval at each interface
  std::map<uint32_t, Time> m_beaconInterval;

  /**

  LinkEventCallback m_linkCloseTraceSrc;

  ///\name Statistics:
  // \{
  struct Statistics {
    uint16_t linksTotal;
    uint16_t linksOpened;

    void Print (std::ostream & os) const;
  };
  struct Statistics m_stats;
  // \}
};

} // namespace dot11s

(-)a/src/mesh/model/mesh-wifi-beacon.h (-1 / +1 lines)

Lines 58-64	Link Here

   * \param mpAddress is mesh point address

   * \param mpAddress is mesh point address

*/

*/

  WifiMacHeader CreateHeader (Mac48Address address, Mac48Address mpAddress);

  WifiMacHeader CreateHeader (Mac48Address address, Mac48Address mpAddress);

  ///Returns a beacon interval of wifi beacon

  /// Returns a beacon interval of wifi beacon

  Time GetBeaconInterval () const;

  Time GetBeaconInterval () const;

  /// Create frame = { beacon header + all information elements sorted by ElementId () }

  /// Create frame = { beacon header + all information elements sorted by ElementId () }

  Ptr<Packet> CreatePacket ();

  Ptr<Packet> CreatePacket ();




  virtual ~MeshWifiInterfaceMac ();

  ///\name Inherited from WifiMac
  // \{
  virtual void  Enqueue (Ptr<const Packet> packet, Mac48Address to, Mac48Address from);
  virtual void  Enqueue (Ptr<const Packet> packet, Mac48Address to);
  virtual bool  SupportsSendFrom () const;
  virtual void  SetLinkUpCallback (Callback<void> linkUp);
  // \}
  ///\name Each mesh point interfaces must know the mesh point address
  // \{
  void SetMeshPointAddress (Mac48Address);
  Mac48Address GetMeshPointAddress () const;
  // \}
  ///\name Beacons
  // \{
  /// Set maximum initial random delay before first beacon
  void SetRandomStartDelay (Time interval);
  /// Set interval between two successive beacons

   * \attention User of ShiftTbtt () must take care to not shift it to the past.
   */
  void ShiftTbtt (Time shift);
  // \}

  ///\name Plugins
  // \{
  /// Install plugin. TODO return unique ID to allow unregister plugins
  void InstallPlugin (Ptr<MeshWifiInterfaceMacPlugin> plugin);
  // \}

  /** \name Channel switching
   *

   *
   * Number of channels to use must be limited elsewhere.
   */
  // \{
  /// Current channel Id
  uint16_t GetFrequencyChannel () const;
  /// Switch channel
  void SwitchFrequencyChannel (uint16_t new_id);
  // \}

  /// To be used by plugins sending management frames.
  void SendManagementFrame (Ptr<Packet> frame, const WifiMacHeader& hdr);

  bool CheckSupportedRates (SupportedRates rates) const;
  /// \return list of supported bitrates
  SupportedRates GetSupportedRates () const;
  ///\name Metric Calculation routines:
  // \{
  void SetLinkMetricCallback (Callback<uint32_t, Mac48Address, Ptr<MeshWifiInterfaceMac> > cb);
  uint32_t GetLinkMetric (Mac48Address peerAddress);
  // \}
  ///\brief Statistics:
  void Report (std::ostream &) const;
  void ResetStats ();

  typedef std::vector<Ptr<MeshWifiInterfaceMacPlugin> > PluginList;

  ///\name Mesh timing intervals
  // \{
  /// Beaconing interval.
  Time m_beaconInterval;
  /// Maximum delay before first beacon
  Time m_randomStart;
  /// Time for the next frame
  Time m_tbtt;
  // \}

  /// Mesh point address
  Mac48Address m_mpAddress;

  PluginList m_plugins;
  Callback<uint32_t, Mac48Address, Ptr<MeshWifiInterfaceMac> > m_linkMetricCallback;
  ///\name Statistics:
  // \{
  struct Statistics
  {
    uint16_t recvBeacons;

    Statistics ();
  };
  Statistics m_stats;
  // \}
  /// Current PHY standard: needed to configure metric
  WifiPhyStandard m_standard;
};

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

Lines 1-5	Link Here

/**

/**

 * @defgroup mobility Mobility

 * \defgroup mobility Mobility

*/

*/

/**

/**




  };

  /**
   * \brief Create a pcap helper.
   */
  PcapHelper ();

  /**
   * \brief Destroy a pcap helper.
   */
  ~PcapHelper ();

  /**
   * \brief Let the pcap helper figure out a reasonable filename to use for a
   * pcap file associated with a device.
   */
  std::string GetFilenameFromDevice (std::string prefix, Ptr<NetDevice> device, bool useObjectNames = true);

  /**
   * \brief Let the pcap helper figure out a reasonable filename to use for the
   * pcap file associated with a node.
   */
  std::string GetFilenameFromInterfacePair (std::string prefix, Ptr<Object> object, 
                                            uint32_t interface, bool useObjectNames = true);

  /**
   * \brief Create and initialize a pcap file.
   */
  Ptr<PcapFileWrapper> CreateFile (std::string filename, std::ios::openmode filemode,
                                   uint32_t dataLinkType,  uint32_t snapLen = 65535, int32_t tzCorrection = 0);
  /**
   * \brief Hook a trace source to the default trace sink
   */
  template <typename T> void HookDefaultSink (Ptr<T> object, std::string traceName, Ptr<PcapFileWrapper> file);


{
public:
  /**
   * \brief Create an ascii trace helper.
   */
  AsciiTraceHelper ();

  /**
   * \brief Destroy an ascii trace helper.
   */
  ~AsciiTraceHelper ();

  /**
   * \brief Let the ascii trace helper figure out a reasonable filename to use
   * for an ascii trace file associated with a device.
   */
  std::string GetFilenameFromDevice (std::string prefix, Ptr<NetDevice> device, bool useObjectNames = true);

  /**
   * \brief Let the ascii trace helper figure out a reasonable filename to use
   * for an ascii trace file associated with a node.
   */
  std::string GetFilenameFromInterfacePair (std::string prefix, Ptr<Object> object, 
                                            uint32_t interface, bool useObjectNames = true);

  /**
   * \brief Create and initialize an output stream object we'll use to write the 
   * traced bits.
   *
   * One of the common issues users run into when trying to use tracing in ns-3

                                             std::ios::openmode filemode = std::ios::out);

  /**
   * \brief Hook a trace source to the default enqueue operation trace sink that
   * does not accept nor log a trace context.
   */
  template <typename T> 
  void HookDefaultEnqueueSinkWithoutContext (Ptr<T> object, std::string traceName, Ptr<OutputStreamWrapper> stream);

  /**
   * \brief Hook a trace source to the default enqueue operation trace sink that
   * does accept and log a trace context.
   */
  template <typename T> 

                                          std::string context, std::string traceName, Ptr<OutputStreamWrapper> stream);

  /**
   * \brief Hook a trace source to the default drop operation trace sink that 
   * does not accept nor log a trace context.
   */
  template <typename T> 
  void HookDefaultDropSinkWithoutContext (Ptr<T> object, std::string traceName, Ptr<OutputStreamWrapper> stream);

  /**
   * \brief Hook a trace source to the default drop operation trace sink that 
   * does accept and log a trace context.
   */
  template <typename T> 

                                       std::string context, std::string traceName, Ptr<OutputStreamWrapper> stream);

  /**
   * \brief Hook a trace source to the default dequeue operation trace sink
   * that does not accept nor log a trace context.
   */
  template <typename T> 
  void HookDefaultDequeueSinkWithoutContext (Ptr<T> object, std::string traceName, Ptr<OutputStreamWrapper> stream);

  /**
   * \brief Hook a trace source to the default dequeue operation trace sink
   * that does accept and log a trace context.
   */
  template <typename T> 

                                          std::string context, std::string traceName, Ptr<OutputStreamWrapper> stream);

  /**
   * \brief Hook a trace source to the default receive operation trace sink
   * that does not accept nor log a trace context.
   */
  template <typename T> 
  void HookDefaultReceiveSinkWithoutContext (Ptr<T> object, std::string traceName, Ptr<OutputStreamWrapper> stream);

  /**
   * \brief Hook a trace source to the default receive operation trace sink
   * that does accept and log a trace context.
   */
  template <typename T> 

{
public:
  /**
   * \brief Construct a PcapHelperForDevice
   */
  PcapHelperForDevice () {}

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

  /**
   * \brief Enable pcap output the indicated net device.
   * \internal
   *
   * \param prefix Filename prefix to use for pcap files.
   * \param nd Net device for which you want to enable tracing.
   * \param promiscuous If true capture all possible packets available at the device.
   * \param explicitFilename Treat the prefix as an explicit filename if true
   */
  virtual void EnablePcapInternal (std::string prefix, Ptr<NetDevice> nd, bool promiscuous, bool explicitFilename) = 0;

  /**
   * \brief Enable pcap output the indicated net device.
   *
   * \param prefix Filename prefix to use for pcap files.
   * \param nd Net device for which you want to enable tracing.
   * \param promiscuous If true capture all possible packets available at the device.
   * \param explicitFilename Treat the prefix as an explicit filename if true
   */
  void EnablePcap (std::string prefix, Ptr<NetDevice> nd, bool promiscuous = false, bool explicitFilename = false);

  /**
   * \brief Enable pcap output the indicated net device using a device previously
   * named using the ns-3 object name service.
   *
   * \param prefix filename prefix to use for pcap files.
   * \param ndName The name of the net device in which you want to enable tracing.
   * \param promiscuous If true capture all possible packets available at the device.
   * \param explicitFilename Treat the prefix as an explicit filename if true
   */
  void EnablePcap (std::string prefix, std::string ndName, bool promiscuous = false, bool explicitFilename = false);

  /**
   * \brief Enable pcap output on each device in the container which is of the 
   * appropriate type.
   *
   * \param prefix Filename prefix to use for pcap files.
   * \param d container of devices of type ns3::CsmaNetDevice
   * \param promiscuous If true capture all possible packets available at the device.
   */
  void EnablePcap (std::string prefix, NetDeviceContainer d, bool promiscuous = false);

  /**
   * \brief Enable pcap output on each device (which is of the appropriate type)
   * in the nodes provided in the container.
   *
   * \param prefix Filename prefix to use for pcap files.

  void EnablePcap (std::string prefix, NodeContainer n, bool promiscuous = false);

  /**
   * \brief Enable pcap output on the device specified by a global node-id (of
   * a previously created node) and associated device-id.
   *
   * \param prefix Filename prefix to use for pcap files.
   * \param nodeid the node id
   * \param deviceid the device id
   * \param promiscuous If true capture all possible packets available at the device.
   */
  void EnablePcap (std::string prefix, uint32_t nodeid, uint32_t deviceid, bool promiscuous = false);

  /**
   * \brief Enable pcap output on each device (which is of the appropriate type)
   * in the set of all nodes created in the simulation.
   *
   * \param prefix Filename prefix to use for pcap files.
   * \param promiscuous If true capture all possible packets available at the device.
   */
  void EnablePcapAll (std::string prefix, bool promiscuous = false);
};

{
public:
  /**
   * \brief Construct an AsciiTraceHelperForDevice.
   */
  AsciiTraceHelperForDevice () {}

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

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

   * trace context could be important, so the device 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 nd Net device for which you want to enable tracing
   * \param explicitFilename Treat the prefix as an explicit filename if true
   */
  virtual void EnableAsciiInternal (Ptr<OutputStreamWrapper> stream, 
                                    std::string prefix, 

                                    bool explicitFilename) = 0;

  /**
   * \brief Enable ascii trace output on the indicated net device.
   *
   * \param prefix Filename prefix to use for ascii files.
   * \param nd Net device for which you want to enable tracing.
   * \param explicitFilename Treat the prefix as an explicit filename if true
   */
  void EnableAscii (std::string prefix, Ptr<NetDevice> nd, bool explicitFilename = false);

  /**
   * \brief Enable ascii trace output on the indicated net device.
   *
   * \param stream An OutputStreamWrapper representing an existing file to use
   *               when writing trace data.
   * \param nd Net device for which you want to enable tracing.
   */
  void EnableAscii (Ptr<OutputStreamWrapper> stream, Ptr<NetDevice> nd);

  /**
   * \brief Enable ascii trace output the indicated net device using a device 
   * previously named using the ns-3 object name service.
   *
   * \param prefix filename prefix to use for ascii files.
   * \param ndName The name of the net device in which you want to enable tracing.
   * \param explicitFilename Treat the prefix as an explicit filename if true
   */
  void EnableAscii (std::string prefix, std::string ndName, 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 ndName The name of the net device in which you want to enable tracing.
   */
  void EnableAscii (Ptr<OutputStreamWrapper> stream, std::string ndName);

  /**
   * \brief Enable ascii trace output on each device in the container which is
   * of the appropriate type.
   *
   * \param prefix Filename prefix to use for ascii files.
   * \param d container of devices of type ns3::CsmaNetDevice
   */
  void EnableAscii (std::string prefix, NetDeviceContainer d);

  /**
   * \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 d container of devices of type ns3::CsmaNetDevice
   */
  void EnableAscii (Ptr<OutputStreamWrapper> stream, NetDeviceContainer d);

  /**
   * \brief Enable ascii trace output on each device (which is of the 
   * appropriate type) in the nodes provided in the container.
   *
   * \param prefix Filename prefix to use for ascii files.

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

  /**
   * \brief Enable ascii trace output on each device (which is of the 
   * appropriate type) 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 EnableAscii (Ptr<OutputStreamWrapper> stream, NodeContainer n);

  /**
   * \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 prefix Filename prefix to use for ascii files.
   */
  void EnableAsciiAll (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 EnableAsciiAll (Ptr<OutputStreamWrapper> stream);

  /**
   * \brief Enable ascii trace output on the device specified by a global 
   * node-id (of a previously created node) and associated device-id.
   *
   * \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 EnableAscii (std::string prefix, uint32_t nodeid, uint32_t deviceid, bool explicitFilename);

  /**
   * \brief Enable ascii trace output on the device specified by a global 
   * node-id (of a previously created node) and associated device-id.
   *
   * \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 deviceid The device identifier/index of the device on which to enable
   *               ascii tracing
   */
  void EnableAscii (Ptr<OutputStreamWrapper> stream, uint32_t nodeid, uint32_t deviceid);

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

                        bool explicitFilename);

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

  /**
   * \internal Avoid code duplication.
   */
  void EnableAsciiImpl (Ptr<OutputStreamWrapper> stream, std::string prefix, NetDeviceContainer d);

  /**
   * \internal Avoid code duplication.
   */
  void EnableAsciiImpl (Ptr<OutputStreamWrapper> stream, std::string prefix, std::string ndName, bool explicitFilename);

  /**
   * \internal Avoid code duplication.
   */
  void EnableAsciiImpl (Ptr<OutputStreamWrapper> stream, std::string prefix, Ptr<NetDevice> nd, bool explicitFilename);
};

(-)a/src/network/model/buffer.h (-2 / +2 lines)

Lines 514-521	Link Here

514

/**

514

/**

515

   * Copy the specified amount of data from the buffer to the given output stream.

515

   * Copy the specified amount of data from the buffer to the given output stream.

516

517

   * @param os the output stream

517

   * \param os the output stream

518

   * @param size the maximum amount of bytes to copy. If zero, nothing is copied.

518

   * \param size the maximum amount of bytes to copy. If zero, nothing is copied.

519

*/

519

*/

520

  void CopyData (std::ostream *os, uint32_t size) const;

520

  void CopyData (std::ostream *os, uint32_t size) const;

521




 * were serialized in the byte buffer. The maintenance of metadata is
 * optional and disabled by default. To enable it, you must call
 * Packet::EnablePrinting and this will allow you to get non-empty
 * output from Packet::Print. If you wish to only enable
 * checking of metadata, and do not need any printing capability, you can
 * call Packet::EnableChecking: its runtime cost is lower than
 * Packet::EnablePrinting.
 *
 * - The set of tags contain simulation-specific information which cannot
 * be stored in the packet byte buffer because the protocol headers or trailers

  /**
   * By default, packets do not keep around enough metadata to
   * perform the operations requested by the Print methods. If you
   * want to be able the Packet::Print method, 
   * you need to invoke this method at least once during the 
   * simulation setup and before any packet is created.
   */




 * This method allows the MAC to instruct the PHY to start a
 * transmission of a given packet
 *
 * \param packet the Packet to be transmitted
 * \return this method returns false if the PHY will start TX,
 * true if the PHY refuses to start the TX. If false, the MAC layer
 * will expect that GenericPhyTxEndCallback is invoked at some point later.
 */

 * this method is invoked by the PHY to notify the MAC that the
 * transmission of a given packet has been completed.
 *
 * \param packet the Packet whose TX has been completed.
 */
typedef Callback< void, Ptr<const Packet> > GenericPhyTxEndCallback;


 * This method is used by the PHY to notify the MAC that a
 * previously started RX attempt has been successfully completed.
 *
 * \param packet the received Packet
 */
typedef Callback< void, Ptr<Packet> > GenericPhyRxEndOkCallback;


(-)a/src/network/utils/output-stream-wrapper.h (-1 / +1 lines)

Lines 27-33	Link Here

namespace ns3 {

namespace ns3 {

/*

/*

 * @brief A class encapsulating an STL output stream.

 * \brief A class encapsulating an STL output stream.

 * This class wraps a pointer to a C++ std::ostream and provides

 * This class wraps a pointer to a C++ std::ostream and provides

 * reference counting of the object.  This class is recommended for users

 * reference counting of the object.  This class is recommended for users




namespace ns3 {

/**
 * \brief Radiotap header implementation
 *
 * Radiotap is a de facto standard for 802.11 frame injection and reception. 
 * The radiotap header format is a mechanism to supply additional information 
 * about frames, from the driver to userspace applications such as libpcap, and 
 * from a userspace application to the driver for transmission. 
 *
 * \warning the radiotap header specification says that the fields included in
 * the header should be aligned to their natural ize (e.g., 16-bit fields 
 * aligned to 16-bit boundaries, 32-bit fields aligned to 32-bit boundaries, 
 * and so on.  This implementation does not enforce this.  However, the radiotap

   * buffer of a packet.  This method returns the number of bytes which are 
   * needed to store the header data during a Serialize.
   *
   * \returns The expected size of the header.
   */
  virtual uint32_t GetSerializedSize (void) const;


   * buffer of a packet.  The data written is expected to match bit-for-bit the 
   * representation of this header in a real network.
   *
   * \param start An iterator which points to where the header should
   *              be written.
   */
  virtual void Serialize (Buffer::Iterator start) const;

   * byte buffer of a packet.  The data read is expected to match bit-for-bit 
   * the representation of this header in real networks.
   *
   * \param start An iterator which points to where the header should
   *              written.
   * \returns The number of bytes read.
   */
  virtual uint32_t Deserialize (Buffer::Iterator start);


   *
   * eg: (field1 val1 field2 val2 field3 val3) field4 val4 field5 val5
   *
   * \param os The output stream
   */
  virtual void Print (std::ostream &os) const;

  /**
   * \brief Set the Time Synchronization Function Timer (TSFT) value.  Valid for
   * received frames only. 
   *
   * \param tsft Value in microseconds of the MAC's 64-bit 802.11 Time 
   *             Synchronization Function timer when the first bit of the MPDU
   *             arrived at the MAC.
   */
  void SetTsft (uint64_t tsft);

  /**
   * \brief Get the Time Synchronization Function Timer (TSFT) value.  Valid for
   * received frames only. 
   *
   * \returns The value in microseconds of the MAC's 64-bit 802.11 Time 
   *          Synchronization Function timer when the first bit of the MPDU
   *          arrived at the MAC.
   */

  };

  /**
   * \brief Set the frame flags of the transmitted or received frame.
   * \param flags flags to set.
   */
  void SetFrameFlags (uint8_t flags);

  /**
   * \brief Get the frame flags of the transmitted or received frame.
   * \returns The frame flags.
   * \see FrameFlags.
   */
  uint8_t GetFrameFlags (void) const;

  /**
   * \brief Set the transmit/receive channel frequency in units of megahertz
   * \param rate the transmit/receive channel frequency in units of megahertz.
   */
  void SetRate (uint8_t rate);

  /**
   * \brief Get the transmit/receive channel frequency in units of megahertz.
   * \returns The transmit/receive channel frequency in units of megahertz.
   */
  uint8_t GetRate (void) const;


  };

  /**
   * \brief Set the transmit/receive channel frequency and flags
   * \param frequency The transmit/receive data rate in units of 500 kbps.
   * \param flags The flags to set.
   * \see ChannelFlags
   */
  void SetChannelFrequencyAndFlags (uint16_t frequency, uint16_t flags);

  /**
   * \brief Get the transmit/receive data rate in units of 500 kbps.
   * \returns The transmit/receive data rate in units of 500 kbps.
   */
  uint16_t GetChannelFrequency (void) const;

  /**
   * \brief Get the channel flags of the transmitted or received frame.
   * \returns The frame flags.
   * \see ChannelFlags.
   */
  uint16_t GetChannelFlags (void) const;

  /**
   * \brief Set the RF signal power at the antenna as a decibel difference
   * from an arbitrary, fixed reference. 
   *
   * \param signal The RF signal power at the antenna as a decibel difference
   *               from an arbitrary, fixed reference;
   */
  void SetAntennaSignalPower (double signal);

  /**
   * \brief Get the RF signal power at the antenna as a decibel difference
   * from an arbitrary, fixed reference. 
   *
   * \returns The RF signal power at the antenna as a decibel difference
   *          from an arbitrary, fixed reference. 
   */
  uint8_t GetAntennaSignalPower (void) const;

  /**
   * \brief Set the RF noise power at the antenna as a decibel difference
   * from an arbitrary, fixed reference. 
   *
   * \param noise The RF noise power at the antenna as a decibel difference
   *              from an arbitrary, fixed reference. 
   */
  void SetAntennaNoisePower (double noise);

  /**
   * \brief Get the RF noise power at the antenna as a decibel difference
   * from an arbitrary, fixed reference. 
   *
   * \returns The RF noise power at the antenna as a decibel difference
   *          from an arbitrary, fixed reference. 
   */
  uint8_t GetAntennaNoisePower (void) const;




  Ipv4NixVectorRouting ();
  ~Ipv4NixVectorRouting ();
  /**
   * \brief The Interface ID of the Global Router interface.
   *
   * \see Object::GetObject ()
   */
  static TypeId GetTypeId (void);
  /**
   * \brief Set the Node pointer of the node for which this
   * routing protocol is to be placed
   *
   * \param node Node pointer
   */
  void SetNode (Ptr<Node> node);

  /**
   * \brief Called when run-time link topology change occurs
   * which iterates through the node list and flushes any
   * nix vector caches
   *

(-)a/src/olsr/model/olsr-repositories.h (-2 / +1 lines)

Lines 21-28	Link Here

*/

*/

///

///

/// \file	olsr-repositories.h

/// \brief Here are defined all data structures needed by an OLSR node.

/// \brief	Here are defined all data structures needed by an OLSR node.

///

///

#ifndef OLSR_REPOSITORIES_H

#ifndef OLSR_REPOSITORIES_H






///
/// \brief Implementation of OLSR agent and related classes.
/// \brief	Implementation of OLSR agent and related classes.
///
/// This is the main file of this software because %OLSR's behaviour is
/// implemented here.

                              receiverIfaceAddr, inetSourceAddr.GetIpv4 ());
            }
        }
	
    }

  // After processing all OLSR messages, we must recompute the routing table

  // MPR computation should be done for each interface. See section 8.3.1
  // (RFC 3626) for details.
  MprSet mprSet;
	

  // N is the subset of neighbors of the node, which are
  // neighbor "of the interface I"

          N.push_back (*neighbor);
        }
    }

  // N2 is the set of 2-hop neighbors reachable from "the interface
  // I", excluding:
  // (i)   the nodes only reachable by members of N with willingness WILL_NEVER


  // 2. Calculate D(y), where y is a member of N, for all nodes in N.
  // (we do this later)

  // 3. Add to the MPR set those nodes in N, which are the *only*
  // nodes to provide reachability to a node in N2.
  std::set<Ipv4Address> coveredTwoHopNeighbors;

          twoHopNeigh++;
        }
    }

  // 4. While there exist nodes in N2 which are not covered by at
  // least one node in the MPR set:
  while (N2.begin () != N2.end ())


  // 1. All the entries from the routing table are removed.
  Clear ();

  // 2. The new routing entries are added starting with the
  // symmetric neighbors (h=1) as the destination nodes.
  const NeighborSet &neighborSet = m_state.GetNeighbors ();


  // 4. For each entry in the multiple interface association base
  // where there exists a routing entry such that:
  // R_dest_addr == I_main_addr (of the multiple interface association entry)
  // AND there is no routing entry such that:
  // R_dest_addr == I_iface_addr
  const IfaceAssocSet &ifaceAssocSet = m_state.GetIfaceAssocSet ();
  for (IfaceAssocSet::const_iterator it = ifaceAssocSet.begin ();
       it != ifaceAssocSet.end (); it++)

{
  const olsr::MessageHeader::Tc &tc = msg.GetTc ();
  Time now = Simulator::Now ();

  // 1. If the sender interface of this message is not in the symmetric
  // 1-hop neighborhood of this node, the message MUST be discarded.
  const LinkTuple *link_tuple = m_state.FindSymLinkTuple (senderIface, now);
  if (link_tuple == NULL)
    return;

  // 2. If there exist some tuple in the topology set where:
  //    T_last_addr == originator address AND
  //    T_seq       >  ANSN,

    m_state.FindNewerTopologyTuple (msg.GetOriginatorAddress (), tc.ansn);
  if (topologyTuple != NULL)
    return;

  // 3. All tuples in the topology set where:
  //    T_last_addr == originator address AND
  //    T_seq       <  ANSN
  // MUST be removed from the topology set.
  m_state.EraseOlderTopologyTuples (msg.GetOriginatorAddress (), tc.ansn);


    {
      const Ipv4Address &addr = *i;
      // 4.1. If there exist some tuple in the topology set where:
      //      T_dest_addr == advertised neighbor main address, AND
      //      T_last_addr == originator address,
      // then the holding time of that tuple MUST be set to:
      //      T_time      =  current time + validity time.
      TopologyTuple *topologyTuple =
        m_state.FindTopologyTuple (addr, msg.GetOriginatorAddress ());


        {
          // 4.2. Otherwise, a new tuple MUST be recorded in the topology
          // set where:
          //      T_dest_addr = advertised neighbor main address,
          //      T_last_addr = originator address,
          //      T_seq       = ANSN,
          //      T_time      = current time + validity time.
          TopologyTuple topologyTuple;;
          topologyTuple.destAddr = addr;
          topologyTuple.lastAddr = msg.GetOriginatorAddress ();

                    " the message MUST be discarded.");
      return;
    }

  // 2. For each interface address listed in the MID message
  for (std::vector<Ipv4Address>::const_iterator i = mid.interfaceAddresses.begin ();
       i != mid.interfaceAddresses.end (); i++)

                    " from " << olsrMessage.GetOriginatorAddress () << " because it is duplicated");
      return;
    }

  // If the sender interface address is an interface address
  // of a MPR selector of this node and ttl is greater than 1,
  // the message must be retransmitted

          retransmitted = true;
        }
    }

  // Update duplicate tuple...
  if (duplicated != NULL)
    {


  std::vector<olsr::MessageHeader::Hello::LinkMessage>
  &linkMessages = hello.linkMessages;

  const LinkSet &links = m_state.GetLinks ();
  for (LinkSet::const_iterator link_tuple = links.begin ();
       link_tuple != links.end (); link_tuple++)

///        in HNA messages sent by the node.
///        If this method is called more than once, entries from the old
///        association are deleted before entries from the new one are added.
/// \param routingTable the Ipv4StaticRouting routing table to be associated.
///
void
RoutingProtocol::SetRoutingTableAssociation (Ptr<Ipv4StaticRouting> routingTable)

}

///
/// \brief Updates Link Set according to a new received HELLO message
/// (following RFC 3626 specification). Neighbor Set is also updated if needed.
void
RoutingProtocol::LinkSensing (const olsr::MessageHeader &msg,
                              const olsr::MessageHeader::Hello &hello,

  NS_LOG_DEBUG ("@" << now.GetSeconds () << ": Olsr node " << m_mainAddress
                    << ": LinkSensing(receiverIface=" << receiverIface
                    << ", senderIface=" << senderIface << ") BEGIN");

  NS_ASSERT (msg.GetVTime () > Seconds (0));
  LinkTuple *link_tuple = m_state.FindLinkTuple (senderIface);
  if (link_tuple == NULL)

      NS_LOG_LOGIC ("Existing link tuple already exists => will update it");
      updated = true;
    }

  link_tuple->asymTime = now + msg.GetVTime ();
  for (std::vector<olsr::MessageHeader::Hello::LinkMessage>::const_iterator linkMessage =
         hello.linkMessages.begin ();

}

///
/// \brief Updates the Neighbor Set according to the information contained in
/// a new received HELLO message (following RFC 3626).
void
RoutingProtocol::PopulateNeighborSet (const olsr::MessageHeader &msg,
                                      const olsr::MessageHeader::Hello &hello)



///
/// \brief Updates the 2-hop Neighbor Set according to the information contained
/// in a new received HELLO message (following RFC 3626).
void
RoutingProtocol::PopulateTwoHopNeighborSet (const olsr::MessageHeader &msg,
                                            const olsr::MessageHeader::Hello &hello)

  Time now = Simulator::Now ();

  NS_LOG_DEBUG ("Olsr node " << m_mainAddress << ": PopulateTwoHopNeighborSet BEGIN");

  for (LinkSet::const_iterator link_tuple = m_state.GetLinks ().begin ();
       link_tuple != m_state.GetLinks ().end (); link_tuple++)
    {



///
/// \brief Updates the MPR Selector Set according to the information contained in
/// a new received HELLO message (following RFC 3626).
void
RoutingProtocol::PopulateMprSelectorSet (const olsr::MessageHeader &msg,
                                         const olsr::MessageHeader::Hello &hello)

  NS_LOG_FUNCTION (this);

  Time now = Simulator::Now ();

  typedef std::vector<olsr::MessageHeader::Hello::LinkMessage> LinkMessageVec;
  for (LinkMessageVec::const_iterator linkMessage = hello.linkMessages.begin ();
       linkMessage != hello.linkMessages.end ();


#if 0
///
/// \brief Drops a given packet because it couldn't be delivered to the corresponding
/// destination by the MAC layer. This may cause a neighbor loss, and appropiate
/// actions are then taken.
///
/// \param p the packet which couldn't be delivered by the MAC layer.
///

  double now              = Simulator::Now ();
  struct hdr_ip* ih       = HDR_IP (p);
  struct hdr_cmn* ch      = HDR_CMN (p);

  debug ("%f: Node %d MAC Layer detects a breakage on link to %d\n",
         now,
         OLSR::node_id (ra_addr ()),
         OLSR::node_id (ch->next_hop ()));

  if ((u_int32_t)ih->daddr () == IP_BROADCAST) {
      drop (p, DROP_RTR_MAC_CALLBACK);
      return;
    }

  OLSR_link_tuple* link_tuple = state_.find_link_tuple (ch->next_hop ());
  if (link_tuple != NULL) {
      link_tuple->lost_time () = now + OLSR_NEIGHB_HOLD_TIME;

}

///
/// \brief This function is invoked when a link tuple is updated. Its aim is to
/// also update the corresponding neighbor tuple if it is needed.
///
/// \param tuple the link tuple which has been updated.
///

//         OLSR::node_id(ra_addr()),
//         OLSR::node_id(tuple->neighborMainAddr),
//         ((tuple->status() == OLSR_STATUS_SYM) ? "sym" : "not_sym"));

  m_state.EraseNeighborTuple (tuple);
  IncrementAnsn ();
}


///
/// \brief Deletes the entry whose destination address is given.
/// \param dest address of the destination node.
///
void
RoutingProtocol::RemoveEntry (Ipv4Address const &dest)


///
/// \brief Looks up an entry for the specified destination address.
/// \param dest destination address.
/// \param outEntry output parameter to hold the routing entry result, if fuond
/// \return true if found, false if not found
///
bool
RoutingProtocol::Lookup (Ipv4Address const &dest,

}

///
/// \brief Finds the appropiate entry which must be used in order to forward
/// a data packet to a next hop (given a destination).
///
/// Imagine a routing table like this: [A,B] [B,C] [C,C]; being each pair of the
/// form [dest addr,next-hop addr]. In this case, if this function is invoked with

/// to forward a data packet destined to A. That is, C is a neighbor of this node,
/// but B isn't. This function finds the appropiate neighbor for forwarding a packet.
///
/// \param entry the routing table entry which indicates the destination node
/// we are interested in.
/// \return the appropiate routing table entry which indicates the next
/// hop which must be used for forwarding a data packet, or NULL
/// if there is no such entry.
///
bool
RoutingProtocol::FindSendEntry (RoutingTableEntry const &entry,

///
/// If an entry for the given destination existed, it is deleted and freed.
///
/// \param dest address of the destination node.
/// \param next address of the next hop node.
/// \param iface address of the local interface.
/// \param dist distance to the destination node.
///
void
RoutingProtocol::AddEntry (Ipv4Address const &dest,

#endif  //NS3_LOG_ENABLE
}

} // namespace olsr
} // namespace ns3



(-)a/src/olsr/model/olsr-state.cc (-1 / +1 lines)

Lines 21-27	Link Here

*/

*/

///

///

/// \file	OlsrState.cc

/// \file	olsr-state.cc

/// \brief	Implementation of all functions needed for manipulating the internal

/// \brief	Implementation of all functions needed for manipulating the internal

///		state of an OLSR node.

///		state of an OLSR node.

///

///

(-)a/src/point-to-point/model/point-to-point-channel.h (-1 / +1 lines)

Lines 135-141	Link Here

135

   * net device, receiving net device, transmission time and

135

   * net device, receiving net device, transmission time and

136

   * packet receipt time.

136

   * packet receipt time.

137

138

   * @see class CallBackTraceSource

138

   * \see class CallBackTraceSource

139

*/

139

*/

140

  TracedCallback<Ptr<const Packet>, // Packet being transmitted

140

  TracedCallback<Ptr<const Packet>, // Packet being transmitted

141

                 Ptr<NetDevice>,    // Transmitting NetDevice

141

                 Ptr<NetDevice>,    // Transmitting NetDevice




   * set in the Attach () method from the corresponding field in the channel
   * to which the device is attached.  It can be overridden using this method.
   *
   * \see Attach ()
   * \param bps the data rate at which this object operates
   */
  void SetDataRate (DataRate bps);


   * Set the interframe gap used to separate packets.  The interframe gap
   * defines the minimum space required between packets sent by this device.
   *
   * \param t the interframe gap time
   */
  void SetInterframeGap (Time t);

  /**
   * Attach the device to a channel.
   *
   * \param ch Ptr to the channel to which this object is being attached.
   */
  bool Attach (Ptr<PointToPointChannel> ch);


   * The PointToPointNetDevice "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;


   * The PointToPointNetDevice may optionally include an ErrorModel in
   * the packet receive chain.
   *
   * \see ErrorModel
   * \param em Ptr to the ErrorModel.
   */
  void SetReceiveErrorModel (Ptr<ErrorModel> em);


   * used by the channel to indicate that the last bit of a packet has 
   * arrived at the device.
   *
   * \see PointToPointChannel
   * \param p Ptr to the received packet.
   */
  void Receive (Ptr<Packet> p);


   * started sending signals.  An event is scheduled for the time at which
   * the bits have been completely transmitted.
   *
   * \see PointToPointChannel::TransmitStart ()
   * \see TransmitCompleteEvent ()
   * \param p a reference to the packet to send
   * \returns true if success, false on failure
   */
  bool TransmitStart (Ptr<Packet> p);


  };
  /**
   * The state of the Net Device transmit state machine.
   * \see TxMachineState
   */
  TxMachineState m_txMachineState;

  /**
   * The data rate that the Net Device uses to simulate packet transmission
   * timing.
   * \see class DataRate
   */
  DataRate       m_bps;

  /**
   * The interframe gap that the Net Device uses to throttle packet
   * transmission
   * \see class Time
   */
  Time           m_tInterframeGap;

  /**
   * The PointToPointChannel to which this PointToPointNetDevice has been
   * attached.
   * \see class PointToPointChannel
   */
  Ptr<PointToPointChannel> m_channel;


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


(-)a/src/propagation/model/propagation-loss-model.h (-3 / +3 lines)

Lines 56-62	Link Here

/**

/**

   * \brief Enables a chain of loss models to act on the signal

   * \brief Enables a chain of loss models to act on the signal

   * \param The next PropagationLossModel to add to the chain

   * \param next The next PropagationLossModel to add to the chain

   * This method of chaining propagation loss models only works commutatively

   * This method of chaining propagation loss models only works commutatively

   * if the propagation loss of all models in the chain are independent

   * if the propagation loss of all models in the chain are independent

Lines 516-523	Link Here

516

   * \brief Set loss (in dB, positive) between pair of ns-3 objects

516

   * \brief Set loss (in dB, positive) between pair of ns-3 objects

517

   * (typically, nodes).

517

   * (typically, nodes).

518

519

   * \param ma          Source mobility model

519

   * \param a ma          Source mobility model

520

   * \param mb          Destination mobility model

520

   * \param b mb          Destination mobility model

521

   * \param loss        a -> b path loss, positive in dB

521

   * \param loss        a -> b path loss, positive in dB

522

   * \param symmetric   If true (default), both a->b and b->a paths will be affected

522

   * \param symmetric   If true (default), both a->b and b->a paths will be affected

523

*/

523

*/




 * \ingroup spectrum
 *
 *
 * helper for creating the NetDevice
 * @image html HdOfdmAlohaNoAck.png
 *
 */
class AdhocAlohaNoackIdealPhyHelper

  /**
   * set the SpectrumChannel that will be used by SpectrumPhy instances created by this helper
   *
   * \param channel
   */
  void SetChannel (Ptr<SpectrumChannel> channel);

  /**
   * set the SpectrumChannel that will be used by SpectrumPhy instances created by this helper
   *
   * \param channelName
   */
  void SetChannel (std::string channelName);


  /**
   *
   * \param txPsd the Power Spectral Density to be used for transmission by all created PHY instances
   */
  void SetTxPowerSpectralDensity (Ptr<SpectrumValue> txPsd);

  /**
   *
   * \param noisePsd the Power Spectral Density to be used for transmission by all created PHY instances
   */
  void SetNoisePowerSpectralDensity (Ptr<SpectrumValue> noisePsd);

  /**
   * \param name the name of the attribute to set
   * \param v the value of the attribute
   *
   * Set these attributes on each HdOfdmSpectrumPhy instance to be created
   */
  void SetPhyAttribute (std::string name, const AttributeValue &v);

  /**
   * \param n1 the name of the attribute to set
   * \param v1 the value of the attribute to set
   *
   * Set these attributes on each AlohaNoackNetDevice created
   */



  /**
    * \param c the set of nodes on which a device must be created
    * \return a device container which contains all the devices created by this method.
    */
  NetDeviceContainer Install (NodeContainer c) const;
  /**
   * \param node the node on which a device must be created
   * \returns a device container which contains all the devices created by this method.
   */
  NetDeviceContainer Install (Ptr<Node> node) const;
  /**
   * \param nodeName the name of node on which a device must be created
   * \return a device container which contains all the devices created by this method.
   */
  NetDeviceContainer Install (std::string nodeName) const;





  /**
   * set the SpectrumChannel that will be used by SpectrumPhy instances created by this helper
   *
   * \param channel
   */
  void SetChannel (Ptr<SpectrumChannel> channel);

  /**
   * set the SpectrumChannel that will be used by SpectrumPhy instances created by this helper
   *
   * \param channelName
   */
  void SetChannel (std::string channelName);

  /**
   * \param name the name of the attribute to set
   * \param v the value of the attribute
   *
   * Set these attributes on each HdOfdmSpectrumPhy instance to be created
   */
  void SetPhyAttribute (std::string name, const AttributeValue &v);

  /**
   * \param n1 the name of the attribute to set
   * \param v1 the value of the attribute to set
   *
   * Set these attributes on each AlohaNoackNetDevice created
   */

  /**
   * Set the spectrum model used by the created SpectrumAnalyzer instances to represent incoming signals
   *
   * \param m 
   */
  void SetRxSpectrumModel (Ptr<SpectrumModel> m);


  /** 
   * Enable ASCII output. This will create one filename for every created SpectrumAnalyzer instance.
   * 
   * \param prefix the prefix of the filename of the traces that will be created.
   */
  void EnableAsciiAll (std::string prefix);

  /**
    * \param c the set of nodes on which a device must be created
    * \return a device container which contains all the devices created by this method.
    */
  NetDeviceContainer Install (NodeContainer c) const;
  /**
   * \param node the node on which a device must be created
   * \returns a device container which contains all the devices created by this method.
   */
  NetDeviceContainer Install (Ptr<Node> node) const;
  /**
   * \param nodeName the name of node on which a device must be created
   * \return a device container which contains all the devices created by this method.
   */
  NetDeviceContainer Install (std::string nodeName) const;





  /**
   * set the channel that will be used by SpectrumPhy instances created by this helper
   *
   * \param channel
   */
  void SetChannel (Ptr<SpectrumChannel> channel);

  /**
   * set the channel that will be used by SpectrumPhy instances created by this helper
   *
   * \param channelName
   */
  void SetChannel (std::string channelName);



  /**
   *
   * \param node
   * \param device
   *
   * \return a  newly created SpectrumPhy instance
   */
  Ptr<SpectrumPhy> Create (Ptr<Node> node, Ptr<NetDevice> device) const;





  /**
   * set the SpectrumChannel that will be used by SpectrumPhy instances created by this helper
   *
   * \param channel
   */
  void SetChannel (Ptr<SpectrumChannel> channel);

  /**
   * set the SpectrumChannel that will be used by SpectrumPhy instances created by this helper
   *
   * \param channelName
   */
  void SetChannel (std::string channelName);


  /**
   *
   * \param txPsd the Power Spectral Density to be used for transmission by all created PHY instances
   */
  void SetTxPowerSpectralDensity (Ptr<SpectrumValue> txPsd);


  /**
   * \param name the name of the attribute to set
   * \param v the value of the attribute
   *
   * Set these attributes on each HdOfdmSpectrumPhy instance to be created
   */
  void SetPhyAttribute (std::string name, const AttributeValue &v);

  /**
   * \param n1 the name of the attribute to set
   * \param v1 the value of the attribute to set
   *
   * Set these attributes on each AlohaNoackNetDevice created
   */



  /**
    * \param c the set of nodes on which a device must be created
    * \return a device container which contains all the devices created by this method.
    */
  NetDeviceContainer Install (NodeContainer c) const;
  /**
   * \param node the node on which a device must be created
   * \returns a device container which contains all the devices created by this method.
   */
  NetDeviceContainer Install (Ptr<Node> node) const;
  /**
   * \param nodeName the name of node on which a device must be created
   * \return a device container which contains all the devices created by this method.
   */
  NetDeviceContainer Install (std::string nodeName) const;





  /**
   * set the queue which is going to be used by this device
   *
   * \param queue
   */
  virtual void SetQueue (Ptr<Queue> queue);


  /**
   * Notify the MAC that the PHY finished a reception successfully
   *
   * \param p the received packet
   */
  void NotifyReceptionEndOk (Ptr<Packet> p);


   * is therefore provide to allow AlohaNoackNetDevice::GetChannel() to have
   * something meaningful to return.
   *
   * \param c the underlying channel
   */
  void SetChannel (Ptr<Channel> c);


  /**
   * set the callback used to instruct the lower layer to start a TX
   *
   * \param c
   */
  void SetGenericPhyTxStartCallback (GenericPhyTxStartCallback c);


   * This object is needed so that we can set/get attributes and
   * connect to trace sources of the PHY from the net device.
   *
   * \param phy the Phy object attached to the device.  Note that the
   * API between the PHY and the above (this NetDevice which also
   * implements the MAC) is implemented entirely by
   * callbacks, so we do not require that the PHY inherits by any

  void SetPhy (Ptr<Object> phy);

  /**
   * \return a reference to the PHY object embedded in this NetDevice.
   */
  Ptr<Object> GetPhy () const;


(-)a/src/spectrum/model/friis-spectrum-propagation-loss.h (-3 / +3 lines)

Lines 60-69	Link Here

   * where C = 3e8 m/s is the light speed in the vacuum. The intended

   * where C = 3e8 m/s is the light speed in the vacuum. The intended

   * use is to calculate Prx = Ptx * G

   * use is to calculate Prx = Ptx * G

   * @param f frequency in Hz

   * \param f frequency in Hz

   * @param d distance in m

   * \param d distance in m

   * @return if Prx < Ptx then return Prx; else return Ptx

   * \return if Prx < Ptx then return Prx; else return Ptx

*/

*/

  double CalculateLoss (double f, double d) const;

  double CalculateLoss (double f, double d) const;




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


   * set the Power Spectral Density of outgoing signals in power units
   * (Watt, Pascal...) per Hz.
   *
   * \param txPsd
   */
  void SetTxPowerSpectralDensity (Ptr<SpectrumValue> txPsd);

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

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

  /**
   * set the PHY rate to be used by this PHY.
   *
   * \param rate
   */
  void SetRate (DataRate rate);

  /**
   *
   * \return the PHY rate used by this PHY.
   */
  DataRate GetRate () const;


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





public:
  /**
   *
   * \return the Power Spectral Density of Micro Wave Oven #1 in the
   * cited paper
   */
  static Ptr<SpectrumValue> CreatePowerSpectralDensityMwo1 ();

  /**
   *
   * \return the Power Spectral Density of Micro Wave Oven #2 in the
   * cited paper
   */
  static Ptr<SpectrumValue> CreatePowerSpectralDensityMwo2 ();




   * an interator pointing to it. If not, it creates a new entry in
   * m_txSpectrumMpodelInfoMap, and returns an iterator to it.
   *
   * \param txSpectrumModel the TX SpectrumModel  being considered
   *
   * \return an iterator pointing to the corresponding entry in m_txSpectrumModelInfoMap
   */
  TxSpectrumModelInfoMap_t::const_iterator FindAndEventuallyAddTxSpectrumModel (Ptr<const SpectrumModel> txSpectrumModel);


   * make sure that there are SpectrumConverters from any
   * SpectrumPhy being used for TX to the given SpectrumModel being used for RX
   *
   * \param rxPhy the RXing SpectrumPhy
   * \param rxSpectrumModel the SpectrumModel used for RX by rxPhy
   */
  void CheckAddRxSpectrumModel (Ptr<SpectrumPhy> rxPhy, Ptr<const SpectrumModel> rxSpectrumModel);


  /**
   * used internally to reschedule transmission after the propagation delay
   *
   * \param p
   * \param rxPowerSpectrum
   * \param duration
   * \param receiver
   */
  virtual void StartRx (Ptr<PacketBurst> p, Ptr <SpectrumValue> rxPowerSpectrum, SpectrumType st, Time duration, Ptr<SpectrumPhy> receiver);





   * is therefore provide to allow NonCommunicatingNetDevice::GetChannel() to have
   * something meaningful to return.
   *
   * \param c the underlying channel
   */
  void SetChannel (Ptr<Channel> c);


   * This object is needed so that we can set/get attributes and
   * connect to trace sources of the PHY from the net device.
   *
   * \param phy the Phy object embedded within this device.
   */
  void SetPhy (Ptr<Object> phy);

  /**
   * \return a reference to the PHY object embedded in this NetDevice.
   */
  Ptr<Object> GetPhy () const;





/**
 * \ingroup spectrum
 *
 * \brief SpectrumChannel implementation which handles a single spectrum model
 *
 * All SpectrumPhy layers attached to this SpectrumChannel
 */

  /**
   * used internally to reschedule transmission after the propagation delay
   *
   * \param p
   * \param rxPowerSpectrum
   * \param st
   * \param duration
   * \param receiver
   */
  virtual void StartRx (Ptr<PacketBurst> p, Ptr <SpectrumValue> rxPowerSpectrum, SpectrumType st, Time duration, Ptr<SpectrumPhy> receiver);


(-)a/src/spectrum/model/spectrum-analyzer.h (-1 / +1 lines)

Lines 64-70	Link Here

/**

/**

   * Set the spectrum model used by the SpectrumAnalyzer to represent incoming signals

   * Set the spectrum model used by the SpectrumAnalyzer to represent incoming signals

   * @param m

   * \param m

*/

*/

  void SetRxSpectrumModel (Ptr<SpectrumModel> m);

  void SetRxSpectrumModel (Ptr<SpectrumModel> m);




  /**
   * Used by attached PHY instances to transmit waveforms on the channel
   *
   * \param p the PacketBurst associated with the waveform being transmitted
   * \param txPsd the Power Spectral Density of the
   * waveform, in linear units. The exact unit will depend on the
   * type of transmission medium involved: W for radio communications, Pa for
   * underwater acoustic communications. Other transmission media to be defined.
   * \param st spectrum type
   * \param duration duration of the packet transmission. It is
   * assumed that the Power Spectral Density remains constant for the
   * whole duration of the transmission. In other words, all waveform
   * have a rect shape with respect to time.
   * \param sender the SpectrumPhy instance making this function call
   */
  virtual void StartTx (Ptr<PacketBurst> p, Ptr <SpectrumValue> txPsd, SpectrumType st, Time duration, Ptr<SpectrumPhy> sender) = 0;

  /**
   * \brief add a SpectrumPhy to a channel, so it can receive packets
   *
   * This method is used to attach a SpectrumPhy instance to a
   * SpectrumChannel instance, so that the SpectrumPhy can receive

   * This method is to be implemented by all classes inheriting from
   * SpectrumChannel.
   *
   * \param phy the SpectrumPhy instance to be added to the channel as
   * a receiver.
   */
  virtual void AddRx (Ptr<SpectrumPhy> phy) = 0;




   * instances defined over one SpectrumModel to corresponding ValueVsFreq
   * instances defined over a diffent SpectrumModel
   *
   * \param fromSpectrumModel the SpectrumModel to convert from
   * \param toSpectrumModel the SpectrumModel to convert to
   */
  SpectrumConverter (Ptr<const SpectrumModel> fromSpectrumModel, Ptr<const SpectrumModel> toSpectrumModel);


  /**
   * Convert a particular ValueVsFreq instance to
   *
   * \param vvf the ValueVsFreq instance to be converted
   *
   * \return the converted version of the provided ValueVsFreq
   */
  Ptr<SpectrumValue> Convert (Ptr<const SpectrumValue> vvf) const;


  /**
   * Calculate the coefficient for value conversion between elements
   *
   * \param from BandInfo to convert from
   * \param to  BandInfo to convert to
   *
   * \return the fraction of the value of the "from" BandInfos that is
   * mapped to the "to" BandInfo
   */
  double GetCoefficient (const BandInfo& from, const BandInfo& to) const;

  std::vector<std::vector<double> > m_conversionMatrix; ///< matrix of conversion coefficients
  Ptr<const SpectrumModel> m_fromSpectrumModel;  ///< the SpectrumModel this SpectrumConverter instance can convert from
  Ptr<const SpectrumModel> m_toSpectrumModel;    ///< the SpectrumModel this SpectrumConverter instance can convert to

};





  /**
   * set the SpectrumErrorModel to be used.
   *
   * \param e
   */
  void SetErrorModel (Ptr<SpectrumErrorModel> e);

  /**
   * notify that the PHY is starting a RX attempt
   *
   * \param p the packet corresponding to the signal being RX
   * \param rxPsd the power spectral density of the signal being RX
   */
  void StartRx (Ptr<const Packet> p, Ptr<const SpectrumValue> rxPsd);


   * method must also be called when RX is aborted.
   *
   *
   * \return true if RX was successful, false otherwise
   */
  bool EndRx ();


   * method is to be called for all incoming signal, regardless of
   * wether they're useful signals or interferers.
   *
   * \param spd the power spectral density of the new signal
   * \param duration the duration of the new signal
   */
  void AddSignal (Ptr<const SpectrumValue> spd, const Time duration);


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




   * between the center frequency of the considered band and the
   * center frequency of the adjacent lower (resp. upper) band.
   *
   * \param centerFreqs the vector of center frequencies.
   *
   * \return
   */
  SpectrumModel (std::vector<double> centerFreqs);


   * This construct a SpectrumModel based on the explicit values of
   * center frequencies and boundaries of each subband.
   *
   * \param bands
   *
   * \return
   */
  SpectrumModel (Bands bands);

  /**
   *
   * \return the number of frequencies in this SpectrumModel
   */
  size_t GetNumBands () const;


  /**
   *
   * \return the unique id of this SpectrumModel
   */
  SpectrumModelUid_t GetUid () const;





  /**
   * set the associated NetDevice instance
   *
   * \param d the NetDevice instance
   */
  virtual void SetDevice (Ptr<NetDevice> d) = 0;

  /**
   * get the associated NetDevice instance
   *
   * \return a Ptr to the associated NetDevice instance
   */
  virtual Ptr<NetDevice> GetDevice () = 0;

  /**
   * Set the mobility model associated with this device.
   *
   * \param m the mobility model
   */
  virtual void SetMobility (Ptr<MobilityModel> m) = 0;

  /**
   * get the associated MobilityModel instance
   *
   * \return a Ptr to the associated NetDevice instance
   */
  virtual Ptr<MobilityModel> GetMobility () = 0;


  /**
   * Set the channel attached to this device.
   *
   * \param c the channel
   */
  virtual void SetChannel (Ptr<SpectrumChannel> c) = 0;

  /**
   *
   * \return returns the SpectrumModel that this SpectrumPhy expects to be used
   * for all SpectrumValues that are passed to StartRx. If 0 is
   * returned, it means that any model will be accepted.
   */

  /**
   * Notify the SpectrumPhy instance of an incoming waveform
   *
   * \param p the PacketBurst associated with the incoming waveform
   * \param rxPsd the Power Spectral Density of the incoming
   * waveform. The units of the PSD are the same specified for SpectrumChannel::StartTx().
   * \param st spectrum type
   * \param duration the duration of the incoming waveform
   */
  virtual void StartRx (Ptr<PacketBurst> p, Ptr <const SpectrumValue> rxPsd, SpectrumType st, Time duration) = 0;





  /**
   * used to chain various instances of SpectrumPropagationLossModel
   *
   * \param next
   */
  void SetNext (Ptr<SpectrumPropagationLossModel> next);

  /**
   * This method is to be called to calculate
   *
   * \param txPsd the SpectrumValue representing the power spectral
   * density of the transmission. Watt units are to be used for radio
   * communications, and Pascal units for acoustic communications
   * (e.g. underwater).
   *
   * \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> CalcRxPowerSpectralDensity (Ptr<const SpectrumValue> txPsd,

  /**
   *
   *
   * \param txPsd 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.
   */
  virtual Ptr<SpectrumValue> DoCalcRxPowerSpectralDensity (Ptr<const SpectrumValue> txPsd,




{
public:
  /**
   * \brief SpectrumValue constructor
   *
   * \param sm pointer to the SpectrumModel which implements the set of frequencies to which the values
   * will be referring.
   *
   * \warning the intended use if that sm points to a static object
   * which will be there for the whole simulation. This is reasonable
   * since the set of frequencies which are to be used in the
   * simulation is normally known before the simulation starts. Make

  /**
   * Access value at given frequency index
   *
   * \param index the given frequency index
   *
   * \return reference to the value
   */
  double& operator[] (size_t index);



  /**
   * \return the uid of the embedded SpectrumModel
   * @return the uid of the embedded SpectrumModel
   */
  SpectrumModelUid_t GetSpectrumModelUid () const;


  /**
   * \return the embedded SpectrumModel
   * @return the  embedded SpectrumModel
   */
  Ptr<const SpectrumModel> GetSpectrumModel () const;


  /**
   * \return a const iterator pointing to the beginning of the embedded SpectrumModel
   *
   * @return a const iterator pointing to the beginning of the embedded SpectrumModel
   */
  Bands::const_iterator ConstBandsBegin () const;

  /**
   * \return a const iterator pointing to the end of the embedded SpectrumModel
   *
   * @return a const iterator pointing to the end of the embedded SpectrumModel
   */
  Bands::const_iterator ConstBandsEnd () const;


  /**
   * \return a const iterator pointing to the beginning of the embedded SpectrumModel
   *
   * @return a const iterator pointing to the beginning of the embedded SpectrumModel
   */
  Values::const_iterator ConstValuesBegin () const;

  /**
   * \return a const iterator pointing to the end of the embedded SpectrumModel
   *
   * @return a const iterator pointing to the end of the embedded SpectrumModel
   */
  Values::const_iterator ConstValuesEnd () const;

  /**
   * \return an iterator pointing to the beginning of the embedded SpectrumModel
   *
   * @return an iterator pointing to the beginning of the embedded SpectrumModel
   */
  Values::iterator ValuesBegin ();

  /**
   * \return an iterator pointing to the end of the embedded SpectrumModel
   *
   * @return an iterator pointing to the end of the embedded SpectrumModel
   */
  Values::iterator ValuesEnd ();


  /**
   *  addition operator
   *
   * \param lhs Left Hand Side of the operator
   * \param rhs Right Hand Side of the operator
   *
   * \return the value of lhs + rhs
   */
  friend SpectrumValue operator+ (const SpectrumValue& lhs, const SpectrumValue& rhs);


  /**
   *  addition operator
   *
   * \param lhs Left Hand Side of the operator
   * \param rhs Right Hand Side of the operator
   *
   * \return the value of lhs + rhs
   */
  friend SpectrumValue operator+ (const SpectrumValue& lhs, double rhs);

  /**
   *  addition operator
   *
   * \param lhs Left Hand Side of the operator
   * \param rhs Right Hand Side of the operator
   *
   * \return the value of lhs + rhs
   */
  friend SpectrumValue operator+ (double lhs, const SpectrumValue& rhs);


  /**
   *  subtraction operator
   *
   * \param lhs Left Hand Side of the operator
   * \param rhs Right Hand Side of the operator
   *
   * \return the value of lhs - rhs
   */
  friend SpectrumValue operator- (const SpectrumValue& lhs, const SpectrumValue& rhs);

  /**
   *  subtraction operator
   *
   * \param lhs Left Hand Side of the operator
   * \param rhs Right Hand Side of the operator
   *
   * \return the value of lhs - rhs
   */
  friend SpectrumValue operator- (const SpectrumValue& lhs, double rhs);

  /**
   *  subtraction operator
   *
   * \param lhs Left Hand Side of the operator
   * \param rhs Right Hand Side of the operator
   *
   * \return the value of lhs - rhs
   */
  friend SpectrumValue operator- (double lhs, const SpectrumValue& rhs);

  /**
   *  multiplication component-by-component (Schur product)
   *
   * \param lhs Left Hand Side of the operator
   * \param rhs Right Hand Side of the operator
   *
   * \return the value of lhs * rhs
   */
  friend SpectrumValue operator* (const SpectrumValue& lhs, const SpectrumValue& rhs);

  /**
   *  multiplication by a scalar
   *
   * \param lhs Left Hand Side of the operator
   * \param rhs Right Hand Side of the operator
   *
   * \return the value of lhs * rhs
   */
  friend SpectrumValue operator* (const SpectrumValue& lhs, double rhs);

  /**
   *  multiplication of a scalar
   *
   * \param lhs Left Hand Side of the operator
   * \param rhs Right Hand Side of the operator
   *
   * \return the value of lhs * rhs
   */
  friend SpectrumValue operator* (double lhs, const SpectrumValue& rhs);

  /**
   *  division component-by-component
   *
   * \param lhs Left Hand Side of the operator
   * \param rhs Right Hand Side of the operator
   *
   * \return the value of lhs / rhs
   */
  friend SpectrumValue operator/ (const SpectrumValue& lhs, const SpectrumValue& rhs);

  /**
   * division by a scalar
   *
   * \param lhs Left Hand Side of the operator
   * \param rhs Right Hand Side of the operator
   *
   * \return the value of *this / rhs
   */
  friend SpectrumValue operator/ (const SpectrumValue& lhs, double rhs);

  /**
   * division of a scalar
   *
   * \param lhs Left Hand Side of the operator
   * \param rhs Right Hand Side of the operator
   *
   * \return the value of *this / rhs
   */
  friend SpectrumValue operator/ (double lhs, const SpectrumValue& rhs);


   * unary plus operator
   *
   *
   * \return the value of *this
   */
  friend SpectrumValue operator+ (const SpectrumValue& rhs);


   * unary minus operator
   *
   *
   * \return the value of - *this
   */
  friend SpectrumValue operator- (const SpectrumValue& rhs);


  /**
   * left shift operator
   *
   * \param n position to shift
   *
   * \return the value of *this left shifted by n positions. In other
   * words, the function of the set of frequencies represented by
   * *this is left-shifted in frequency by n positions.
   */

  /**
    * right shift operator
    *
    * \param n position to shift
    *
    * \return the value of *this right shifted by n positions. In other
    * words, the function of the set of frequencies represented by
    * *this is left-shifted in frequency by n positions.
    */

  /**
   * Add the Right Hand Side of the operator to *this, component by component
   *
   * \param rhs the Right Hand Side
   *
   * \return a reference to *this
   */
  SpectrumValue& operator+= (const SpectrumValue& rhs);

  /**
   * Subtract the Right Hand Side of the operator from *this, component by component
   *
   * \param rhs the Right Hand Side
   *
   * \return a reference to *this
   */
  SpectrumValue& operator-= (const SpectrumValue& rhs);

  /**
   * Multiply *this by the Right Hand Side of the operator, component by component
   *
   * \param rhs the Right Hand Side
   *
   * \return  a reference to *this
   */
  SpectrumValue& operator*= (const SpectrumValue& rhs);

  /**
   * Divide *this by the Right Hand Side of the operator, component by component
   *
   * \param rhs the Right Hand Side
   *
   * \return  a reference to *this
   */
  SpectrumValue& operator/= (const SpectrumValue& rhs);


   * Add the value of the Right Hand Side of the operator to all
   * components of *this
   *
   * \param rhs the Right Hand Side
   *
   * \return a reference to *this
   */
  SpectrumValue& operator+= (double rhs);


   * Subtract the value of the Right Hand Side of the operator from all
   * components of *this
   *
   * \param rhs the Right Hand Side
   *
   * \return a reference to *this
   */
  SpectrumValue& operator-= (double rhs);


   * Multiply every component of *this by the value of the Right Hand
   * Side of the operator
   *
   * \param rhs the Right Hand Side
   *
   * \return  a reference to *this
   */
  SpectrumValue& operator*= (double rhs);


   * Divide every component of *this by the value of the Right Hand
   * Side of the operator
   *
   * \param rhs the Right Hand Side
   *
   * \return  a reference to *this
   */
  SpectrumValue& operator/= (double rhs);


   * Assign each component of *this to the value of the Right Hand
   * Side of the operator
   *
   * \param rhs
   *
   * \return
   */
  SpectrumValue& operator= (double rhs);



  /**
   * \param x the operand
   *
   * \return the euclidean norm, i.e., the sum of the squares of all
   *
   * @return the euclidean norm, i.e., the sum of the squares of all
   * the values in x
   */
  friend double Norm (const SpectrumValue& x);


  /**
   * \param x the operand
   *
   * \return the sum of all
   *
   * @return the sum of all
   * the values in x
   */
  friend double Sum (const SpectrumValue& x);


  /**
   * \param x the operand
   *
   * \return the product of all
   * the values in x
   */
  friend double Prod (const SpectrumValue& x);


  /**
   * \param lhs the base
   * \param rhs  the exponent
   *
   * \return each value in base raised to the exponent
   * @param base the base
   * @param exp  the exponent
   *
   * @return each value in base raised to the exponent
   */
  friend SpectrumValue Pow (const SpectrumValue& lhs, double rhs);


  /**
   * \param lhs the base
   * \param rhs  the exponent
   *
   * \return the value in base raised to each value in the exponent
   * @param base the base
   * @param exp  the exponent
   *
   * @return the value in base raised to each value in the exponent
   */
  friend SpectrumValue Pow (double lhs, const SpectrumValue& rhs);

  /**
   * \param arg the argument
   *
   * \return the logarithm in base 10 of all values in the argument
   * @param arg the argument
   *
   * @return the logarithm in base 10 of all values in the argument
   */
  friend SpectrumValue Log10 (const SpectrumValue& arg);


  /**
   * \param arg the argument
   *
   * \return the logarithm in base 2 of all values in the argument
   * @param arg the argument
   *
   * @return the logarithm in base 2 of all values in the argument
   */
  friend SpectrumValue Log2 (const SpectrumValue&  arg);

  /**
   * \param arg the argument
   *
   * \return the logarithm in base e of all values in the argument
   * @param arg the argument
   *
   * @return the logarithm in base e of all values in the argument
   */
  friend SpectrumValue Log (const SpectrumValue&  arg);

  /**
   * \return a Ptr to a copy of this instance
   * @return a Ptr to a copy of this instance
   */
  Ptr<SpectrumValue> Copy () const;



private:
  void Add (const SpectrumValue& x);
  void Add (double s);

double Norm (const SpectrumValue& x);
double Sum (const SpectrumValue& x);
double Prod (const SpectrumValue& x);
SpectrumValue Pow (const SpectrumValue& lhs, double rhs);
SpectrumValue Pow (double lhs, const SpectrumValue& rhs);
SpectrumValue Log10 (const SpectrumValue& arg);
SpectrumValue Log2 (const SpectrumValue& arg);
SpectrumValue Log (const SpectrumValue& arg);


} // namespace ns3




  /**
   * Set the Power Spectral Density used for outgoing waveforms
   *
   * \param txs the Power Spectral Density
   */
  void SetTxPowerSpectralDensity (Ptr<SpectrumValue> txs);


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


   * Set the period according to which the WaveformGenerator switches
   * on and off
   *
   * \param period
   */
  void SetPeriod (Time period);


  /**
   *
   * \return the value of the period according to which the WaveformGenerator switches
   * on and off
   */
  Time GetPeriod () const;


  /**
   *
   * \param value the value of the duty cycle
   */
  void SetDutyCycle (double value);

  /**
   *
   * \return the value of the duty cycle
   */
  double GetDutyCycle () const;





  virtual ~WifiSpectrumValueHelper ();
  /*
   *
   * \param value the constant value
   *
   * \return a Ptr to a newly created SpectrumValue instance which
   * has a constant value for all frequencies
   */
  virtual Ptr<SpectrumValue> CreateConstant (double psd) = 0;

  /*
   *
   * \param txPower the total TX power in W
   * \param channel the number of the channel
   *
   * \return a Ptr to a newly created SpectrumValue instance which
   * represents the TX Power Spectral Density  of a wifi device
   * corresponding to the provided parameters
   */


  /*
   *
   * \param channel the number of the channel
   *
   * \return a Ptr to a newly created SpectrumValue instance which
   * represents the frequency response of the RF filter which is used
   * by a wifi device to receive signals when tuned to a particular channel
   */





  /**
   * Returns the sum of the values.
   * \see getWeightedSum()
   */
  virtual double getSum () const = 0;

  /**
   * Returns the sum of the squared values.
   * \see getWeightedSqrSum()
   */
  virtual double getSqrSum () const = 0;


(-)a/src/tap-bridge/model/tap-bridge.h (-1 / +1 lines)

Lines 160-166	Link Here

160

/**

160

/**

161

   * Set a stop time for the device.

161

   * Set a stop time for the device.

162

163

   * @param tStop the stop time

163

   * \param tStop the stop time

164

165

   * \see TapBridge::Start

165

   * \see TapBridge::Start

166

*/

166

*/




  NS_LOG_FUNCTION (this);
}

/* uid \loc [+] [bb] (num_neigh) [&ext] -> <nuid-1> <nuid-2> ... {-euid} ... =name[!] rn */

#define REGMATCH_MAX 16


      return nodes;
    }

  /* uid \loc [+] [bb] (num_neigh) [&ext] -> <nuid-1> <nuid-2> ... {-euid} ... =name[!] rn */
  NS_LOG_INFO ("Load Node[" << uid << "]: location: " << loc << " dns: " << dns
                            << " bb: " << bb << " neighbors: " << neigh_list.size ()
                            << "(" << "%d" << ") externals: \"%s\"(%d) "

NodeContainer
RocketfuelTopologyReader::GenerateFromWeightsFile (int argc, char *argv[])
{
  /* uid \loc [+] [bb] (num_neigh) [&ext] -> <nuid-1> <nuid-2> ... {-euid} ... =name[!] rn */
  std::string sname;
  std::string tname;
  char *endptr;





  NetDeviceContainer Install (NodeContainer c) const;
  /**
   * \param c a set of nodes
   * \param channel a channel to use
   * \param c a set of nodes
   *
   * For each of the input nodes, a new ns3::UanNetDevice is attached
   * to the shared input channel. Each ns3::UanNetDevice is also


  /**
   * \param node a node where to install the uan components
   * \param channel a channel to use
   *
   * Create a default uan stack with:
   * - default channel, ideal propagation and default noise model

(-)a/src/uan/model/uan-phy.h (-1 / +1 lines)

Lines 169-175	Link Here

169

public:

169

public:

170

  static TypeId GetTypeId (void);

170

  static TypeId GetTypeId (void);

171

172

  // / Enum defining possible Phy states

172

  /// Enum defining possible Phy states

173

  enum State

173

  enum State

174

175

    IDLE, CCABUSY, RX, TX, SLEEP

175

    IDLE, CCABUSY, RX, TX, SLEEP

(-)a/src/uan/model/uan-tx-mode.h (-1 / +1 lines)

Lines 200-206	Link Here

200

*/

200

*/

201

std::istream &operator >> (std::istream &is, UanModesList &ml);

201

std::istream &operator >> (std::istream &is, UanModesList &ml);

202

203

///UanModesList is attribute value

203

/// UanModesList is attribute value

204

ATTRIBUTE_HELPER_HEADER (UanModesList);

204

ATTRIBUTE_HELPER_HEADER (UanModesList);

205

206

} // namespace ns3

206

} // namespace ns3




        """
        Set a background SVG icon for the node.

        \param file_base_name: base file name, including .svg
        extension, of the svg file.  Place the file in the folder
        src/contrib/visualizer/resource.
        
        \param width: scale to the specified width, in meters
        \param width: scale to the specified height, in meters

        \param align_x: horizontal alignment of the icon relative to
        the node position, from 0 (icon fully to the left of the node)
        to 1.0 (icon fully to the right of the node)

        \param align_y: vertical alignment of the icon relative to the
        node position, from 0 (icon fully to the top of the node) to
        1.0 (icon fully to the bottom of the node)


        assert isinstance(link, Link)
        self.links.remove(link)

    \property
    def has_mobility(self):
        if self._has_mobility is None:
            node = ns.network.NodeList.GetNode(self.node_index)




class NetDevice;

/**
 * \brief create AthstatsWifiTraceSink instances and connect them to wifi devices
 *
 *
 */



/**
 * \brief trace sink for wifi device that mimics madwifi's athstats tool.
 *
 * The AthstatsWifiTraceSink class is a trace sink to be connected to several of the traces
 * available within a wifi device. The purpose of AthstatsWifiTraceSink is to

  /**
   * function to be called when the net device transmits a packet
   *
   * \param context
   * \param p the packet being transmitted
   */
  void DevTxTrace (std::string context, Ptr<const Packet> p);

  /**
   * function to be called when the net device receives a packet
   *
   * \param context
   * \param p the packet being received
   */
  void DevRxTrace (std::string context, Ptr<const Packet> p);


   * Function to be called when a RTS frame transmission by the considered
   * device has failed
   *
   * \param context
   * \param address the MAC address of the remote station
   */
  void TxRtsFailedTrace (std::string context, Mac48Address address);


   * Function to be called when a data frame transmission by the considered
   * device has failed
   *
   * \param context
   * \param address the MAC address of the remote station
   */
  void TxDataFailedTrace (std::string context, Mac48Address address);


   * Function to be called when the transmission of a RTS frame has
   * exceeded the retry limit
   *
   * \param context
   * \param address the MAC address of the remote station
   */
  void TxFinalRtsFailedTrace (std::string context, Mac48Address address);


   * Function to be called when the transmission of a data frame has
   * exceeded the retry limit
   *
   * \param context
   * \param address the MAC address of the remote station
   */
  void TxFinalDataFailedTrace (std::string context, Mac48Address address);


   * Function to be called when the PHY layer  of the considered
   * device receives a frame
   *
   * \param context
   * \param packet
   * \param snr
   * \param mode
   * \param preamble
   */
  void PhyRxOkTrace (std::string context, Ptr<const Packet> packet, double snr, WifiMode mode, enum WifiPreamble preamble);


   * layer  of the considered device resulted in an error due to a failure in the CRC check of
   * the frame
   *
   * \param context
   * \param packet
   * \param snr
   */
  void PhyRxErrorTrace (std::string context, Ptr<const Packet> packet, double snr);


   * Function to be called when a frame is being transmitted by the
   * PHY layer of the considered device
   *
   * \param context
   * \param packet
   * \param mode
   * \param preamble
   * \param txPower
   */
  void PhyTxTrace (std::string context, Ptr<const Packet> packet, WifiMode mode, WifiPreamble preamble, uint8_t txPower);


   * Function to be called when the PHY layer of the considered device
   * changes state
   *
   * \param context
   * \param start
   * \param duration
   * \param state
   */
  void PhyStateTrace (std::string context, Time start, Time duration, enum WifiPhy::State state);

  /**
   * Open a file for output
   *
   * \param name the name of the file to be opened.
   */
  void Open (std::string const& name);

private:
  /**
   * \internal
   */
  void WriteStats ();

  /**
   * \internal
   */
  void ResetCounters ();





   * called before EnablePcap(), so that the header of the pcap file can be
   * written correctly.
   *
   * \see SupportedPcapDataLinkTypes
   *
   * \param dlt The data link type of the pcap file (and packets) to be used
   */
  void SetPcapDataLinkType (enum SupportedPcapDataLinkTypes dlt);


  virtual Ptr<WifiPhy> Create (Ptr<Node> node, Ptr<WifiNetDevice> device) const;

  /**
   * \brief Enable pcap output the indicated net device.
   *
   * NetDevice-specific implementation mechanism for hooking the trace and
   * writing to the trace file.
   *
   * \param prefix Filename prefix to use for pcap files.
   * \param nd Net device for which you want to enable tracing.
   * \param promiscuous If true capture all possible packets available at the device.
   * \param explicitFilename Treat the prefix as an explicit filename if true
   */
  virtual void EnablePcapInternal (std::string prefix,
                                   Ptr<NetDevice> nd,

(-)a/src/wifi/model/interference-helper.h (-1 / +1 lines)

Lines 121-127	Link Here

121

122

  double m_noiseFigure; /**< noise figure (linear) */

122

  double m_noiseFigure; /**< noise figure (linear) */

123

  Ptr<ErrorRateModel> m_errorRateModel;

123

  Ptr<ErrorRateModel> m_errorRateModel;

124

  ///Experimental: needed for energy duration calculation

124

  /// Experimental: needed for energy duration calculation

125

  NiChanges m_niChanges;

125

  NiChanges m_niChanges;

126

  double m_firstPower;

126

  double m_firstPower;

127

  bool m_rxing;

127

  bool m_rxing;

(-)a/src/wifi/model/qos-tag.h (-2 / +2 lines)

Lines 79-85	Link Here

   * application is aware of the QoS support provided by the MAC

   * application is aware of the QoS support provided by the MAC

   * layer, and is therefore able to set the correct TID.

   * layer, and is therefore able to set the correct TID.

   * @param tid the value of the TID to set

   * \param tid the value of the TID to set

*/

*/

  void SetTid (uint8_t tid);

  void SetTid (uint8_t tid);

Lines 90-96	Link Here

   * EDCA is used. When using HDCA, QosTag(uint8_t tid) should be used

   * EDCA is used. When using HDCA, QosTag(uint8_t tid) should be used

   * instead.

   * instead.

   * @param up the requested UserPriority

   * \param up the requested UserPriority

*/

*/

  void SetUserPriority (UserPriority up);

  void SetUserPriority (UserPriority up);




  WifiInformationElementVector ();
  ~WifiInformationElementVector ();
  ///\name Inherited from Header
  // \{
  static TypeId GetTypeId ();
  TypeId GetInstanceTypeId () const;
  virtual uint32_t GetSerializedSize () const;

  /**
   * \attention When you use RemoveHeader, WifiInformationElementVector supposes, that
   * all buffer consists of information elements
   * \param start
   * \return
   */
  virtual uint32_t Deserialize (Buffer::Iterator start);
  virtual void Print (std::ostream &os) const;
  // \}
  /**
   * \brief Needed when you try to deserialize a lonely IE inside other header
   * \param start is the start of the buffer
   * \return deserialized bytes
   */
  virtual uint32_t DeserializeSingleIe (Buffer::Iterator start);
  /// Set maximum size to control overflow of the max packet length
  void SetMaxSize (uint16_t size);
  /// As soon as this is a vector, we define an Iterator
  typedef std::vector<Ptr<WifiInformationElement> >::iterator Iterator;




   */
  static WifiMode GetPlcpHeaderMode (WifiMode payloadMode, WifiPreamble preamble);

  /**
   * 
   * 
   * \param payloadMode the WifiMode use for the transmission of the payload
   * \param preamble the type of preamble
   * 
   * \return the duration of the PLCP header in microseconds
   */

  static uint32_t GetPlcpPreambleDurationMicroSeconds (WifiMode payloadMode, WifiPreamble preamble);

  /** 
   * \param size the number of bytes in the packet to send
   * \param payloadMode the WifiMode use for the transmission of the payload
   * \param preamble the type of preamble 
   * 
   * \return the duration of the payload in microseconds
   */

   * Public method used to fire a MonitorSniffer trace for a wifi packet being received.  Implemented for encapsulation
   * purposes.
   *
   * \param packet the packet being received
   * \param channelFreqMhz the frequency in MHz at which the packet is
   * received. Note that in real devices this is normally the
   * frequency to which  the receiver is tuned, and this can be
   * different than the frequency at which the packet was originally
   * transmitted. This is because it is possible to have the receiver
   * tuned on a given channel and still to be able to receive packets
   * on a nearby channel.
   * \param channelNumber the channel on which the packet is received
   * \param rate the PHY data rate in units of 500kbps (i.e., the same
   * units used both for the radiotap and for the prism header)
   * \param isShortPreamble true if short preamble is used, false otherwise
   * \param signalDbm signal power in dBm
   * \param noiseDbm  noise power in dBm
   */
  void NotifyMonitorSniffRx (Ptr<const Packet> packet, uint16_t channelFreqMhz, uint16_t channelNumber, uint32_t rate, bool isShortPreamble,
                             double signalDbm, double noiseDbm);

   * Public method used to fire a MonitorSniffer trace for a wifi packet being transmitted.  Implemented for encapsulation
   * purposes.
   *
   * \param packet the packet being transmitted
   * \param channelFreqMhz the frequency in MHz at which the packet is
   * transmitted.
   * \param channelNumber the channel on which the packet is transmitted
   * \param rate the PHY data rate in units of 500kbps (i.e., the same
   * units used both for the radiotap and for the prism header)
   * \param isShortPreamble true if short preamble is used, false otherwise
   */
  void NotifyMonitorSniffTx (Ptr<const Packet> packet, uint16_t channelFreqMhz, uint16_t channelNumber, uint32_t rate, bool isShortPreamble);





   * because it resets time of last update.
   */
  double CalculateAveragingCoefficient ();
  /// averaging coefficient depends on the memory time
  Time m_memoryTime;
  /// when last update has occured
  Time m_lastUpdate;
  /// moving percentage of failed frames
  double m_failAvg;
};

/**
 * \ingroup wifi
 * \brief hold a list of per-remote-station state.
 * \ingroup wifi
 *
 * \sa ns3::WifiRemoteStation.
 */




   * Check if the payload tx duration returned by InterferenceHelper
   * corresponds to a known value of the pay
   *
   * \param size size of payload in octets (includes everything after the PLCP header)
   * \param payloadMode the WifiMode used
   * \param knownPlcpLengthFieldValue the known value of the Length field in the PLCP header
   *
   * \return true if values correspond, false otherwise
   */
  bool CheckPayloadDuration (uint32_t size, WifiMode payloadMode,  uint32_t knownDurationMicroSeconds);


   * Check if the overall tx duration returned by InterferenceHelper
   * corresponds to a known value of the pay
   *
   * \param size size of payload in octets (includes everything after the PLCP header)
   * \param payloadMode the WifiMode used
   * \param preamble the WifiPreamble used
   * \param knownPlcpLengthFieldValue the known value of the Length field in the PLCP header
   *
   * \return true if values correspond, false otherwise
   */
  bool CheckTxDuration (uint32_t size, WifiMode payloadMode,  WifiPreamble preamble, uint32_t knownDurationMicroSeconds);





  m_downlinkBursts->push_back (std::make_pair (dlMapIe, burst));
}

/**
 * \brief A DownLink Scheduler for rtPS Flows
 *
 * The DL Scheduler assigns the available bandwidth in the following order:
 * - IR Connections
 * - Broadcast Connections
 * - Basic and Primary Connections
 * - UGS Connections
 * - rtPS Connections
 * - nrtPS Connections
 * - BE Connections
 * All rtPS flows that have packets in the queue can transmit at least one
 * packet, according to the available bandwidth.
 */
void
BSSchedulerRtps::Schedule (void)
{
  /**
   * \brief  A DownLink Scheduler for rtPS Flows
   *
   * The DL Scheduler assigns the available bandwidth in the following order:
   *         - IR Connections
   *         - Broadcast Connections
   *         - Basic and Primary Connections
   *         - UGS Connections
   * - rtPS Connections
   *         - nrtPS Connections
   *         - BE Connections
   * All rtPS flows that have packets in the queue can transmit at least one
   * packet, according to the available bandwidth.
   */

  uint32_t availableSymbols = GetBs ()->GetNrDlSymbols ();


Return to bug 938