introduce the ns3::String class, get rid of the string -> Attribute implicit conversion, and get rid of MakeDataRate, port PointToPointNetDevice to Attributes
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007 University of Washington
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation;
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Author: Craig Dowell <craigdo@ee.washington.edu>
*/
#ifndef POINT_TO_POINT_NET_DEVICE_H
#define POINT_TO_POINT_NET_DEVICE_H
#include <string.h>
#include "ns3/address.h"
#include "ns3/node.h"
#include "ns3/net-device.h"
#include "ns3/callback.h"
#include "ns3/packet.h"
#include "ns3/traced-callback.h"
#include "ns3/nstime.h"
#include "ns3/data-rate.h"
#include "ns3/ptr.h"
#include "ns3/mac48-address.h"
namespace ns3 {
class Queue;
class PointToPointChannel;
class ErrorModel;
/**
* \class PointToPointNetDevice
* \brief A Device for a Point to Point Network Link.
*
* This PointToPointNetDevice class specializes the NetDevice abstract
* base class. Together with a PointToPointChannel (and a peer
* PointToPointNetDevice), the class models, with some level of
* abstraction, a generic point-to-point or serial link.
* Key parameters or objects that can be specified for this device
* include a queue, data rate, and interframe transmission gap (the
* propagation delay is set in the PointToPointChannel).
*/
class PointToPointNetDevice : public NetDevice
{
public:
static TypeId GetTypeId (void);
/**
* Construct a PointToPointNetDevice
*
* This is the constructor for the PointToPointNetDevice. It takes as a
* parameter a pointer to the Node to which this device is connected,
* as well as an optional DataRate object.
*
* @see PointToPointTopology::AddPointToPointLink ()
*/
PointToPointNetDevice ();
/**
* Destroy a PointToPointNetDevice
*
* This is the destructor for the PointToPointNetDevice.
*/
virtual ~PointToPointNetDevice ();
/**
* Set the Data Rate used for transmission of packets. The data rate is
* 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 (const DataRate& bps);
/**
* Set the inteframe gap used to separate packets. The interframe gap
* defines the minimum space required between packets sent by this device.
* It is usually set in the Attach () method based on the speed of light
* delay of the channel to which the device is attached. It can be
* overridden using this method if desired.
*
* @see Attach ()
* @param t the interframe gap time
*/
void SetInterframeGap (const Time& t);
/**
* Attach the device to a channel.
*
* The PointToPointTopology object creates a PointToPointChannel and two
* PointtoPointNetDevices. In order to introduce these components to each
* other, the topology object calls Attach () on each PointToPointNetDevice.
* Inside this method, the Net Device calls out to the PointToPointChannel
* to introduce itself.
*
* @see PointToPointTopology::AddPointToPointLink ()
* @see SetDataRate ()
* @see SetInterframeGap ()
* @param ch a pointer to the channel to which this object is being attached.
*/
bool Attach (Ptr<PointToPointChannel> ch);
/**
* Attach a queue to the PointToPointNetDevice.
*
* The PointToPointNetDevice "owns" a queue. This queue is created by the
* PointToPointTopology object and implements a queueing method such as
* DropTail or RED. The PointToPointNetDevice assumes ownership of this
* queue and must delete it when the device is destroyed.
*
* @see PointToPointTopology::AddPointToPointLink ()
* @see Queue
* @see DropTailQueue
* @param queue a pointer to the queue for which object is assuming
* ownership.
*/
void AddQueue (Ptr<Queue> queue);
/**
* Attach a receive ErrorModel to the PointToPointNetDevice.
*
* The PointToPointNetDevice may optionally include an ErrorModel in
* the packet receive chain.
*
* @see ErrorModel
* @param em a pointer to the ErrorModel
*/
void AddReceiveErrorModel(Ptr<ErrorModel> em);
/**
* Receive a packet from a connected PointToPointChannel.
*
* The PointToPointNetDevice receives packets from its connected channel
* and forwards them up the protocol stack. This is the public method
* used by the channel to indicate that the last bit of a packet has
* arrived at the device.
*
* @see PointToPointChannel
* @param p a reference to the received packet
*/
void Receive (Ptr<Packet> p);
// inherited from NetDevice base class.
virtual void SetName(const std::string name);
virtual std::string GetName(void) const;
virtual void SetIfIndex(const uint32_t index);
virtual uint32_t GetIfIndex(void) const;
virtual Ptr<Channel> GetChannel (void) const;
virtual Address GetAddress (void) const;
virtual bool SetMtu (const uint16_t mtu);
virtual uint16_t GetMtu (void) const;
virtual bool IsLinkUp (void) const;
virtual void SetLinkChangeCallback (Callback<void> callback);
virtual bool IsBroadcast (void) const;
virtual Address GetBroadcast (void) const;
virtual bool IsMulticast (void) const;
virtual Address GetMulticast (void) const;
virtual Address MakeMulticastAddress (Ipv4Address multicastGroup) const;
virtual bool IsPointToPoint (void) const;
virtual bool Send(Ptr<Packet> packet, const Address& dest, uint16_t protocolNumber);
virtual Ptr<Node> GetNode (void) const;
virtual bool NeedsArp (void) const;
virtual void SetReceiveCallback (NetDevice::ReceiveCallback cb);
private:
virtual void DoDispose (void);
/**
* Get a copy of the attached Queue.
*
* This method is provided for any derived class that may need to get
* direct access to the underlying queue.
*
* @see PointToPointTopology
* @returns a pointer to the queue.
*/
Ptr<Queue> GetQueue(void) const;
private:
/**
* Adds the necessary headers and trailers to a packet of data in order to
* respect the protocol implemented by the agent.
*/
void AddHeader(Ptr<Packet> p, uint16_t protocolNumber);
/**
* Removes, from a packet of data, all headers and trailers that
* relate to the protocol implemented by the agent
* \return Returns true if the packet should be forwarded up the
* protocol stack.
*/
bool ProcessHeader(Ptr<Packet> p, uint16_t& param);
/**
* Start Sending a Packet Down the Wire.
*
* The TransmitStart method is the method that is used internally in the
* PointToPointNetDevice to begin the process of sending a packet out on
* the channel. The corresponding method is called on the channel to let
* it know that the physical device this class represents has virually
* 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);
/**
* Stop Sending a Packet Down the Wire and Begin the Interframe Gap.
*
* The TransmitComplete method is used internally to finish the process
* of sending a packet out on the channel.
*
*/
void TransmitComplete(void);
void NotifyLinkUp (void);
/**
* Enumeration of the states of the transmit machine of the net device.
*/
enum TxMachineState
{
READY, /**< The transmitter is ready to begin transmission of a packet */
BUSY /**< The transmitter is busy transmitting a packet */
};
/**
* 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;
/**
* The trace source for the packet reception events that the device can
* fire.
*
* @see class CallBackTraceSource
* @see class TraceResolver
*/
TracedCallback<Ptr<const Packet> > m_rxTrace;
/**
* The trace source for the packet drop events that the device can
* fire.
*
* @see class CallBackTraceSource
* @see class TraceResolver
*/
TracedCallback<Ptr<const Packet> > m_dropTrace;
/**
* Error model for receive packet events
*/
Ptr<ErrorModel> m_receiveErrorModel;
Ptr<Node> m_node;
Mac48Address m_address;
NetDevice::ReceiveCallback m_rxCallback;
uint32_t m_ifIndex;
std::string m_name;
bool m_linkUp;
Callback<void> m_linkChangeCallback;
uint16_t m_mtu;
};
} // namespace ns3
#endif // POINT_TO_POINT_NET_DEVICE_H