A Discrete-Event Network Simulator
API
point-to-point-net-device.cc
Go to the documentation of this file.
1/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2/*
3 * Copyright (c) 2007, 2008 University of Washington
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation;
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 */
18
19#include "ns3/log.h"
20#include "ns3/queue.h"
21#include "ns3/simulator.h"
22#include "ns3/mac48-address.h"
23#include "ns3/llc-snap-header.h"
24#include "ns3/error-model.h"
25#include "ns3/trace-source-accessor.h"
26#include "ns3/uinteger.h"
27#include "ns3/pointer.h"
30#include "ppp-header.h"
31
32namespace ns3 {
33
34NS_LOG_COMPONENT_DEFINE ("PointToPointNetDevice");
35
36NS_OBJECT_ENSURE_REGISTERED (PointToPointNetDevice);
37
38TypeId
40{
41 static TypeId tid = TypeId ("ns3::PointToPointNetDevice")
43 .SetGroupName ("PointToPoint")
44 .AddConstructor<PointToPointNetDevice> ()
45 .AddAttribute ("Mtu", "The MAC-level Maximum Transmission Unit",
49 MakeUintegerChecker<uint16_t> ())
50 .AddAttribute ("Address",
51 "The MAC address of this device.",
52 Mac48AddressValue (Mac48Address ("ff:ff:ff:ff:ff:ff")),
53 MakeMac48AddressAccessor (&PointToPointNetDevice::m_address),
54 MakeMac48AddressChecker ())
55 .AddAttribute ("DataRate",
56 "The default data rate for point to point links",
57 DataRateValue (DataRate ("32768b/s")),
58 MakeDataRateAccessor (&PointToPointNetDevice::m_bps),
59 MakeDataRateChecker ())
60 .AddAttribute ("ReceiveErrorModel",
61 "The receiver error model used to simulate packet loss",
62 PointerValue (),
64 MakePointerChecker<ErrorModel> ())
65 .AddAttribute ("InterframeGap",
66 "The time to wait between packet (frame) transmissions",
67 TimeValue (Seconds (0.0)),
70
71 //
72 // Transmit queueing discipline for the device which includes its own set
73 // of trace hooks.
74 //
75 .AddAttribute ("TxQueue",
76 "A queue to use as the transmit queue in the device.",
77 PointerValue (),
79 MakePointerChecker<Queue<Packet> > ())
80
81 //
82 // Trace sources at the "top" of the net device, where packets transition
83 // to/from higher layers.
84 //
85 .AddTraceSource ("MacTx",
86 "Trace source indicating a packet has arrived "
87 "for transmission by this device",
89 "ns3::Packet::TracedCallback")
90 .AddTraceSource ("MacTxDrop",
91 "Trace source indicating a packet has been dropped "
92 "by the device before transmission",
94 "ns3::Packet::TracedCallback")
95 .AddTraceSource ("MacPromiscRx",
96 "A packet has been received by this device, "
97 "has been passed up from the physical layer "
98 "and is being forwarded up the local protocol stack. "
99 "This is a promiscuous trace,",
101 "ns3::Packet::TracedCallback")
102 .AddTraceSource ("MacRx",
103 "A packet has been received by this device, "
104 "has been passed up from the physical layer "
105 "and is being forwarded up the local protocol stack. "
106 "This is a non-promiscuous trace,",
108 "ns3::Packet::TracedCallback")
109#if 0
110 // Not currently implemented for this device
111 .AddTraceSource ("MacRxDrop",
112 "Trace source indicating a packet was dropped "
113 "before being forwarded up the stack",
115 "ns3::Packet::TracedCallback")
116#endif
117 //
118 // Trace sources at the "bottom" of the net device, where packets transition
119 // to/from the channel.
120 //
121 .AddTraceSource ("PhyTxBegin",
122 "Trace source indicating a packet has begun "
123 "transmitting over the channel",
125 "ns3::Packet::TracedCallback")
126 .AddTraceSource ("PhyTxEnd",
127 "Trace source indicating a packet has been "
128 "completely transmitted over the channel",
130 "ns3::Packet::TracedCallback")
131 .AddTraceSource ("PhyTxDrop",
132 "Trace source indicating a packet has been "
133 "dropped by the device during transmission",
135 "ns3::Packet::TracedCallback")
136#if 0
137 // Not currently implemented for this device
138 .AddTraceSource ("PhyRxBegin",
139 "Trace source indicating a packet has begun "
140 "being received by the device",
142 "ns3::Packet::TracedCallback")
143#endif
144 .AddTraceSource ("PhyRxEnd",
145 "Trace source indicating a packet has been "
146 "completely received by the device",
148 "ns3::Packet::TracedCallback")
149 .AddTraceSource ("PhyRxDrop",
150 "Trace source indicating a packet has been "
151 "dropped by the device during reception",
153 "ns3::Packet::TracedCallback")
154
155 //
156 // Trace sources designed to simulate a packet sniffer facility (tcpdump).
157 // Note that there is really no difference between promiscuous and
158 // non-promiscuous traces in a point-to-point link.
159 //
160 .AddTraceSource ("Sniffer",
161 "Trace source simulating a non-promiscuous packet sniffer "
162 "attached to the device",
164 "ns3::Packet::TracedCallback")
165 .AddTraceSource ("PromiscSniffer",
166 "Trace source simulating a promiscuous packet sniffer "
167 "attached to the device",
169 "ns3::Packet::TracedCallback")
170 ;
171 return tid;
172}
173
174
176 :
177 m_txMachineState (READY),
178 m_channel (0),
179 m_linkUp (false),
180 m_currentPkt (0)
181{
182 NS_LOG_FUNCTION (this);
183}
184
186{
187 NS_LOG_FUNCTION (this);
188}
189
190void
192{
193 NS_LOG_FUNCTION (this << p << protocolNumber);
194 PppHeader ppp;
195 ppp.SetProtocol (EtherToPpp (protocolNumber));
196 p->AddHeader (ppp);
197}
198
199bool
201{
202 NS_LOG_FUNCTION (this << p << param);
203 PppHeader ppp;
204 p->RemoveHeader (ppp);
205 param = PppToEther (ppp.GetProtocol ());
206 return true;
207}
208
209void
211{
212 NS_LOG_FUNCTION (this);
213 m_node = 0;
214 m_channel = 0;
216 m_currentPkt = 0;
217 m_queue = 0;
219}
220
221void
223{
224 NS_LOG_FUNCTION (this);
225 m_bps = bps;
226}
227
228void
230{
231 NS_LOG_FUNCTION (this << t.As (Time::S));
233}
234
235bool
237{
238 NS_LOG_FUNCTION (this << p);
239 NS_LOG_LOGIC ("UID is " << p->GetUid () << ")");
240
241 //
242 // This function is called to start the process of transmitting a packet.
243 // We need to tell the channel that we've started wiggling the wire and
244 // schedule an event that will be executed when the transmission is complete.
245 //
246 NS_ASSERT_MSG (m_txMachineState == READY, "Must be READY to transmit");
248 m_currentPkt = p;
250
251 Time txTime = m_bps.CalculateBytesTxTime (p->GetSize ());
252 Time txCompleteTime = txTime + m_tInterframeGap;
253
254 NS_LOG_LOGIC ("Schedule TransmitCompleteEvent in " << txCompleteTime.As (Time::S));
256
257 bool result = m_channel->TransmitStart (p, this, txTime);
258 if (result == false)
259 {
261 }
262 return result;
263}
264
265void
267{
268 NS_LOG_FUNCTION (this);
269
270 //
271 // This function is called to when we're all done transmitting a packet.
272 // We try and pull another packet off of the transmit queue. If the queue
273 // is empty, we are done, otherwise we need to start transmitting the
274 // next packet.
275 //
276 NS_ASSERT_MSG (m_txMachineState == BUSY, "Must be BUSY if transmitting");
278
279 NS_ASSERT_MSG (m_currentPkt, "PointToPointNetDevice::TransmitComplete(): m_currentPkt zero");
280
282 m_currentPkt = 0;
283
284 Ptr<Packet> p = m_queue->Dequeue ();
285 if (!p)
286 {
287 NS_LOG_LOGIC ("No pending packets in device queue after tx complete");
288 return;
289 }
290
291 //
292 // Got another packet off of the queue, so start the transmit process again.
293 //
294 m_snifferTrace (p);
296 TransmitStart (p);
297}
298
299bool
301{
302 NS_LOG_FUNCTION (this << &ch);
303
304 m_channel = ch;
305
306 m_channel->Attach (this);
307
308 //
309 // This device is up whenever it is attached to a channel. A better plan
310 // would be to have the link come up when both devices are attached, but this
311 // is not done for now.
312 //
313 NotifyLinkUp ();
314 return true;
315}
316
317void
319{
320 NS_LOG_FUNCTION (this << q);
321 m_queue = q;
322}
323
324void
326{
327 NS_LOG_FUNCTION (this << em);
329}
330
331void
333{
334 NS_LOG_FUNCTION (this << packet);
335 uint16_t protocol = 0;
336
337 if (m_receiveErrorModel && m_receiveErrorModel->IsCorrupt (packet) )
338 {
339 //
340 // If we have an error model and it indicates that it is time to lose a
341 // corrupted packet, don't forward this packet up, let it go.
342 //
343 m_phyRxDropTrace (packet);
344 }
345 else
346 {
347 //
348 // Hit the trace hooks. All of these hooks are in the same place in this
349 // device because it is so simple, but this is not usually the case in
350 // more complicated devices.
351 //
352 m_snifferTrace (packet);
353 m_promiscSnifferTrace (packet);
354 m_phyRxEndTrace (packet);
355
356 //
357 // Trace sinks will expect complete packets, not packets without some of the
358 // headers.
359 //
360 Ptr<Packet> originalPacket = packet->Copy ();
361
362 //
363 // Strip off the point-to-point protocol header and forward this packet
364 // up the protocol stack. Since this is a simple point-to-point link,
365 // there is no difference in what the promisc callback sees and what the
366 // normal receive callback sees.
367 //
368 ProcessHeader (packet, protocol);
369
371 {
372 m_macPromiscRxTrace (originalPacket);
373 m_promiscCallback (this, packet, protocol, GetRemote (), GetAddress (), NetDevice::PACKET_HOST);
374 }
375
376 m_macRxTrace (originalPacket);
377 m_rxCallback (this, packet, protocol, GetRemote ());
378 }
379}
380
383{
384 NS_LOG_FUNCTION (this);
385 return m_queue;
386}
387
388void
390{
391 NS_LOG_FUNCTION (this);
392 m_linkUp = true;
394}
395
396void
398{
399 NS_LOG_FUNCTION (this);
400 m_ifIndex = index;
401}
402
405{
406 return m_ifIndex;
407}
408
411{
412 return m_channel;
413}
414
415//
416// This is a point-to-point device, so we really don't need any kind of address
417// information. However, the base class NetDevice wants us to define the
418// methods to get and set the address. Rather than be rude and assert, we let
419// clients get and set the address, but simply ignore them.
420
421void
423{
424 NS_LOG_FUNCTION (this << address);
426}
427
430{
431 return m_address;
432}
433
434bool
436{
437 NS_LOG_FUNCTION (this);
438 return m_linkUp;
439}
440
441void
443{
444 NS_LOG_FUNCTION (this);
446}
447
448//
449// This is a point-to-point device, so every transmission is a broadcast to
450// all of the devices on the network.
451//
452bool
454{
455 NS_LOG_FUNCTION (this);
456 return true;
457}
458
459//
460// We don't really need any addressing information since this is a
461// point-to-point device. The base class NetDevice wants us to return a
462// broadcast address, so we make up something reasonable.
463//
466{
467 NS_LOG_FUNCTION (this);
468 return Mac48Address ("ff:ff:ff:ff:ff:ff");
469}
470
471bool
473{
474 NS_LOG_FUNCTION (this);
475 return true;
476}
477
480{
481 NS_LOG_FUNCTION (this);
482 return Mac48Address ("01:00:5e:00:00:00");
483}
484
487{
488 NS_LOG_FUNCTION (this << addr);
489 return Mac48Address ("33:33:00:00:00:00");
490}
491
492bool
494{
495 NS_LOG_FUNCTION (this);
496 return true;
497}
498
499bool
501{
502 NS_LOG_FUNCTION (this);
503 return false;
504}
505
506bool
508 Ptr<Packet> packet,
509 const Address &dest,
510 uint16_t protocolNumber)
511{
512 NS_LOG_FUNCTION (this << packet << dest << protocolNumber);
513 NS_LOG_LOGIC ("p=" << packet << ", dest=" << &dest);
514 NS_LOG_LOGIC ("UID is " << packet->GetUid ());
515
516 //
517 // If IsLinkUp() is false it means there is no channel to send any packet
518 // over so we just hit the drop trace on the packet and return an error.
519 //
520 if (IsLinkUp () == false)
521 {
522 m_macTxDropTrace (packet);
523 return false;
524 }
525
526 //
527 // Stick a point to point protocol header on the packet in preparation for
528 // shoving it out the door.
529 //
530 AddHeader (packet, protocolNumber);
531
532 m_macTxTrace (packet);
533
534 //
535 // We should enqueue and dequeue the packet to hit the tracing hooks.
536 //
537 if (m_queue->Enqueue (packet))
538 {
539 //
540 // If the channel is ready for transition we send the packet right now
541 //
542 if (m_txMachineState == READY)
543 {
544 packet = m_queue->Dequeue ();
545 m_snifferTrace (packet);
546 m_promiscSnifferTrace (packet);
547 bool ret = TransmitStart (packet);
548 return ret;
549 }
550 return true;
551 }
552
553 // Enqueue may fail (overflow)
554
555 m_macTxDropTrace (packet);
556 return false;
557}
558
559bool
561 const Address &source,
562 const Address &dest,
563 uint16_t protocolNumber)
564{
565 NS_LOG_FUNCTION (this << packet << source << dest << protocolNumber);
566 return false;
567}
568
571{
572 return m_node;
573}
574
575void
577{
578 NS_LOG_FUNCTION (this);
579 m_node = node;
580}
581
582bool
584{
585 NS_LOG_FUNCTION (this);
586 return false;
587}
588
589void
591{
592 m_rxCallback = cb;
593}
594
595void
597{
599}
600
601bool
603{
604 NS_LOG_FUNCTION (this);
605 return false;
606}
607
608void
610{
611 NS_LOG_FUNCTION (this << p);
612 Receive (p);
613}
614
617{
618 NS_LOG_FUNCTION (this);
619 NS_ASSERT (m_channel->GetNDevices () == 2);
620 for (std::size_t i = 0; i < m_channel->GetNDevices (); ++i)
621 {
622 Ptr<NetDevice> tmp = m_channel->GetDevice (i);
623 if (tmp != this)
624 {
625 return tmp->GetAddress ();
626 }
627 }
628 NS_ASSERT (false);
629 // quiet compiler.
630 return Address ();
631}
632
633bool
635{
636 NS_LOG_FUNCTION (this << mtu);
637 m_mtu = mtu;
638 return true;
639}
640
641uint16_t
643{
644 NS_LOG_FUNCTION (this);
645 return m_mtu;
646}
647
648uint16_t
650{
652 switch(proto)
653 {
654 case 0x0021: return 0x0800; //IPv4
655 case 0x0057: return 0x86DD; //IPv6
656 default: NS_ASSERT_MSG (false, "PPP Protocol number not defined!");
657 }
658 return 0;
659}
660
661uint16_t
663{
665 switch(proto)
666 {
667 case 0x0800: return 0x0021; //IPv4
668 case 0x86DD: return 0x0057; //IPv6
669 default: NS_ASSERT_MSG (false, "PPP Protocol number not defined!");
670 }
671 return 0;
672}
673
674
675} // namespace ns3
a polymophic address class
Definition: address.h:91
bool IsNull(void) const
Check for null implementation.
Definition: callback.h:532
Class for representing data rates.
Definition: data-rate.h:89
Time CalculateBytesTxTime(uint32_t bytes) const
Calculate transmission time.
Definition: data-rate.cc:275
AttributeValue implementation for DataRate.
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:41
Describes an IPv6 address.
Definition: ipv6-address.h:50
an EUI-48 address
Definition: mac48-address.h:44
static Mac48Address ConvertFrom(const Address &address)
AttributeValue implementation for Mac48Address.
Network layer to device interface.
Definition: net-device.h:96
@ PACKET_HOST
Packet addressed oo us.
Definition: net-device.h:298
virtual void DoDispose(void)
Destructor implementation.
Definition: object.cc:346
uint32_t RemoveHeader(Header &header)
Deserialize and remove the header from the internal buffer.
Definition: packet.cc:280
void AddHeader(const Header &header)
Add header to this packet.
Definition: packet.cc:256
uint64_t GetUid(void) const
Returns the packet's Uid.
Definition: packet.cc:390
Ptr< Packet > Copy(void) const
performs a COW copy of the packet.
Definition: packet.cc:121
uint32_t GetSize(void) const
Returns the the size in bytes of the packet (including the zero-filled initial payload).
Definition: packet.h:856
A Device for a Point to Point Network Link.
void AddHeader(Ptr< Packet > p, uint16_t protocolNumber)
Adds the necessary headers and trailers to a packet of data in order to respect the protocol implemen...
virtual bool SendFrom(Ptr< Packet > packet, const Address &source, const Address &dest, uint16_t protocolNumber)
static TypeId GetTypeId(void)
Get the TypeId.
static const uint16_t DEFAULT_MTU
Default MTU.
TracedCallback< Ptr< const Packet > > m_phyRxEndTrace
The trace source fired when a packet ends the reception process from the medium.
virtual Address GetMulticast(Ipv4Address multicastGroup) const
Make and return a MAC multicast address using the provided multicast group.
TracedCallback< Ptr< const Packet > > m_macPromiscRxTrace
The trace source fired for packets successfully received by the device immediately before being forwa...
PointToPointNetDevice()
Construct a PointToPointNetDevice.
Ptr< PointToPointChannel > m_channel
The PointToPointChannel to which this PointToPointNetDevice has been attached.
virtual bool IsBroadcast(void) const
DataRate m_bps
The data rate that the Net Device uses to simulate packet transmission timing.
bool TransmitStart(Ptr< Packet > p)
Start Sending a Packet Down the Wire.
TracedCallback< Ptr< const Packet > > m_macRxTrace
The trace source fired for packets successfully received by the device immediately before being forwa...
TracedCallback< Ptr< const Packet > > m_macRxDropTrace
The trace source fired for packets successfully received by the device but are dropped before being f...
TracedCallback m_linkChangeCallbacks
Callback for the link change event.
TracedCallback< Ptr< const Packet > > m_macTxTrace
The trace source fired when packets come into the "top" of the device at the L3/L2 transition,...
void SetQueue(Ptr< Queue< Packet > > queue)
Attach a queue to the PointToPointNetDevice.
virtual bool SupportsSendFrom(void) const
virtual bool SetMtu(const uint16_t mtu)
void NotifyLinkUp(void)
Make the link up and running.
bool Attach(Ptr< PointToPointChannel > ch)
Attach the device to a channel.
virtual void DoDispose(void)
Dispose of the object.
virtual uint32_t GetIfIndex(void) const
static uint16_t EtherToPpp(uint16_t protocol)
Ethernet to PPP protocol number mapping.
void SetReceiveErrorModel(Ptr< ErrorModel > em)
Attach a receive ErrorModel to the PointToPointNetDevice.
virtual Ptr< Channel > GetChannel(void) const
TracedCallback< Ptr< const Packet > > m_phyTxDropTrace
The trace source fired when the phy layer drops a packet before it tries to transmit it.
Ptr< ErrorModel > m_receiveErrorModel
Error model for receive packet events.
void SetInterframeGap(Time t)
Set the interframe gap used to separate packets.
virtual void SetIfIndex(const uint32_t index)
void TransmitComplete(void)
Stop Sending a Packet Down the Wire and Begin the Interframe Gap.
bool m_linkUp
Identify if the link is up or not.
TracedCallback< Ptr< const Packet > > m_phyRxDropTrace
The trace source fired when the phy layer drops a packet it has received.
Ptr< Queue< Packet > > GetQueue(void) const
Get a copy of the attached Queue.
virtual void SetPromiscReceiveCallback(PromiscReceiveCallback cb)
@ READY
The transmitter is ready to begin transmission of a packet.
@ BUSY
The transmitter is busy transmitting a packet.
static uint16_t PppToEther(uint16_t protocol)
PPP to Ethernet protocol number mapping.
virtual uint16_t GetMtu(void) const
virtual bool IsBridge(void) const
Return true if the net device is acting as a bridge.
virtual Ptr< Node > GetNode(void) const
virtual void SetReceiveCallback(NetDevice::ReceiveCallback cb)
TracedCallback< Ptr< const Packet > > m_phyTxBeginTrace
The trace source fired when a packet begins the transmission process on the medium.
virtual Address GetBroadcast(void) const
Mac48Address m_address
Mac48Address of this NetDevice.
Time m_tInterframeGap
The interframe gap that the Net Device uses to throttle packet transmission.
Ptr< Packet > m_currentPkt
Current packet processed.
bool ProcessHeader(Ptr< Packet > p, uint16_t &param)
Removes, from a packet of data, all headers and trailers that relate to the protocol implemented by t...
virtual void AddLinkChangeCallback(Callback< void > callback)
void Receive(Ptr< Packet > p)
Receive a packet from a connected PointToPointChannel.
TracedCallback< Ptr< const Packet > > m_phyRxBeginTrace
The trace source fired when a packet begins the reception process from the medium – when the simulate...
Ptr< Queue< Packet > > m_queue
The Queue which this PointToPointNetDevice uses as a packet source.
virtual void SetAddress(Address address)
Set the address of this interface.
virtual bool Send(Ptr< Packet > packet, const Address &dest, uint16_t protocolNumber)
TracedCallback< Ptr< const Packet > > m_promiscSnifferTrace
A trace source that emulates a promiscuous mode protocol sniffer connected to the device.
TracedCallback< Ptr< const Packet > > m_phyTxEndTrace
The trace source fired when a packet ends the transmission process on the medium.
virtual ~PointToPointNetDevice()
Destroy a PointToPointNetDevice.
TxMachineState m_txMachineState
The state of the Net Device transmit state machine.
virtual void SetNode(Ptr< Node > node)
void DoMpiReceive(Ptr< Packet > p)
Handler for MPI receive event.
void SetDataRate(DataRate bps)
Set the Data Rate used for transmission of packets.
virtual bool IsMulticast(void) const
virtual Address GetAddress(void) const
uint32_t m_mtu
The Maximum Transmission Unit.
Ptr< Node > m_node
Node owning this NetDevice.
TracedCallback< Ptr< const Packet > > m_snifferTrace
A trace source that emulates a non-promiscuous protocol sniffer connected to the device.
TracedCallback< Ptr< const Packet > > m_macTxDropTrace
The trace source fired when packets coming into the "top" of the device at the L3/L2 transition are d...
NetDevice::PromiscReceiveCallback m_promiscCallback
Receive callback.
NetDevice::ReceiveCallback m_rxCallback
Receive callback.
uint32_t m_ifIndex
Index of the interface.
virtual bool IsPointToPoint(void) const
Return true if the net device is on a point-to-point link.
Hold objects of type Ptr<T>.
Definition: pointer.h:37
Packet header for PPP.
Definition: ppp-header.h:49
void SetProtocol(uint16_t protocol)
Set the protocol type carried by this PPP packet.
Definition: ppp-header.cc:96
uint16_t GetProtocol(void)
Get the protocol type carried by this PPP packet.
Definition: ppp-header.cc:102
static EventId Schedule(Time const &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
Definition: simulator.h:555
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:104
@ S
second
Definition: nstime.h:115
TimeWithUnit As(const enum Unit unit=Time::AUTO) const
Attach a unit to a Time, to facilitate output in a specific unit.
Definition: time.cc:418
AttributeValue implementation for Time.
Definition: nstime.h:1309
void ConnectWithoutContext(const CallbackBase &callback)
Append a Callback to the chain (without a context).
a unique identifier for an interface.
Definition: type-id.h:59
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:922
Hold an unsigned integer type.
Definition: uinteger.h:44
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
Definition: assert.h:67
#define NS_ASSERT_MSG(condition, message)
At runtime, in debugging builds, if this condition is not true, the program prints the message to out...
Definition: assert.h:88
Ptr< const AttributeAccessor > MakePointerAccessor(T1 a1)
Definition: pointer.h:227
Ptr< const AttributeAccessor > MakeTimeAccessor(T1 a1)
Definition: nstime.h:1310
Ptr< const AttributeAccessor > MakeUintegerAccessor(T1 a1)
Definition: uinteger.h:45
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:206
#define NS_LOG_LOGIC(msg)
Use NS_LOG to output a message of level LOG_LOGIC.
Definition: log.h:290
#define NS_LOG_FUNCTION_NOARGS()
Output the name of the function.
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition: object-base.h:45
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1245
Ptr< const TraceSourceAccessor > MakeTraceSourceAccessor(T a)
Create a TraceSourceAccessor which will control access to the underlying trace source.
address
Definition: first.py:40
Every class exported by the ns3 library is enclosed in the ns3 namespace.
Ptr< const AttributeChecker > MakeTimeChecker(const Time min, const Time max)
Helper to make a Time checker with bounded range.
Definition: time.cc:522