Attachment #832 for bug #877

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

(-)a/src/helper/csma-helper.h (-1 / +1 lines)

Lines 43-49	Link Here

 * encapsulates a general attribute or a set of functionality that

 * encapsulates a general attribute or a set of functionality that

 * may be of interest to many other classes.

 * may be of interest to many other classes.

*/

*/

class CsmaHelper : public PcapHelperForDevice, public AsciiTraceHelperForDevice

class CsmaHelper : public TraceHelperForDevice

public:

public:

/**

/**

(-)a/src/helper/emu-helper.h (-1 / +1 lines)

Lines 43-49	Link Here

 * encapsulates a general attribute or a set of functionality that

 * encapsulates a general attribute or a set of functionality that

 * may be of interest to many other classes.

 * may be of interest to many other classes.

*/

*/

  class EmuHelper : public PcapHelperForDevice, public AsciiTraceHelperForDevice

class EmuHelper : public TraceHelperForDevice

public:

public:

/*

/*




 * there is no device.  This means that the creation of output file names will
 * change, and also the user-visible methods will not reference devices and
 * therefore the number of trace enable methods is reduced.
 *
 * Normally we eschew multiple inheritance, however, the classes 
 * PcapUserHelperForIpv4 and AsciiTraceUserHelperForIpv4 are
 * treated as "mixins".  A mixin is a self-contained class that
 * encapsulates a general attribute or a set of functionality that
 * may be of interest to many other classes.
 */
class InternetStackHelper : public TraceHelperForIpvx
                              public AsciiTraceHelperForIpv4, public AsciiTraceHelperForIpv6
{
public:
  /**

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

Lines 42-48	Link Here

 * PcapUserHelperForDevice and AsciiTraceUserHelperForDevice are

 * PcapUserHelperForDevice and AsciiTraceUserHelperForDevice are

 * "mixins".

 * "mixins".

*/

*/

class PointToPointHelper : public PcapHelperForDevice, public AsciiTraceHelperForDevice

class PointToPointHelper : public TraceHelperForDevice

public:

public:

/**

/**




}

void 
TraceHelperForDevice::EnablePcap (std::string prefix, Ptr<NetDevice> nd, bool promiscuous, bool explicitFilename)
{
  EnablePcapInternal (prefix, nd, promiscuous, explicitFilename);
}

void 
TraceHelperForDevice::EnablePcap (std::string prefix, std::string ndName, bool promiscuous, bool explicitFilename)
{
  Ptr<NetDevice> nd = Names::Find<NetDevice> (ndName);
  EnablePcap (prefix, nd, promiscuous, explicitFilename);
}

void 
TraceHelperForDevice::EnablePcap (std::string prefix, NetDeviceContainer d, bool promiscuous)
{
  for (NetDeviceContainer::Iterator i = d.Begin (); i != d.End (); ++i)
    {

}

void
TraceHelperForDevice::EnablePcap (std::string prefix, NodeContainer n, bool promiscuous)
{
  NetDeviceContainer devs;
  for (NodeContainer::Iterator i = n.Begin (); i != n.End (); ++i)

}

void
TraceHelperForDevice::EnablePcapAll (std::string prefix, bool promiscuous)
{
  EnablePcap (prefix, NodeContainer::GetGlobal (), promiscuous);
}

void 
TraceHelperForDevice::EnablePcap (std::string prefix, uint32_t nodeid, uint32_t deviceid, bool promiscuous)
{
  NodeContainer n = NodeContainer::GetGlobal ();


          continue;
        }
      
      NS_ABORT_MSG_IF (deviceid >= node->GetNDevices (), "TraceHelperForDevice::EnablePcap(): Unknown deviceid = " 
                       << deviceid);
      Ptr<NetDevice> nd = node->GetDevice (deviceid);
      EnablePcap (prefix, nd, promiscuous);

// Public API
//
void 
TraceHelperForDevice::EnableAscii (std::string prefix, Ptr<NetDevice> nd, bool explicitFilename)
{
  EnableAsciiInternal (Ptr<OutputStreamWrapper> (), prefix, nd, explicitFilename);
}

// Public API
//
void 
TraceHelperForDevice::EnableAscii (Ptr<OutputStreamWrapper> stream, Ptr<NetDevice> nd)
{
  EnableAsciiInternal (stream, std::string (), nd, false);
}

// Public API
//
void 
TraceHelperForDevice::EnableAscii (std::string prefix, std::string ndName, bool explicitFilename)
{
  EnableAsciiImpl (Ptr<OutputStreamWrapper> (), prefix, ndName, explicitFilename);
}

// Public API
//
void 
TraceHelperForDevice::EnableAscii (Ptr<OutputStreamWrapper> stream, std::string ndName)
{
  EnableAsciiImpl (stream, std::string (), ndName, false);
}

// Private API
//
void 
TraceHelperForDevice::EnableAsciiImpl (
  Ptr<OutputStreamWrapper> stream, 
  std::string prefix, 
  std::string ndName,

// Public API
//
void 
TraceHelperForDevice::EnableAscii (std::string prefix, NetDeviceContainer d)
{
  EnableAsciiImpl (Ptr<OutputStreamWrapper> (), prefix, d);
}

// Public API
//
void 
TraceHelperForDevice::EnableAscii (Ptr<OutputStreamWrapper> stream, NetDeviceContainer d)
{
  EnableAsciiImpl (stream, std::string (), d);
}

// Private API
//
void 
TraceHelperForDevice::EnableAsciiImpl (Ptr<OutputStreamWrapper> stream, std::string prefix, NetDeviceContainer d)
{
  for (NetDeviceContainer::Iterator i = d.Begin (); i != d.End (); ++i)
    {

// Public API
//
void
TraceHelperForDevice::EnableAscii (std::string prefix, NodeContainer n)
{
  EnableAsciiImpl (Ptr<OutputStreamWrapper> (), prefix, n);
}

// Public API
//
void
TraceHelperForDevice::EnableAscii (Ptr<OutputStreamWrapper> stream, NodeContainer n)
{
  EnableAsciiImpl (stream, std::string (), n);
}

// Private API
//
void
TraceHelperForDevice::EnableAsciiImpl (Ptr<OutputStreamWrapper> stream, std::string prefix, NodeContainer n)
{
  NetDeviceContainer devs;
  for (NodeContainer::Iterator i = n.Begin (); i != n.End (); ++i)

// Public API
//
void
TraceHelperForDevice::EnableAsciiAll (std::string prefix)
{
  EnableAsciiImpl (Ptr<OutputStreamWrapper> (), prefix, NodeContainer::GetGlobal ());
}

// Public API
//
void
TraceHelperForDevice::EnableAsciiAll (Ptr<OutputStreamWrapper> stream)
{
  EnableAsciiImpl (stream, std::string (), NodeContainer::GetGlobal ());
}

// Public API
//
void 
TraceHelperForDevice::EnableAscii (Ptr<OutputStreamWrapper> stream, uint32_t nodeid, uint32_t deviceid)
{
  EnableAsciiImpl (stream, std::string (), nodeid, deviceid, false);
}

// Public API
//
void 
TraceHelperForDevice::EnableAscii (
  std::string prefix, 
  uint32_t nodeid, 
  uint32_t deviceid,

// Private API
//
void 
TraceHelperForDevice::EnableAsciiImpl (
  Ptr<OutputStreamWrapper> stream, 
  std::string prefix, 
  uint32_t nodeid, 

        }
      
      NS_ABORT_MSG_IF (deviceid >= node->GetNDevices (), 
                       "TraceHelperForDevice::EnableAscii(): Unknown deviceid = " << deviceid);

      Ptr<NetDevice> nd = node->GetDevice (deviceid);


}

void 
TraceHelperForIpvx::EnablePcapIpv4 (std::string prefix, Ptr<Ipv4> ipv4, uint32_t interface, bool explicitFilename)
{
  EnablePcapIpv4Internal (prefix, ipv4, interface, explicitFilename);
}

void 
TraceHelperForIpvx::EnablePcapIpv4 (std::string prefix, std::string ipv4Name, uint32_t interface, bool explicitFilename)
{
  Ptr<Ipv4> ipv4 = Names::Find<Ipv4> (ipv4Name);
  EnablePcapIpv4 (prefix, ipv4, interface, explicitFilename);
}

void 
TraceHelperForIpvx::EnablePcapIpv4 (std::string prefix, Ipv4InterfaceContainer c)
{
  for (Ipv4InterfaceContainer::Iterator i = c.Begin (); i != c.End (); ++i)
    {

}

void
TraceHelperForIpvx::EnablePcapIpv4 (std::string prefix, NodeContainer n)
{
  for (NodeContainer::Iterator i = n.Begin (); i != n.End (); ++i)
    {

}

void
TraceHelperForIpvx::EnablePcapIpv4All (std::string prefix)
{
  EnablePcapIpv4 (prefix, NodeContainer::GetGlobal ());
}

void 
TraceHelperForIpvx::EnablePcapIpv4 (std::string prefix, uint32_t nodeid, uint32_t interface, bool explicitFilename)
{
  NodeContainer n = NodeContainer::GetGlobal ();


// Public API
//
void 
TraceHelperForIpvx::EnableAsciiIpv4 (std::string prefix, Ptr<Ipv4> ipv4, uint32_t interface, bool explicitFilename)
{
  EnableAsciiIpv4Internal (Ptr<OutputStreamWrapper> (), prefix, ipv4, interface, explicitFilename);
}

// Public API
//
void 
TraceHelperForIpvx::EnableAsciiIpv4 (Ptr<OutputStreamWrapper> stream, Ptr<Ipv4> ipv4, uint32_t interface)
{
  EnableAsciiIpv4Internal (stream, std::string (), ipv4, interface, false);
}

// Public API
//
void 
TraceHelperForIpvx::EnableAsciiIpv4 (
  std::string prefix, 
  std::string ipv4Name, 
  uint32_t interface,

// Public API
//
void 
TraceHelperForIpvx::EnableAsciiIpv4 (Ptr<OutputStreamWrapper> stream, std::string ipv4Name, uint32_t interface)
{
  EnableAsciiIpv4Impl (stream, std::string (), ipv4Name, interface, false);
}

// Private API
//
void 
TraceHelperForIpvx::EnableAsciiIpv4Impl (
  Ptr<OutputStreamWrapper> stream, 
  std::string prefix, 
  std::string ipv4Name, 

// Public API
//
void 
TraceHelperForIpvx::EnableAsciiIpv4 (std::string prefix, Ipv4InterfaceContainer c)
{
  EnableAsciiIpv4Impl (Ptr<OutputStreamWrapper> (), prefix, c);
}

// Public API
//
void 
TraceHelperForIpvx::EnableAsciiIpv4 (Ptr<OutputStreamWrapper> stream, Ipv4InterfaceContainer c)
{
  EnableAsciiIpv4Impl (stream, std::string (), c);
}

// Private API
//
void 
TraceHelperForIpvx::EnableAsciiIpv4Impl (Ptr<OutputStreamWrapper> stream, std::string prefix, Ipv4InterfaceContainer c)
{
  for (Ipv4InterfaceContainer::Iterator i = c.Begin (); i != c.End (); ++i)
    {

// Public API
//
void
TraceHelperForIpvx::EnableAsciiIpv4 (std::string prefix, NodeContainer n)
{
  EnableAsciiIpv4Impl (Ptr<OutputStreamWrapper> (), prefix, n);
}

// Public API
//
void
TraceHelperForIpvx::EnableAsciiIpv4 (Ptr<OutputStreamWrapper> stream, NodeContainer n)
{
  EnableAsciiIpv4Impl (stream, std::string (), n);
}

// Private API
//
void
TraceHelperForIpvx::EnableAsciiIpv4Impl (Ptr<OutputStreamWrapper> stream, std::string prefix, NodeContainer n)
{
  for (NodeContainer::Iterator i = n.Begin (); i != n.End (); ++i)
    {

// Public API
//
void
TraceHelperForIpvx::EnableAsciiIpv4All (std::string prefix)
{
  EnableAsciiIpv4Impl (Ptr<OutputStreamWrapper> (), prefix, NodeContainer::GetGlobal ());
}

// Public API
//
void
TraceHelperForIpvx::EnableAsciiIpv4All (Ptr<OutputStreamWrapper> stream)
{
  EnableAsciiIpv4Impl (stream, std::string (), NodeContainer::GetGlobal ());
}

// Public API
//
void 
TraceHelperForIpvx::EnableAsciiIpv4 (
  Ptr<OutputStreamWrapper> stream, 
  uint32_t nodeid, 
  uint32_t interface,

// Public API
//
void 
TraceHelperForIpvx::EnableAsciiIpv4 (std::string prefix, uint32_t nodeid, uint32_t interface, bool explicitFilename)
{
  EnableAsciiIpv4Impl (Ptr<OutputStreamWrapper> (), prefix, nodeid, interface, explicitFilename);
}

// Private API
//
void 
TraceHelperForIpvx::EnableAsciiIpv4Impl (
  Ptr<OutputStreamWrapper> stream, 
  std::string prefix, 
  uint32_t nodeid, 

}

void 
TraceHelperForIpvx::EnablePcapIpv6 (std::string prefix, Ptr<Ipv6> ipv6, uint32_t interface, bool explicitFilename)
{
  EnablePcapIpv6Internal (prefix, ipv6, interface, explicitFilename);
}

void 
TraceHelperForIpvx::EnablePcapIpv6 (std::string prefix, std::string ipv6Name, uint32_t interface, bool explicitFilename)
{
  Ptr<Ipv6> ipv6 = Names::Find<Ipv6> (ipv6Name);
  EnablePcapIpv6 (prefix, ipv6, interface, explicitFilename);
}

void 
TraceHelperForIpvx::EnablePcapIpv6 (std::string prefix, Ipv6InterfaceContainer c)
{
  for (Ipv6InterfaceContainer::Iterator i = c.Begin (); i != c.End (); ++i)
    {

}

void
TraceHelperForIpvx::EnablePcapIpv6 (std::string prefix, NodeContainer n)
{
  for (NodeContainer::Iterator i = n.Begin (); i != n.End (); ++i)
    {

}

void
TraceHelperForIpvx::EnablePcapIpv6All (std::string prefix)
{
  EnablePcapIpv6 (prefix, NodeContainer::GetGlobal ());
}

void 
TraceHelperForIpvx::EnablePcapIpv6 (std::string prefix, uint32_t nodeid, uint32_t interface, bool explicitFilename)
{
  NodeContainer n = NodeContainer::GetGlobal ();


// Public API
//
void 
TraceHelperForIpvx::EnableAsciiIpv6 (std::string prefix, Ptr<Ipv6> ipv6, uint32_t interface, bool explicitFilename)
{
  EnableAsciiIpv6Internal (Ptr<OutputStreamWrapper> (), prefix, ipv6, interface, explicitFilename);
}

// Public API
//
void 
TraceHelperForIpvx::EnableAsciiIpv6 (Ptr<OutputStreamWrapper> stream, Ptr<Ipv6> ipv6, uint32_t interface)
{
  EnableAsciiIpv6Internal (stream, std::string (), ipv6, interface, false);
}

// Public API
//
void 
TraceHelperForIpvx::EnableAsciiIpv6 (std::string prefix, std::string ipv6Name, uint32_t interface, bool explicitFilename)
{
  EnableAsciiIpv6Impl (Ptr<OutputStreamWrapper> (), prefix, ipv6Name, interface, explicitFilename);
}

// Public API
//
void 
TraceHelperForIpvx::EnableAsciiIpv6 (Ptr<OutputStreamWrapper> stream, std::string ipv6Name, uint32_t interface)
{
  EnableAsciiIpv6Impl (stream, std::string (), ipv6Name, interface, false);
}

// Private API
//
void 
TraceHelperForIpvx::EnableAsciiIpv6Impl (
  Ptr<OutputStreamWrapper> stream, 
  std::string prefix, 
  std::string ipv6Name, 

// Public API
//
void 
TraceHelperForIpvx::EnableAsciiIpv6 (std::string prefix, Ipv6InterfaceContainer c)
{
  EnableAsciiIpv6Impl (Ptr<OutputStreamWrapper> (), prefix, c);
}

// Public API
//
void 
TraceHelperForIpvx::EnableAsciiIpv6 (Ptr<OutputStreamWrapper> stream, Ipv6InterfaceContainer c)
{
  EnableAsciiIpv6Impl (stream, std::string (), c);
}

// Private API
//
void 
TraceHelperForIpvx::EnableAsciiIpv6Impl (Ptr<OutputStreamWrapper> stream, std::string prefix, Ipv6InterfaceContainer c)
{
  for (Ipv6InterfaceContainer::Iterator i = c.Begin (); i != c.End (); ++i)
    {

// Public API
//
void
TraceHelperForIpvx::EnableAsciiIpv6 (std::string prefix, NodeContainer n)
{
  EnableAsciiIpv6Impl (Ptr<OutputStreamWrapper> (), prefix, n);
}

// Public API
//
void
TraceHelperForIpvx::EnableAsciiIpv6 (Ptr<OutputStreamWrapper> stream, NodeContainer n)
{
  EnableAsciiIpv6Impl (stream, std::string (), n);
}

// Private API
//
void
TraceHelperForIpvx::EnableAsciiIpv6Impl (Ptr<OutputStreamWrapper> stream, std::string prefix, NodeContainer n)
{
  for (NodeContainer::Iterator i = n.Begin (); i != n.End (); ++i)
    {

// Public API
//
void
TraceHelperForIpvx::EnableAsciiIpv6All (std::string prefix)
{
  EnableAsciiIpv6Impl (Ptr<OutputStreamWrapper> (), prefix, NodeContainer::GetGlobal ());
}

// Public API
//
void
TraceHelperForIpvx::EnableAsciiIpv6All (Ptr<OutputStreamWrapper> stream)
{
  EnableAsciiIpv6Impl (stream, std::string (), NodeContainer::GetGlobal ());
}

// Public API
//
void 
TraceHelperForIpvx::EnableAsciiIpv6 (Ptr<OutputStreamWrapper> stream, uint32_t nodeid, uint32_t interface)
{
  EnableAsciiIpv6Impl (stream, std::string (), nodeid, interface, false);
}

// Public API
//
void 
TraceHelperForIpvx::EnableAsciiIpv6 (std::string prefix, uint32_t nodeid, uint32_t interface, bool explicitFilename)
{
  EnableAsciiIpv6Impl (Ptr<OutputStreamWrapper> (), prefix, nodeid, interface, explicitFilename);
}

// Private API
//
void 
TraceHelperForIpvx::EnableAsciiIpv6Impl (
  Ptr<OutputStreamWrapper> stream, 
  std::string prefix, 
  uint32_t nodeid, 




}

/**
 * \brief Base class providing common user-level pcap and ascii operations for helpers
 * representing net devices.
 */
class TraceHelperForDevice
{
public:
  /**
   * @brief Construct a PcapHelperForDevice
   */
  TraceHelperForDevice () {}

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

  /**
   * @brief Enable pcap output the indicated net device.

   * @param promiscuous If true capture all possible packets available at the device.
   */
  void EnablePcapAll (std::string prefix, bool promiscuous = false);
};

/**
 * \brief Base class providing common user-level ascii trace operations for helpers
 * representing net devices.
 */
class AsciiTraceHelperForDevice
{
public:
  /**
   * @brief Construct an AsciiTraceHelperForDevice.
   */
  AsciiTraceHelperForDevice () {}

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

  /**
   * @brief Enable ascii trace output on the indicated net device.

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

};

/**
 * @brief Base class providing common user-level pcap and ascii operations for helpers
 * representing IPv4 and IPv6 protocols .
 */
class TraceHelperForIpvx
{
public:
  /**
   * @brief Construct a TraceHelperForIpv4.
   */
  TraceHelperForIpvx () {}

  /**
   * @brief Destroy a TraceHelperForIpv4.
   */
  virtual ~TraceHelperForIpvx () {}

  /**
   * @brief Enable pcap output the indicated Ipv4 and interface pair.

   */
  void EnablePcapIpv4All (std::string prefix);

};

/**
 * @brief Base class providing common user-level ascii trace operations for 
 * helpers representing IPv4 protocols .
 */
class AsciiTraceHelperForIpv4
{
public:
  /**
   * @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, 
                                       uint32_t interface,
                                       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.
   * \param n container of nodes.
   */
  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 Enable ascii trace output on the indicated Ipv4 and interface pair.

   */
  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, 
                            uint32_t nodeid, 
                            uint32_t interface,
                            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, 
                            std::string ipv4Name, 
                            uint32_t interface,
                            bool explicitFilename);

  /**
   * @internal Avoid code duplication.
   */
  void EnableAsciiIpv4Impl (Ptr<OutputStreamWrapper> stream, 
                            std::string prefix, 
                            Ptr<Ipv4> ipv4, 
                            uint32_t interface,
                            bool explicitFilename);
};

/**
 * @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, 
                                       uint32_t interface,
                                       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.
   * \param n container of nodes.
   */
  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

  /**
   * @internal Avoid code duplication.
   */
  void EnableAsciiIpv4Impl (Ptr<OutputStreamWrapper> stream, 
                            std::string prefix, 
                            uint32_t nodeid, 
                            uint32_t interface,
                            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, 
                            std::string ipv4Name, 
                            uint32_t interface,
                            bool explicitFilename);

  /**
   * @internal Avoid code duplication.
   */
  void EnableAsciiIpv4Impl (Ptr<OutputStreamWrapper> stream, 
                            std::string prefix, 
                            Ptr<Ipv4> ipv4, 
                            uint32_t interface,
                            bool explicitFilename);

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

                            bool explicitFilename);
};



} // namespace ns3

#endif /* TRACE_HELPER_H */

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

Lines 43-49	Link Here

 * This base class must be implemented by new PHY implementation which wish to integrate

 * This base class must be implemented by new PHY implementation which wish to integrate

 * with the \ref ns3::WifiHelper class.

 * with the \ref ns3::WifiHelper class.

*/

*/

class WifiPhyHelper

class WifiPhyHelper : public TraceHelperForDevice

public:

public:

  virtual ~WifiPhyHelper ();

  virtual ~WifiPhyHelper ();

(-)a/src/helper/wimax-helper.h (-1 / +1 lines)

Lines 49-55	Link Here

/**

/**

 * \brief build a set of WimaxNetDevice objects

 * \brief build a set of WimaxNetDevice objects

*/

*/

class WimaxHelper :public PcapHelperForDevice, public AsciiTraceHelperForDevice

class WimaxHelper : public TraceHelperForDevice

public:

public:

/**

/**

(-)a/src/helper/yans-wifi-helper.h (-2 / +1 lines)

Lines 136-143	Link Here

136

 * in this class correspond to PHY-level traces and come to us via WifiPhyHelper

136

 * in this class correspond to PHY-level traces and come to us via WifiPhyHelper

137

138

*/

138

*/

139

class YansWifiPhyHelper : public WifiPhyHelper,

139

class YansWifiPhyHelper : public WifiPhyHelper

140

                          public PcapHelperForDevice, public AsciiTraceHelperForDevice

141

140

142

public:

141

public:

143

/**

142

/**

Return to bug 877