diff --git a/CHANGES.html b/CHANGES.html
index 45a8eb368be..e8cce28db06 100644
--- a/CHANGES.html
+++ b/CHANGES.html
@@ -54,6 +54,27 @@
Changes from ns-3.25 to ns-3.26
New API:
+- A SocketPriorityTag is introduced to carry the packet priority. Such a tag
+ is added to packets by sockets that support this mechanism (UdpSocketImpl,
+ TcpSocketBase and PacketSocket). The base class Socket has a new SetPriority
+ method to set the socket priority. When the IPv4 protocol is used, the
+ priority is set based on the ToS. See the Socket options section of the
+ Network model for more information.
+
+- A WifiNetDevice::SelectQueue method has been added to determine the user
+ priority of an MSDU. This method is called by the traffic control layer before
+ enqueuing a packet in the queue disc, if a queue disc is installed on
+ the outgoing device, or passing a packet to the device, otherwise. The
+ user priority is set to the three most significant bits of the DS field
+ (TOS field in case of IPv4 and Traffic Class field in case of IPv6). The
+ packet priority carried by the SocketPriorityTag is set to the user priority.
+
+- The PfifoFastQueueDisc classifies packets into bands based on their priority.
+ See the pfifo_fast queue disc section of the Traffic Control Layer model
+ for more information.
+
+- A new class SpectrumWifiPhy has been introduced that makes use of the Spectrum module. Its functionality and API is currently very similar to that of the YansWifiPhy, especially because it reuses the same InterferenceHelper and ErrorModel classes (for this release). Some example programs in the 'examples/wireless/' directory, such as 'wifi-spectrum-per-example.cc', illustrate how the SpectrumWifiPhy class can be substituted for the default YansWifiPhy PHY model.
+
Changes to existing API:
@@ -66,6 +87,18 @@ Changes to existing API:
As a consequence, SocketAddressTag has been completely removed from ns-3.
Users can use RecvFrom (for UDP), GetPeerName (for TCP), or similar.
+- InetSockAddress can now store a ToS value, which can be set through its
+ SetTos method. The Bind and Connect methods of UDP (UdpSocketImpl) and
+ TCP (TcpSocketBase) sockets set the socket ToS value to the value provided
+ through the address input parameter (of type InetSockAddress). See the
+ Socket options section of the Network model for more information.
+
+- The QosTag is removed as it has been superseded by the SocketPriorityTag.
+- The Ipv4L3Protocol::DefaultTos attribute is removed.
+- The attributes YansWifiPhy::Frequency, YansWifiPhy::ChannelNumber, and YansWifiPhy::ChannelWidth, and the related accessor methods, were moved to base class WifiPhy. YansWifiPhy::GetChannelFrequencyMhz() was deleted. A new method WifiPhy::DefineChannelNumber () was added to allow users to define relationships between channel number, standard, frequency, and channel width.
+
+- The class WifiSpectrumValueHelper has been refactored; previously it was an abstract base class supporting the WifiSpectrumValue5MhzFactory spectrum model. It now contains various static member methods supporting the creation of power spectral densities with the granularity of a Wi-Fi OFDM subcarrier bandwidth. The class WifiSpectrumValue5MhzFactory and its API remain but it is not subclassed.
+- A new method InterferenceHelper::AddForeignSignal has been introduced to support use of the SpectrumWifiPhy (so that non-Wi-Fi signals may be handled as noise power).
Changes to build system:
@@ -73,6 +106,7 @@ Changes to build system:
Changed behavior:
This section is for behavioral changes to the models that were not due to a bug fix.
+ - (wifi) The relationship between channel number, frequency, channel width, and Wi-Fi standard has been revised (see bug 2412). Previously, ChannelNumber and Frequency were attributes of class YansWifiPhy, and the frequency was defined as the start of the band. Now, Frequency has been redefined to be the center frequency of the channel, and the underlying device relies on the pair of frequency and channel width to control behavior; the channel number and Wi-Fi standard are used as attributes to configure frequency and channel width. The wifi module documentation discusses this change and the new behavior.
diff --git a/RELEASE_NOTES b/RELEASE_NOTES
index 6e4ba4cf12d..5dfddd0d921 100644
--- a/RELEASE_NOTES
+++ b/RELEASE_NOTES
@@ -36,6 +36,11 @@ New user-visible features
- (internet) Added TCP YeAH congestion control algorithm
- (network) SocketAddressTag has been removed from the codebase.
Users can use RecvFrom (for UDP) or GetPeerName (for TCP) instead.
+- (wifi) A new SpectrumWifiPhy physical layer model, making use of the
+ ns-3 spectrum framework, has been introduced. The current version of
+ this model matches the API and behavior of YansWifiPhy closely, but
+ over time is expected to support a different PHY abstraction and error
+ models.
Bugs fixed
----------
@@ -65,6 +70,7 @@ Bugs fixed
- Bug 2402 - IPv4 Interface forwarding state is not honored
- Bug 2406 - Poor 802.11g performance in ad-hoc mode
- Bug 2408 - Simulation fails when 802.11n/ac is running with HT Minstrel and pcap enabled
+- Bug 2412 - align WifiPhy frequency and channel number
- Bug 2414 - UdpSocket doesn't call NotifyConnectionFailed
- Bug 2419 - BsmApplication should use RecvFrom and not SocketAddressTag
- Bug 2420 - Remove code duplication between Wifi and Wave modules
diff --git a/doc/models/Makefile b/doc/models/Makefile
index ac3b2f385a8..2d29f02cd2d 100644
--- a/doc/models/Makefile
+++ b/doc/models/Makefile
@@ -57,6 +57,7 @@ SOURCES = \
$(SRC)/network/doc/sockets-api.rst \
$(SRC)/network/doc/simple.rst \
$(SRC)/network/doc/queue.rst \
+ $(SRC)/network/doc/queue-limits.rst \
$(SRC)/internet/doc/internet-stack.rst \
$(SRC)/internet/doc/ipv4.rst \
$(SRC)/internet/doc/ipv6.rst \
diff --git a/doc/models/source/network.rst b/doc/models/source/network.rst
index bb67a7c36e1..cb3b8b5d063 100644
--- a/doc/models/source/network.rst
+++ b/doc/models/source/network.rst
@@ -9,3 +9,4 @@ Network Module
sockets-api
simple
queue
+ queue-limits
diff --git a/examples/traffic-control/benchmark-queue-discs.cc b/examples/traffic-control/benchmark-queue-discs.cc
new file mode 100644
index 00000000000..8a2af914265
--- /dev/null
+++ b/examples/traffic-control/benchmark-queue-discs.cc
@@ -0,0 +1,294 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2015 Universita' degli Studi di Napoli Federico II
+ *
+ * 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
+ *
+ * Authors: Pasquale Imputato
+ * Stefano Avallone
+ */
+
+// This example serves as benchmark test for all the queue discs (with BQL enabled or not)
+//
+// Network topology
+//
+// 192.168.1.0 192.168.2.0
+// n1 ------------------------------------ n2 ----------------------------------- n3
+// point-to-point (access link) point-to-point (bottleneck link)
+// 100 Mbps, 0.1 ms bandwidth [10 Mbps], delay [5 ms]
+// qdiscs PfifoFast with capacity qdiscs queueDiscType in {PfifoFast, ARED, CoDel} [PfifoFast]
+// of 1000 packets with capacity of queueDiscSize packets [1000]
+// netdevices queues with size of 100 packets netdevices queues with size of netdevicesQueueSize packets [100]
+// without BQL bql BQL [false]
+// *** fixed configuration ***
+//
+// The output will consist of a number of ping Rtt such as:
+//
+// /NodeList/0/ApplicationList/2/$ns3::V4Ping/Rtt=111 ms
+// /NodeList/0/ApplicationList/2/$ns3::V4Ping/Rtt=111 ms
+// /NodeList/0/ApplicationList/2/$ns3::V4Ping/Rtt=110 ms
+// /NodeList/0/ApplicationList/2/$ns3::V4Ping/Rtt=111 ms
+// /NodeList/0/ApplicationList/2/$ns3::V4Ping/Rtt=111 ms
+// /NodeList/0/ApplicationList/2/$ns3::V4Ping/Rtt=112 ms
+// /NodeList/0/ApplicationList/2/$ns3::V4Ping/Rtt=111 ms
+//
+// The files output will consist of a trace file with bytes in queue and of a trace file for limits
+// (when BQL is enabled) both for bottleneck NetDevice on n2, two files with upload and download
+// goodput for flows configuration and a file with flow monitor stats.
+//
+// If you use an AQM as queue disc on the bottleneck netdevices, you can observe that the ping Rtt
+// decrease. A further decrease can be observed when you enable BQL.
+
+#include "ns3/core-module.h"
+#include "ns3/network-module.h"
+#include "ns3/internet-module.h"
+#include "ns3/point-to-point-module.h"
+#include "ns3/applications-module.h"
+#include "ns3/internet-apps-module.h"
+#include "ns3/traffic-control-module.h"
+#include "ns3/flow-monitor-module.h"
+
+using namespace ns3;
+
+NS_LOG_COMPONENT_DEFINE ("BenchmarkQueueDiscs");
+
+void
+LimitsTrace (Ptr stream, uint32_t oldVal, uint32_t newVal)
+{
+ *stream->GetStream () << Simulator::Now ().GetSeconds () << " " << newVal << std::endl;
+}
+
+void
+BytesInQueueTrace (Ptr stream, uint32_t oldVal, uint32_t newVal)
+{
+ *stream->GetStream () << Simulator::Now ().GetSeconds () << " " << newVal << std::endl;
+}
+
+static void
+GoodputSampling (std::string fileName, ApplicationContainer app, Ptr stream, float period)
+{
+ Simulator::Schedule (Seconds (period), &GoodputSampling, fileName, app, stream, period);
+ double goodput;
+ uint32_t totalPackets = DynamicCast (app.Get (0))->GetTotalRx ();
+ goodput = totalPackets * 8 / (Simulator::Now ().GetSeconds () * 1024); // Kbit/s
+ *stream->GetStream () << Simulator::Now ().GetSeconds () << " " << goodput << std::endl;
+}
+
+static void PingRtt (std::string context, Time rtt)
+{
+ std::cout << context << "=" << rtt.GetMilliSeconds () << " ms" << std::endl;
+}
+
+int main (int argc, char *argv[])
+{
+ std::string bandwidth = "10Mbps";
+ std::string delay = "5ms";
+ std::string queueDiscType = "PfifoFast";
+ uint32_t queueDiscSize = 1000;
+ uint32_t netdevicesQueueSize = 100;
+ bool bql = false;
+
+ std::string flowsDatarate = "20Mbps";
+ uint32_t flowsPacketsSize = 1000;
+
+ float startTime = 0.1; // in s
+ float simDuration = 60;
+ float samplingPeriod = 1;
+
+ CommandLine cmd;
+ cmd.AddValue ("bandwidth", "Bottleneck bandwidth", bandwidth);
+ cmd.AddValue ("delay", "Bottleneck delay", delay);
+ cmd.AddValue ("queueDiscType", "Bottleneck queue disc type in {PfifoFast, ARED, CoDel}", queueDiscType);
+ cmd.AddValue ("queueDiscSize", "Bottleneck queue disc size in packets", queueDiscSize);
+ cmd.AddValue ("netdevicesQueueSize", "Bottleneck netdevices queue size in packets", netdevicesQueueSize);
+ cmd.AddValue ("bql", "Enable byte queue limits on bottleneck netdevices", bql);
+ cmd.AddValue ("flowsDatarate", "Upload and download flows datarate", flowsDatarate);
+ cmd.AddValue ("flowsPacketsSize", "Upload and download flows packets sizes", flowsPacketsSize);
+ cmd.AddValue ("startTime", "Simulation start time", startTime);
+ cmd.AddValue ("simDuration", "Simulation duration in seconds", simDuration);
+ cmd.AddValue ("samplingPeriod", "Goodput sampling period in seconds", samplingPeriod);
+ cmd.Parse (argc, argv);
+
+ float stopTime = startTime + simDuration;
+
+ // Create nodes
+ NodeContainer n1, n2, n3;
+ n1.Create (1);
+ n2.Create (1);
+ n3.Create (1);
+
+ // Create and configure access link and bottleneck link
+ PointToPointHelper accessLink;
+ accessLink.SetDeviceAttribute ("DataRate", StringValue ("100Mbps"));
+ accessLink.SetChannelAttribute ("Delay", StringValue ("0.1ms"));
+
+ PointToPointHelper bottleneckLink;
+ bottleneckLink.SetDeviceAttribute ("DataRate", StringValue (bandwidth));
+ bottleneckLink.SetChannelAttribute ("Delay", StringValue (delay));
+
+ InternetStackHelper stack;
+ stack.InstallAll ();
+
+ // Access link traffic control configuration
+ TrafficControlHelper tchPfifoFastAccess;
+ uint32_t handle = tchPfifoFastAccess.SetRootQueueDisc ("ns3::PfifoFastQueueDisc", "Limit", UintegerValue (1000));
+
+ // Bottleneck link traffic control configuration
+ TrafficControlHelper tchPfifoFastBottleneck;
+ handle = tchPfifoFastBottleneck.SetRootQueueDisc ("ns3::PfifoFastQueueDisc", "Limit", UintegerValue (queueDiscSize));
+
+ TrafficControlHelper tchRed;
+ handle = tchRed.SetRootQueueDisc ("ns3::RedQueueDisc");
+ Config::SetDefault ("ns3::RedQueueDisc::ARED", BooleanValue (true));
+ tchRed.AddInternalQueues (handle, 1, "ns3::DropTailQueue", "MaxPackets", UintegerValue (queueDiscSize));
+
+ TrafficControlHelper tchCoDel;
+ handle = tchCoDel.SetRootQueueDisc ("ns3::CoDelQueueDisc");
+ Config::SetDefault ("ns3::CoDelQueueDisc::Mode", EnumValue (Queue::QUEUE_MODE_PACKETS));
+ tchCoDel.AddInternalQueues (handle, 1, "ns3::DropTailQueue", "MaxPackets", UintegerValue (queueDiscSize));
+
+ if (bql)
+ {
+ tchPfifoFastBottleneck.SetQueueLimits ("ns3::DynamicQueueLimits");
+ tchRed.SetQueueLimits ("ns3::DynamicQueueLimits");
+ tchCoDel.SetQueueLimits ("ns3::DynamicQueueLimits");
+ }
+
+ Config::SetDefault ("ns3::Queue::Mode", StringValue ("QUEUE_MODE_PACKETS"));
+ Config::SetDefault ("ns3::Queue::MaxPackets", UintegerValue (100));
+
+ NetDeviceContainer devicesAccessLink = accessLink.Install (n1.Get (0), n2.Get (0));
+ tchPfifoFastAccess.Install (devicesAccessLink);
+ Ipv4AddressHelper address;
+ address.SetBase ("192.168.0.0", "255.255.255.0");
+ address.NewNetwork ();
+ Ipv4InterfaceContainer interfacesAccess = address.Assign (devicesAccessLink);
+
+ Config::SetDefault ("ns3::Queue::MaxPackets", UintegerValue (netdevicesQueueSize));
+
+ NetDeviceContainer devicesBottleneckLink = bottleneckLink.Install (n2.Get (0), n3.Get (0));
+ QueueDiscContainer qdiscs;
+ if (queueDiscType.compare ("PfifoFast") == 0)
+ {
+ qdiscs = tchPfifoFastBottleneck.Install (devicesBottleneckLink);
+ }
+ else if (queueDiscType.compare ("ARED") == 0)
+ {
+ qdiscs = tchRed.Install (devicesBottleneckLink);
+ }
+ else if (queueDiscType.compare ("CoDel") == 0)
+ {
+ qdiscs = tchCoDel.Install (devicesBottleneckLink);
+ }
+ else
+ {
+ NS_ABORT_MSG ("--queueDiscType not valid");
+ }
+ address.NewNetwork ();
+ Ipv4InterfaceContainer interfacesBottleneck = address.Assign (devicesBottleneckLink);
+
+ Ptr interface = devicesBottleneckLink.Get (0)->GetObject ();
+ Ptr queueInterface = interface->GetTxQueue (0);
+ Ptr queueLimits = StaticCast (queueInterface->GetQueueLimits ());
+
+ AsciiTraceHelper ascii;
+ if (bql)
+ {
+ queueDiscType = queueDiscType + "-bql";
+ Ptr streamLimits = ascii.CreateFileStream (queueDiscType + "-limits.txt");
+ queueLimits->TraceConnectWithoutContext ("Limit",MakeBoundCallback (&LimitsTrace, streamLimits));
+ }
+ Ptr queue = StaticCast (devicesBottleneckLink.Get (0))->GetQueue ();
+ Ptr streamBytesInQueue = ascii.CreateFileStream (queueDiscType + "-bytesInQueue.txt");
+ queue->TraceConnectWithoutContext ("BytesInQueue",MakeBoundCallback (&BytesInQueueTrace, streamBytesInQueue));
+
+ Ipv4InterfaceContainer n1Interface;
+ n1Interface.Add (interfacesAccess.Get (0));
+
+ Ipv4InterfaceContainer n3Interface;
+ n3Interface.Add (interfacesBottleneck.Get (1));
+
+ Ipv4GlobalRoutingHelper::PopulateRoutingTables ();
+
+ Config::SetDefault ("ns3::TcpSocket::SegmentSize", UintegerValue (flowsPacketsSize));
+
+ // Flows configuration
+ // Bidirectional TCP streams with ping like flent tcp_bidirectional test.
+ uint16_t port = 7;
+ ApplicationContainer uploadApp, downloadApp, sourceApps;
+ // Configure and install upload flow
+ Address addUp (InetSocketAddress (Ipv4Address::GetAny (), port));
+ PacketSinkHelper sinkHelperUp ("ns3::TcpSocketFactory", addUp);
+ sinkHelperUp.SetAttribute ("Protocol", TypeIdValue (TcpSocketFactory::GetTypeId ()));
+ uploadApp.Add (sinkHelperUp.Install (n3));
+
+ InetSocketAddress socketAddressUp = InetSocketAddress (n3Interface.GetAddress (0), port);
+ OnOffHelper onOffHelperUp ("ns3::TcpSocketFactory", Address ());
+ onOffHelperUp.SetAttribute ("Remote", AddressValue (socketAddressUp));
+ onOffHelperUp.SetAttribute ("OnTime", StringValue ("ns3::ConstantRandomVariable[Constant=1]"));
+ onOffHelperUp.SetAttribute ("OffTime", StringValue ("ns3::ConstantRandomVariable[Constant=0]"));
+ onOffHelperUp.SetAttribute ("PacketSize", UintegerValue (flowsPacketsSize));
+ onOffHelperUp.SetAttribute ("DataRate", StringValue (flowsDatarate));
+ sourceApps.Add (onOffHelperUp.Install (n1));
+
+ port = 8;
+ // Configure and install download flow
+ Address addDown (InetSocketAddress (Ipv4Address::GetAny (), port));
+ PacketSinkHelper sinkHelperDown ("ns3::TcpSocketFactory", addDown);
+ sinkHelperDown.SetAttribute ("Protocol", TypeIdValue (TcpSocketFactory::GetTypeId ()));
+ downloadApp.Add (sinkHelperDown.Install (n1));
+
+ InetSocketAddress socketAddressDown = InetSocketAddress (n1Interface.GetAddress (0), port);
+ OnOffHelper onOffHelperDown ("ns3::TcpSocketFactory", Address ());
+ onOffHelperDown.SetAttribute ("Remote", AddressValue (socketAddressDown));
+ onOffHelperDown.SetAttribute ("OnTime", StringValue ("ns3::ConstantRandomVariable[Constant=1]"));
+ onOffHelperDown.SetAttribute ("OffTime", StringValue ("ns3::ConstantRandomVariable[Constant=0]"));
+ onOffHelperDown.SetAttribute ("PacketSize", UintegerValue (flowsPacketsSize));
+ onOffHelperDown.SetAttribute ("DataRate", StringValue (flowsDatarate));
+ sourceApps.Add (onOffHelperDown.Install (n3));
+
+ // Configure and install ping
+ V4PingHelper ping = V4PingHelper (n3Interface.GetAddress (0));
+ ping.Install (n1);
+
+ Config::Connect ("/NodeList/*/ApplicationList/*/$ns3::V4Ping/Rtt", MakeCallback (&PingRtt));
+
+ uploadApp.Start (Seconds (0));
+ uploadApp.Stop (Seconds (stopTime));
+ downloadApp.Start (Seconds (0));
+ downloadApp.Stop (Seconds (stopTime));
+
+ sourceApps.Start (Seconds (0 + 0.1));
+ sourceApps.Stop (Seconds (stopTime - 0.1));
+
+ Ptr uploadGoodputStream = ascii.CreateFileStream (queueDiscType + "-upGoodput.txt");
+ Simulator::Schedule (Seconds (samplingPeriod), &GoodputSampling, queueDiscType + "-upGoodput.txt", uploadApp,
+ uploadGoodputStream, samplingPeriod);
+ Ptr downloadGoodputStream = ascii.CreateFileStream (queueDiscType + "-downGoodput.txt");
+ Simulator::Schedule (Seconds (samplingPeriod), &GoodputSampling, queueDiscType + "-downGoodput.txt", downloadApp,
+ downloadGoodputStream, samplingPeriod);
+
+ // Flow monitor
+ Ptr flowMonitor;
+ FlowMonitorHelper flowHelper;
+ flowMonitor = flowHelper.InstallAll();
+
+ Simulator::Stop (Seconds (stopTime));
+ Simulator::Run ();
+
+ flowMonitor->SerializeToXmlFile(queueDiscType + "-flowMonitor.xml", true, true);
+
+ Simulator::Destroy ();
+ return 0;
+}
diff --git a/examples/traffic-control/wscript b/examples/traffic-control/wscript
index 3955647f65c..8c4692e47f1 100644
--- a/examples/traffic-control/wscript
+++ b/examples/traffic-control/wscript
@@ -4,3 +4,7 @@ def build(bld):
obj = bld.create_ns3_program('traffic-control',
['internet', 'point-to-point', 'applications', 'traffic-control'])
obj.source = 'traffic-control.cc'
+
+ obj = bld.create_ns3_program('benchmark-queue-discs',
+ ['internet', 'point-to-point', 'applications', 'internet-apps', 'traffic-control', 'flow-monitor'])
+ obj.source = 'benchmark-queue-discs.cc'
diff --git a/examples/wireless/examples-to-run.py b/examples/wireless/examples-to-run.py
index 859d5567b54..e1c1df78622 100755
--- a/examples/wireless/examples-to-run.py
+++ b/examples/wireless/examples-to-run.py
@@ -32,6 +32,10 @@
("ofdm-vht-validation", "True", "True"),
("mixed-bg-network", "True", "True"),
("wifi-tcp", "True", "True"),
+ ("wifi-spectrum-per-example --distance=52 --index=3 --wifiType=ns3::SpectrumWifiPhy --simulationTime=1", "True", "True"),
+ ("wifi-spectrum-per-example --distance=24 --index=31 --wifiType=ns3::YansWifiPhy --simulationTime=1", "True", "True"),
+ ("wifi-spectrum-per-interference --distance=24 --index=31 --simulationTime=1 --waveformPower=0.1", "True", "True"),
+ ("wifi-spectrum-saturation-example --simulationTime=1 --index=63", "True", "True"),
]
# A list of Python examples to run in order to ensure that they remain
diff --git a/examples/wireless/wifi-spectrum-per-example.cc b/examples/wireless/wifi-spectrum-per-example.cc
new file mode 100644
index 00000000000..cbbf0b9ea63
--- /dev/null
+++ b/examples/wireless/wifi-spectrum-per-example.cc
@@ -0,0 +1,565 @@
+/* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2009 MIRKO BANCHI
+ * Copyright (c) 2015 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
+ *
+ * Authors: Mirko Banchi
+ * Sebastien Deronne
+ * Tom Henderson
+ *
+ * Adapted from ht-wifi-network.cc example
+ */
+#include
+#include
+
+#include "ns3/core-module.h"
+#include "ns3/config-store-module.h"
+#include "ns3/network-module.h"
+#include "ns3/applications-module.h"
+#include "ns3/wifi-module.h"
+#include "ns3/mobility-module.h"
+#include "ns3/spectrum-module.h"
+#include "ns3/internet-module.h"
+
+// This is a simple example of an IEEE 802.11n Wi-Fi network.
+//
+// The main use case is to enable and test SpectrumWifiPhy vs YansWifiPhy
+// for packet error ratio
+//
+// Network topology:
+//
+// Wi-Fi 192.168.1.0
+//
+// STA AP
+// * <-- distance --> *
+// | |
+// n1 n2
+//
+// Users may vary the following command-line arguments in addition to the
+// attributes, global values, and default values typically available:
+//
+// --simulationTime: Simulation time in seconds [10]
+// --udp: UDP if set to 1, TCP otherwise [true]
+// --distance: meters separation between nodes [50]
+// --index: restrict index to single value between 0 and 31 [256]
+// --wifiType: select ns3::SpectrumWifiPhy or ns3::YansWifiPhy [ns3::SpectrumWifiPhy]
+// --errorModelType: select ns3::NistErrorRateModel or ns3::YansErrorRateModel [ns3::NistErrorRateModel]
+// --enablePcap: enable pcap output [false]
+//
+// By default, the program will step through 32 index values, corresponding
+// to the following MCS, channel width, and guard interval combinations:
+// index 0-7: MCS 0-7, long guard interval, 20 MHz channel
+// index 8-15: MCS 0-7, short guard interval, 20 MHz channel
+// index 16-23: MCS 0-7, long guard interval, 40 MHz channel
+// index 24-31: MCS 0-7, short guard interval, 40 MHz channel
+// and send 1000 UDP packets using each MCS, using the SpectrumWifiPhy and the
+// NistErrorRateModel, at a distance of 50 meters. The program outputs
+// results such as:
+//
+// wifiType: ns3::SpectrumWifiPhy distance: 50m; sent: 1000
+// index MCS Rate (Mb/s) Tput (Mb/s) Received Signal (dBm) Noise (dBm) SNR (dB)
+// 0 0 6.5 0.7776 1000 -77.6633 -100.966 23.3027
+// 1 1 13 0.7776 1000 -77.6633 -100.966 23.3027
+// 2 2 19.5 0.7776 1000 -77.6633 -100.966 23.3027
+// 3 3 26 0.7776 1000 -77.6633 -100.966 23.3027
+// ...
+//
+// When UDP is used, the throughput will always be 0.7776 Mb/s since the
+// traffic generator does not attempt to match the maximum Phy data rate
+// but instead sends at a constant rate. When TCP is used, the TCP flow
+// will exhibit different throughput depending on the index.
+
+using namespace ns3;
+
+// Global variables for use in callbacks.
+double g_signalDbmAvg;
+double g_noiseDbmAvg;
+uint32_t g_samples;
+uint16_t g_channelNumber;
+uint32_t g_rate;
+
+void MonitorSniffRx (Ptr packet, uint16_t channelFreqMhz,
+ uint16_t channelNumber, uint32_t rate,
+ WifiPreamble preamble, WifiTxVector txVector,
+ struct mpduInfo aMpdu, struct signalNoiseDbm signalNoise)
+
+{
+ g_samples++;
+ g_signalDbmAvg += ((signalNoise.signal - g_signalDbmAvg) / g_samples);
+ g_noiseDbmAvg += ((signalNoise.noise - g_noiseDbmAvg) / g_samples);
+ g_rate = rate;
+ g_channelNumber = channelNumber;
+}
+
+NS_LOG_COMPONENT_DEFINE ("WifiSpectrumPerExample");
+
+int main (int argc, char *argv[])
+{
+ bool udp = true;
+ double distance = 50;
+ double simulationTime = 10; //seconds
+ uint16_t index = 256;
+ std::string wifiType = "ns3::SpectrumWifiPhy";
+ std::string errorModelType = "ns3::NistErrorRateModel";
+ bool enablePcap = false;
+ const uint32_t tcpPacketSize = 1448;
+
+ CommandLine cmd;
+ cmd.AddValue ("simulationTime", "Simulation time in seconds", simulationTime);
+ cmd.AddValue ("udp", "UDP if set to 1, TCP otherwise", udp);
+ cmd.AddValue ("distance", "meters separation between nodes", distance);
+ cmd.AddValue ("index", "restrict index to single value between 0 and 31", index);
+ cmd.AddValue ("wifiType", "select ns3::SpectrumWifiPhy or ns3::YansWifiPhy", wifiType);
+ cmd.AddValue ("errorModelType", "select ns3::NistErrorRateModel or ns3::YansErrorRateModel", errorModelType);
+ cmd.AddValue ("enablePcap", "enable pcap output", enablePcap);
+ cmd.Parse (argc,argv);
+
+ uint16_t startIndex = 0;
+ uint16_t stopIndex = 31;
+ if (index < 32)
+ {
+ startIndex = index;
+ stopIndex = index;
+ }
+
+ std::cout << "wifiType: " << wifiType << " distance: " << distance << "m; sent: 1000 TxPower: 1 dBm (1.3 mW)" << std::endl;
+ std::cout << std::setw (5) << "index" <<
+ std::setw (6) << "MCS" <<
+ std::setw (12) << "Rate (Mb/s)" <<
+ std::setw (12) << "Tput (Mb/s)" <<
+ std::setw (10) << "Received " <<
+ std::setw (12) << "Signal (dBm)" <<
+ std::setw (12) << "Noise (dBm)" <<
+ std::setw (10) << "SNR (dB)" <<
+ std::endl;
+ for (uint16_t i = startIndex; i <= stopIndex; i++)
+ {
+ uint32_t payloadSize;
+ if (udp)
+ {
+ payloadSize = 972; // 1000 bytes IPv4
+ }
+ else
+ {
+ payloadSize = 1448; // 1500 bytes IPv6
+ Config::SetDefault ("ns3::TcpSocket::SegmentSize", UintegerValue (payloadSize));
+ }
+
+ NodeContainer wifiStaNode;
+ wifiStaNode.Create (1);
+ NodeContainer wifiApNode;
+ wifiApNode.Create (1);
+
+ YansWifiPhyHelper phy = YansWifiPhyHelper::Default ();
+ SpectrumWifiPhyHelper spectrumPhy = SpectrumWifiPhyHelper::Default ();
+ if (wifiType == "ns3::YansWifiPhy")
+ {
+ YansWifiChannelHelper channel;
+ channel.AddPropagationLoss ("ns3::FriisPropagationLossModel");
+ channel.SetPropagationDelay ("ns3::ConstantSpeedPropagationDelayModel");
+ phy.SetChannel (channel.Create ());
+ phy.Set ("TxPowerStart", DoubleValue (1)); // dBm (1.26 mW)
+ phy.Set ("TxPowerEnd", DoubleValue (1));
+
+ if (i <= 7)
+ {
+ phy.Set ("ShortGuardEnabled", BooleanValue (false));
+ phy.Set ("ChannelWidth", UintegerValue (20));
+ }
+ else if (i > 7 && i <= 15)
+ {
+ phy.Set ("ShortGuardEnabled", BooleanValue (true));
+ phy.Set ("ChannelWidth", UintegerValue (20));
+ }
+ else if (i > 15 && i <= 23)
+ {
+ phy.Set ("ShortGuardEnabled", BooleanValue (false));
+ phy.Set ("ChannelWidth", UintegerValue (40));
+ }
+ else
+ {
+ phy.Set ("ShortGuardEnabled", BooleanValue (true));
+ phy.Set ("ChannelWidth", UintegerValue (40));
+ }
+ }
+ else if (wifiType == "ns3::SpectrumWifiPhy")
+ {
+ Ptr spectrumChannel
+ = CreateObject ();
+ Ptr lossModel
+ = CreateObject ();
+ spectrumChannel->AddPropagationLossModel (lossModel);
+
+ Ptr delayModel
+ = CreateObject ();
+ spectrumChannel->SetPropagationDelayModel (delayModel);
+
+ spectrumPhy.SetChannel (spectrumChannel);
+ spectrumPhy.SetErrorRateModel (errorModelType);
+ spectrumPhy.Set ("Frequency", UintegerValue (5180));
+ spectrumPhy.Set ("TxPowerStart", DoubleValue (1)); // dBm (1.26 mW)
+ spectrumPhy.Set ("TxPowerEnd", DoubleValue (1));
+
+ if (i <= 7)
+ {
+ spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (false));
+ spectrumPhy.Set ("ChannelWidth", UintegerValue (20));
+ }
+ else if (i > 7 && i <= 15)
+ {
+ spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (true));
+ spectrumPhy.Set ("ChannelWidth", UintegerValue (20));
+ }
+ else if (i > 15 && i <= 23)
+ {
+ spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (false));
+ spectrumPhy.Set ("ChannelWidth", UintegerValue (40));
+ }
+ else
+ {
+ spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (true));
+ spectrumPhy.Set ("ChannelWidth", UintegerValue (40));
+ }
+ }
+ else
+ {
+ NS_FATAL_ERROR ("Unsupported WiFi type " << wifiType);
+ }
+
+
+ WifiHelper wifi;
+ wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);
+ WifiMacHelper mac;
+
+ Ssid ssid = Ssid ("ns380211n");
+
+ double datarate = 0;
+ StringValue DataRate;
+ if (i == 0)
+ {
+ DataRate = StringValue ("HtMcs0");
+ datarate = 6.5;
+ }
+ else if (i == 1)
+ {
+ DataRate = StringValue ("HtMcs1");
+ datarate = 13;
+ }
+ else if (i == 2)
+ {
+ DataRate = StringValue ("HtMcs2");
+ datarate = 19.5;
+ }
+ else if (i == 3)
+ {
+ DataRate = StringValue ("HtMcs3");
+ datarate = 26;
+ }
+ else if (i == 4)
+ {
+ DataRate = StringValue ("HtMcs4");
+ datarate = 39;
+ }
+ else if (i == 5)
+ {
+ DataRate = StringValue ("HtMcs5");
+ datarate = 52;
+ }
+ else if (i == 6)
+ {
+ DataRate = StringValue ("HtMcs6");
+ datarate = 58.5;
+ }
+ else if (i == 7)
+ {
+ DataRate = StringValue ("HtMcs7");
+ datarate = 65;
+ }
+ else if (i == 8)
+ {
+ DataRate = StringValue ("HtMcs0");
+ datarate = 7.2;
+ }
+ else if (i == 9)
+ {
+ DataRate = StringValue ("HtMcs1");
+ datarate = 14.4;
+ }
+ else if (i == 10)
+ {
+ DataRate = StringValue ("HtMcs2");
+ datarate = 21.7;
+ }
+ else if (i == 11)
+ {
+ DataRate = StringValue ("HtMcs3");
+ datarate = 28.9;
+ }
+ else if (i == 12)
+ {
+ DataRate = StringValue ("HtMcs4");
+ datarate = 43.3;
+ }
+ else if (i == 13)
+ {
+ DataRate = StringValue ("HtMcs5");
+ datarate = 57.8;
+ }
+ else if (i == 14)
+ {
+ DataRate = StringValue ("HtMcs6");
+ datarate = 65;
+ }
+ else if (i == 15)
+ {
+ DataRate = StringValue ("HtMcs7");
+ datarate = 72.2;
+ }
+ else if (i == 16)
+ {
+ DataRate = StringValue ("HtMcs0");
+ datarate = 13.5;
+ }
+ else if (i == 17)
+ {
+ DataRate = StringValue ("HtMcs1");
+ datarate = 27;
+ }
+ else if (i == 18)
+ {
+ DataRate = StringValue ("HtMcs2");
+ datarate = 40.5;
+ }
+ else if (i == 19)
+ {
+ DataRate = StringValue ("HtMcs3");
+ datarate = 54;
+ }
+ else if (i == 20)
+ {
+ DataRate = StringValue ("HtMcs4");
+ datarate = 81;
+ }
+ else if (i == 21)
+ {
+ DataRate = StringValue ("HtMcs5");
+ datarate = 108;
+ }
+ else if (i == 22)
+ {
+ DataRate = StringValue ("HtMcs6");
+ datarate = 121.5;
+ }
+ else if (i == 23)
+ {
+ DataRate = StringValue ("HtMcs7");
+ datarate = 135;
+ }
+ else if (i == 24)
+ {
+ DataRate = StringValue ("HtMcs0");
+ datarate = 15;
+ }
+ else if (i == 25)
+ {
+ DataRate = StringValue ("HtMcs1");
+ datarate = 30;
+ }
+ else if (i == 26)
+ {
+ DataRate = StringValue ("HtMcs2");
+ datarate = 45;
+ }
+ else if (i == 27)
+ {
+ DataRate = StringValue ("HtMcs3");
+ datarate = 60;
+ }
+ else if (i == 28)
+ {
+ DataRate = StringValue ("HtMcs4");
+ datarate = 90;
+ }
+ else if (i == 29)
+ {
+ DataRate = StringValue ("HtMcs5");
+ datarate = 120;
+ }
+ else if (i == 30)
+ {
+ DataRate = StringValue ("HtMcs6");
+ datarate = 135;
+ }
+ else
+ {
+ DataRate = StringValue ("HtMcs7");
+ datarate = 150;
+ }
+
+ wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager","DataMode", DataRate,
+ "ControlMode", DataRate);
+
+ NetDeviceContainer staDevice;
+ NetDeviceContainer apDevice;
+
+ if (wifiType == "ns3::YansWifiPhy")
+ {
+ mac.SetType ("ns3::StaWifiMac",
+ "Ssid", SsidValue (ssid),
+ "ActiveProbing", BooleanValue (false));
+ staDevice = wifi.Install (phy, mac, wifiStaNode);
+ mac.SetType ("ns3::ApWifiMac",
+ "Ssid", SsidValue (ssid));
+ apDevice = wifi.Install (phy, mac, wifiApNode);
+
+ }
+ else if (wifiType == "ns3::SpectrumWifiPhy")
+ {
+ mac.SetType ("ns3::StaWifiMac",
+ "Ssid", SsidValue (ssid),
+ "ActiveProbing", BooleanValue (false));
+ staDevice = wifi.Install (spectrumPhy, mac, wifiStaNode);
+ mac.SetType ("ns3::ApWifiMac",
+ "Ssid", SsidValue (ssid));
+ apDevice = wifi.Install (spectrumPhy, mac, wifiApNode);
+ }
+
+ // mobility.
+ MobilityHelper mobility;
+ Ptr positionAlloc = CreateObject ();
+
+ positionAlloc->Add (Vector (0.0, 0.0, 0.0));
+ positionAlloc->Add (Vector (distance, 0.0, 0.0));
+ mobility.SetPositionAllocator (positionAlloc);
+
+ mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
+
+ mobility.Install (wifiApNode);
+ mobility.Install (wifiStaNode);
+
+ /* Internet stack*/
+ InternetStackHelper stack;
+ stack.Install (wifiApNode);
+ stack.Install (wifiStaNode);
+
+ Ipv4AddressHelper address;
+
+ address.SetBase ("192.168.1.0", "255.255.255.0");
+ Ipv4InterfaceContainer staNodeInterface;
+ Ipv4InterfaceContainer apNodeInterface;
+
+ staNodeInterface = address.Assign (staDevice);
+ apNodeInterface = address.Assign (apDevice);
+
+ /* Setting applications */
+ ApplicationContainer serverApp, sinkApp;
+ if (udp)
+ {
+ //UDP flow
+ UdpServerHelper myServer (9);
+ serverApp = myServer.Install (wifiStaNode.Get (0));
+ serverApp.Start (Seconds (0.0));
+ serverApp.Stop (Seconds (simulationTime + 1));
+
+ UdpClientHelper myClient (staNodeInterface.GetAddress (0), 9);
+ myClient.SetAttribute ("MaxPackets", UintegerValue (1000));
+ myClient.SetAttribute ("Interval", TimeValue (MilliSeconds (5)));
+ myClient.SetAttribute ("PacketSize", UintegerValue (payloadSize));
+
+ ApplicationContainer clientApp = myClient.Install (wifiApNode.Get (0));
+ clientApp.Start (Seconds (1.0));
+ clientApp.Stop (Seconds (simulationTime + 1));
+ }
+ else
+ {
+ //TCP flow
+ uint16_t port = 50000;
+ Address apLocalAddress (InetSocketAddress (Ipv4Address::GetAny (), port));
+ PacketSinkHelper packetSinkHelper ("ns3::TcpSocketFactory", apLocalAddress);
+ sinkApp = packetSinkHelper.Install (wifiStaNode.Get (0));
+
+ sinkApp.Start (Seconds (0.0));
+ sinkApp.Stop (Seconds (simulationTime + 1));
+
+ OnOffHelper onoff ("ns3::TcpSocketFactory",Ipv4Address::GetAny ());
+ onoff.SetAttribute ("OnTime", StringValue ("ns3::ConstantRandomVariable[Constant=1]"));
+ onoff.SetAttribute ("OffTime", StringValue ("ns3::ConstantRandomVariable[Constant=0]"));
+ onoff.SetAttribute ("PacketSize", UintegerValue (payloadSize));
+ onoff.SetAttribute ("DataRate", DataRateValue (1000000000)); //bit/s
+ ApplicationContainer apps;
+
+ AddressValue remoteAddress (InetSocketAddress (staNodeInterface.GetAddress (0), port));
+ onoff.SetAttribute ("Remote", remoteAddress);
+ apps.Add (onoff.Install (wifiApNode.Get (0)));
+ apps.Start (Seconds (1.0));
+ apps.Stop (Seconds (simulationTime + 1));
+ }
+
+ Config::ConnectWithoutContext ("/NodeList/0/DeviceList/*/Phy/MonitorSnifferRx", MakeCallback (&MonitorSniffRx));
+
+ if (enablePcap)
+ {
+ std::stringstream ss;
+ ss << "wifi-spectrum-per-example-" << i;
+ phy.EnablePcap (ss.str (), apDevice);
+ }
+ g_signalDbmAvg = 0;
+ g_noiseDbmAvg = 0;
+ g_samples = 0;
+ g_channelNumber = 0;
+ g_rate = 0;
+
+ Simulator::Stop (Seconds (simulationTime + 1));
+ Simulator::Run ();
+ Simulator::Destroy ();
+
+ double throughput = 0;
+ uint32_t totalPacketsThrough = 0;
+ if (udp)
+ {
+ //UDP
+ totalPacketsThrough = DynamicCast (serverApp.Get (0))->GetReceived ();
+ throughput = totalPacketsThrough * payloadSize * 8 / (simulationTime * 1000000.0); //Mbit/s
+ }
+ else
+ {
+ //TCP
+ uint32_t totalBytesRx = DynamicCast (sinkApp.Get (0))->GetTotalRx ();
+ totalPacketsThrough = totalBytesRx / tcpPacketSize;
+ throughput = totalBytesRx * 8 / (simulationTime * 1000000.0); //Mbit/s
+ }
+ std::cout << std::setw (5) << i <<
+ std::setw (6) << (i % 8) <<
+ std::setw (10) << datarate <<
+ std::setw (12) << throughput <<
+ std::setw (8) << totalPacketsThrough;
+ if (totalPacketsThrough > 0)
+ {
+ std::cout << std::setw (12) << g_signalDbmAvg <<
+ std::setw (12) << g_noiseDbmAvg <<
+ std::setw (12) << (g_signalDbmAvg - g_noiseDbmAvg) <<
+ std::endl;
+ }
+ else
+ {
+ std::cout << std::setw (12) << "N/A" <<
+ std::setw (12) << "N/A" <<
+ std::setw (12) << "N/A" <<
+ std::endl;
+ }
+ }
+ return 0;
+}
diff --git a/examples/wireless/wifi-spectrum-per-interference.cc b/examples/wireless/wifi-spectrum-per-interference.cc
new file mode 100644
index 00000000000..103460d2dc7
--- /dev/null
+++ b/examples/wireless/wifi-spectrum-per-interference.cc
@@ -0,0 +1,627 @@
+/* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2009 MIRKO BANCHI
+ * Copyright (c) 2015 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
+ *
+ * Authors: Mirko Banchi
+ * Sebastien Deronne
+ * Tom Henderson
+ *
+ * Adapted from ht-wifi-network.cc example
+ */
+#include
+#include
+
+#include "ns3/core-module.h"
+#include "ns3/config-store-module.h"
+#include "ns3/network-module.h"
+#include "ns3/applications-module.h"
+#include "ns3/wifi-module.h"
+#include "ns3/mobility-module.h"
+#include "ns3/spectrum-module.h"
+#include "ns3/internet-module.h"
+
+// This is a simple example of an IEEE 802.11n Wi-Fi network with a
+// non-Wi-Fi interferer. It is an adaptation of the wifi-spectrum-per-example
+//
+// Unless the --waveformPower argument is passed, it will behave like
+// wifi-spectrum-per-example. Adding --waveformPower=value for values
+// greater than 0.0001 will result in frame losses beyond those that
+// result from the normal SNR based on distance path loss.
+//
+// If YansWifiPhy is selected as the wifiType, --waveformPower will have
+// no effect.
+//
+// Network topology:
+//
+// Wi-Fi 192.168.1.0
+//
+// STA AP
+// * <-- distance --> *
+// | |
+// n1 n2
+//
+// Users may vary the following command-line arguments in addition to the
+// attributes, global values, and default values typically available:
+//
+// --simulationTime: Simulation time in seconds [10]
+// --udp: UDP if set to 1, TCP otherwise [true]
+// --distance: meters separation between nodes [50]
+// --index: restrict index to single value between 0 and 31 [256]
+// --wifiType: select ns3::SpectrumWifiPhy or ns3::YansWifiPhy [ns3::SpectrumWifiPhy]
+// --errorModelType: select ns3::NistErrorRateModel or ns3::YansErrorRateModel [ns3::NistErrorRateModel]
+// --enablePcap: enable pcap output [false]
+// --waveformPower: Waveform power [0]
+//
+// By default, the program will step through 32 index values, corresponding
+// to the following MCS, channel width, and guard interval combinations:
+// index 0-7: MCS 0-7, long guard interval, 20 MHz channel
+// index 8-15: MCS 0-7, short guard interval, 20 MHz channel
+// index 16-23: MCS 0-7, long guard interval, 40 MHz channel
+// index 24-31: MCS 0-7, short guard interval, 40 MHz channel
+// and send 1000 UDP packets using each MCS, using the SpectrumWifiPhy and the
+// NistErrorRateModel, at a distance of 50 meters. The program outputs
+// results such as:
+//
+// wifiType: ns3::SpectrumWifiPhy distance: 50m; sent: 1000
+// index MCS Rate (Mb/s) Tput (Mb/s) Received Signal (dBm) Noise (dBm) SNR (dB)
+// 0 0 6.5 0.7776 1000 -77.6633 -100.966 23.3027
+// 1 1 13 0.7776 1000 -77.6633 -100.966 23.3027
+// 2 2 19.5 0.7776 1000 -77.6633 -100.966 23.3027
+// 3 3 26 0.7776 1000 -77.6633 -100.966 23.3027
+// ...
+//
+// When UDP is used, the throughput will always be 0.7776 Mb/s since the
+// traffic generator does not attempt to match the maximum Phy data rate
+// but instead sends at a constant rate. When TCP is used, the TCP flow
+// will exhibit different throughput depending on the index.
+
+using namespace ns3;
+
+// Global variables for use in callbacks.
+double g_signalDbmAvg;
+double g_noiseDbmAvg;
+uint32_t g_samples;
+uint16_t g_channelNumber;
+uint32_t g_rate;
+
+void MonitorSniffRx (Ptr packet, uint16_t channelFreqMhz,
+ uint16_t channelNumber, uint32_t rate,
+ WifiPreamble preamble, WifiTxVector txVector,
+ struct mpduInfo aMpdu, struct signalNoiseDbm signalNoise)
+
+{
+ g_samples++;
+ g_signalDbmAvg += ((signalNoise.signal - g_signalDbmAvg) / g_samples);
+ g_noiseDbmAvg += ((signalNoise.noise - g_noiseDbmAvg) / g_samples);
+ g_rate = rate;
+ g_channelNumber = channelNumber;
+}
+
+NS_LOG_COMPONENT_DEFINE ("WifiSpectrumPerInterference");
+
+Ptr SpectrumModelWifi5180MHz;
+
+class static_SpectrumModelWifi5180MHz_initializer
+{
+public:
+ static_SpectrumModelWifi5180MHz_initializer ()
+ {
+ BandInfo bandInfo;
+ bandInfo.fc = 5180e6;
+ bandInfo.fl = 5180e6 - 10e6;
+ bandInfo.fh = 5180e6 + 10e6;
+
+ Bands bands;
+ bands.push_back (bandInfo);
+
+ SpectrumModelWifi5180MHz = Create (bands);
+ }
+
+} static_SpectrumModelWifi5180MHz_initializer_instance;
+
+int main (int argc, char *argv[])
+{
+ bool udp = true;
+ double distance = 50;
+ double simulationTime = 10; //seconds
+ uint16_t index = 256;
+ std::string wifiType = "ns3::SpectrumWifiPhy";
+ std::string errorModelType = "ns3::NistErrorRateModel";
+ bool enablePcap = false;
+ const uint32_t tcpPacketSize = 1448;
+ double waveformPower = 0;
+
+ CommandLine cmd;
+ cmd.AddValue ("simulationTime", "Simulation time in seconds", simulationTime);
+ cmd.AddValue ("udp", "UDP if set to 1, TCP otherwise", udp);
+ cmd.AddValue ("distance", "meters separation between nodes", distance);
+ cmd.AddValue ("index", "restrict index to single value between 0 and 31", index);
+ cmd.AddValue ("wifiType", "select ns3::SpectrumWifiPhy or ns3::YansWifiPhy", wifiType);
+ cmd.AddValue ("errorModelType", "select ns3::NistErrorRateModel or ns3::YansErrorRateModel", errorModelType);
+ cmd.AddValue ("enablePcap", "enable pcap output", enablePcap);
+ cmd.AddValue ("waveformPower", "Waveform power", waveformPower);
+ cmd.Parse (argc,argv);
+
+ uint16_t startIndex = 0;
+ uint16_t stopIndex = 31;
+ if (index < 32)
+ {
+ startIndex = index;
+ stopIndex = index;
+ }
+
+ std::cout << "wifiType: " << wifiType << " distance: " << distance << "m; sent: 1000 TxPower: 16 dBm (40 mW)" << std::endl;
+ std::cout << std::setw (5) << "index" <<
+ std::setw (6) << "MCS" <<
+ std::setw (12) << "Rate (Mb/s)" <<
+ std::setw (12) << "Tput (Mb/s)" <<
+ std::setw (10) << "Received " <<
+ std::setw (12) << "Signal (dBm)" <<
+ std::setw (12) << "Noi+Inf(dBm)" <<
+ std::setw (10) << "SNR (dB)" <<
+ std::endl;
+ for (uint16_t i = startIndex; i <= stopIndex; i++)
+ {
+ uint32_t payloadSize;
+ if (udp)
+ {
+ payloadSize = 972; // 1000 bytes IPv4
+ }
+ else
+ {
+ payloadSize = 1448; // 1500 bytes IPv6
+ Config::SetDefault ("ns3::TcpSocket::SegmentSize", UintegerValue (payloadSize));
+ }
+
+ NodeContainer wifiStaNode;
+ wifiStaNode.Create (1);
+ NodeContainer wifiApNode;
+ wifiApNode.Create (1);
+ NodeContainer interferingNode;
+ interferingNode.Create (1);
+
+ YansWifiPhyHelper phy = YansWifiPhyHelper::Default ();
+ SpectrumWifiPhyHelper spectrumPhy = SpectrumWifiPhyHelper::Default ();
+ Ptr spectrumChannel;
+ if (wifiType == "ns3::YansWifiPhy")
+ {
+ YansWifiChannelHelper channel;
+ channel.AddPropagationLoss ("ns3::FriisPropagationLossModel");
+ channel.SetPropagationDelay ("ns3::ConstantSpeedPropagationDelayModel");
+ phy.SetChannel (channel.Create ());
+ phy.Set ("Frequency", UintegerValue (5180));
+
+ if (i <= 7)
+ {
+ phy.Set ("ShortGuardEnabled", BooleanValue (false));
+ phy.Set ("ChannelWidth", UintegerValue (20));
+ }
+ else if (i > 7 && i <= 15)
+ {
+ phy.Set ("ShortGuardEnabled", BooleanValue (true));
+ phy.Set ("ChannelWidth", UintegerValue (20));
+ }
+ else if (i > 15 && i <= 23)
+ {
+ phy.Set ("ShortGuardEnabled", BooleanValue (false));
+ phy.Set ("ChannelWidth", UintegerValue (40));
+ }
+ else
+ {
+ phy.Set ("ShortGuardEnabled", BooleanValue (true));
+ phy.Set ("ChannelWidth", UintegerValue (40));
+ }
+ }
+ else if (wifiType == "ns3::SpectrumWifiPhy")
+ {
+ spectrumChannel
+ = CreateObject ();
+ Ptr lossModel
+ = CreateObject ();
+ spectrumChannel->AddPropagationLossModel (lossModel);
+
+
+ Ptr delayModel
+ = CreateObject ();
+ spectrumChannel->SetPropagationDelayModel (delayModel);
+
+ spectrumPhy.SetChannel (spectrumChannel);
+ spectrumPhy.SetErrorRateModel (errorModelType);
+ spectrumPhy.Set ("Frequency", UintegerValue (5180)); // channel 36 at 20 MHz
+
+ if (i <= 7)
+ {
+ spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (false));
+ spectrumPhy.Set ("ChannelWidth", UintegerValue (20));
+ }
+ else if (i > 7 && i <= 15)
+ {
+ spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (true));
+ spectrumPhy.Set ("ChannelWidth", UintegerValue (20));
+ }
+ else if (i > 15 && i <= 23)
+ {
+ spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (false));
+ spectrumPhy.Set ("ChannelWidth", UintegerValue (40));
+ }
+ else
+ {
+ spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (true));
+ spectrumPhy.Set ("ChannelWidth", UintegerValue (40));
+ }
+ }
+ else
+ {
+ NS_FATAL_ERROR ("Unsupported WiFi type " << wifiType);
+ }
+
+
+ WifiHelper wifi;
+ wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);
+ WifiMacHelper mac;
+
+ Ssid ssid = Ssid ("ns380211n");
+
+ double datarate = 0;
+ StringValue DataRate;
+ if (i == 0)
+ {
+ DataRate = StringValue ("HtMcs0");
+ datarate = 6.5;
+ }
+ else if (i == 1)
+ {
+ DataRate = StringValue ("HtMcs1");
+ datarate = 13;
+ }
+ else if (i == 2)
+ {
+ DataRate = StringValue ("HtMcs2");
+ datarate = 19.5;
+ }
+ else if (i == 3)
+ {
+ DataRate = StringValue ("HtMcs3");
+ datarate = 26;
+ }
+ else if (i == 4)
+ {
+ DataRate = StringValue ("HtMcs4");
+ datarate = 39;
+ }
+ else if (i == 5)
+ {
+ DataRate = StringValue ("HtMcs5");
+ datarate = 52;
+ }
+ else if (i == 6)
+ {
+ DataRate = StringValue ("HtMcs6");
+ datarate = 58.5;
+ }
+ else if (i == 7)
+ {
+ DataRate = StringValue ("HtMcs7");
+ datarate = 65;
+ }
+ else if (i == 8)
+ {
+ DataRate = StringValue ("HtMcs0");
+ datarate = 7.2;
+ }
+ else if (i == 9)
+ {
+ DataRate = StringValue ("HtMcs1");
+ datarate = 14.4;
+ }
+ else if (i == 10)
+ {
+ DataRate = StringValue ("HtMcs2");
+ datarate = 21.7;
+ }
+ else if (i == 11)
+ {
+ DataRate = StringValue ("HtMcs3");
+ datarate = 28.9;
+ }
+ else if (i == 12)
+ {
+ DataRate = StringValue ("HtMcs4");
+ datarate = 43.3;
+ }
+ else if (i == 13)
+ {
+ DataRate = StringValue ("HtMcs5");
+ datarate = 57.8;
+ }
+ else if (i == 14)
+ {
+ DataRate = StringValue ("HtMcs6");
+ datarate = 65;
+ }
+ else if (i == 15)
+ {
+ DataRate = StringValue ("HtMcs7");
+ datarate = 72.2;
+ }
+ else if (i == 16)
+ {
+ DataRate = StringValue ("HtMcs0");
+ datarate = 13.5;
+ }
+ else if (i == 17)
+ {
+ DataRate = StringValue ("HtMcs1");
+ datarate = 27;
+ }
+ else if (i == 18)
+ {
+ DataRate = StringValue ("HtMcs2");
+ datarate = 40.5;
+ }
+ else if (i == 19)
+ {
+ DataRate = StringValue ("HtMcs3");
+ datarate = 54;
+ }
+ else if (i == 20)
+ {
+ DataRate = StringValue ("HtMcs4");
+ datarate = 81;
+ }
+ else if (i == 21)
+ {
+ DataRate = StringValue ("HtMcs5");
+ datarate = 108;
+ }
+ else if (i == 22)
+ {
+ DataRate = StringValue ("HtMcs6");
+ datarate = 121.5;
+ }
+ else if (i == 23)
+ {
+ DataRate = StringValue ("HtMcs7");
+ datarate = 135;
+ }
+ else if (i == 24)
+ {
+ DataRate = StringValue ("HtMcs0");
+ datarate = 15;
+ }
+ else if (i == 25)
+ {
+ DataRate = StringValue ("HtMcs1");
+ datarate = 30;
+ }
+ else if (i == 26)
+ {
+ DataRate = StringValue ("HtMcs2");
+ datarate = 45;
+ }
+ else if (i == 27)
+ {
+ DataRate = StringValue ("HtMcs3");
+ datarate = 60;
+ }
+ else if (i == 28)
+ {
+ DataRate = StringValue ("HtMcs4");
+ datarate = 90;
+ }
+ else if (i == 29)
+ {
+ DataRate = StringValue ("HtMcs5");
+ datarate = 120;
+ }
+ else if (i == 30)
+ {
+ DataRate = StringValue ("HtMcs6");
+ datarate = 135;
+ }
+ else
+ {
+ DataRate = StringValue ("HtMcs7");
+ datarate = 150;
+ }
+
+ wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager","DataMode", DataRate,
+ "ControlMode", DataRate);
+
+ NetDeviceContainer staDevice;
+ NetDeviceContainer apDevice;
+
+ if (wifiType == "ns3::YansWifiPhy")
+ {
+ mac.SetType ("ns3::StaWifiMac",
+ "Ssid", SsidValue (ssid),
+ "ActiveProbing", BooleanValue (false));
+ staDevice = wifi.Install (phy, mac, wifiStaNode);
+ mac.SetType ("ns3::ApWifiMac",
+ "Ssid", SsidValue (ssid));
+ apDevice = wifi.Install (phy, mac, wifiApNode);
+
+ }
+ else if (wifiType == "ns3::SpectrumWifiPhy")
+ {
+ mac.SetType ("ns3::StaWifiMac",
+ "Ssid", SsidValue (ssid),
+ "ActiveProbing", BooleanValue (false));
+ staDevice = wifi.Install (spectrumPhy, mac, wifiStaNode);
+ mac.SetType ("ns3::ApWifiMac",
+ "Ssid", SsidValue (ssid));
+ apDevice = wifi.Install (spectrumPhy, mac, wifiApNode);
+ }
+
+ // mobility.
+ MobilityHelper mobility;
+ Ptr positionAlloc = CreateObject ();
+
+ positionAlloc->Add (Vector (0.0, 0.0, 0.0));
+ positionAlloc->Add (Vector (distance, 0.0, 0.0));
+ positionAlloc->Add (Vector (distance, distance, 0.0));
+ mobility.SetPositionAllocator (positionAlloc);
+
+ mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
+
+ mobility.Install (wifiApNode);
+ mobility.Install (wifiStaNode);
+ mobility.Install (interferingNode);
+
+ /* Internet stack*/
+ InternetStackHelper stack;
+ stack.Install (wifiApNode);
+ stack.Install (wifiStaNode);
+
+ Ipv4AddressHelper address;
+
+ address.SetBase ("192.168.1.0", "255.255.255.0");
+ Ipv4InterfaceContainer staNodeInterface;
+ Ipv4InterfaceContainer apNodeInterface;
+
+ staNodeInterface = address.Assign (staDevice);
+ apNodeInterface = address.Assign (apDevice);
+
+ /* Setting applications */
+ ApplicationContainer serverApp, sinkApp;
+ if (udp)
+ {
+ //UDP flow
+ UdpServerHelper myServer (9);
+ serverApp = myServer.Install (wifiStaNode.Get (0));
+ serverApp.Start (Seconds (0.0));
+ serverApp.Stop (Seconds (simulationTime + 1));
+
+ UdpClientHelper myClient (staNodeInterface.GetAddress (0), 9);
+ myClient.SetAttribute ("MaxPackets", UintegerValue (1000));
+ myClient.SetAttribute ("Interval", TimeValue (MilliSeconds (5)));
+ myClient.SetAttribute ("PacketSize", UintegerValue (payloadSize));
+
+ ApplicationContainer clientApp = myClient.Install (wifiApNode.Get (0));
+ clientApp.Start (Seconds (1.0));
+ clientApp.Stop (Seconds (simulationTime + 1));
+ }
+ else
+ {
+ //TCP flow
+ uint16_t port = 50000;
+ Address apLocalAddress (InetSocketAddress (Ipv4Address::GetAny (), port));
+ PacketSinkHelper packetSinkHelper ("ns3::TcpSocketFactory", apLocalAddress);
+ sinkApp = packetSinkHelper.Install (wifiStaNode.Get (0));
+
+ sinkApp.Start (Seconds (0.0));
+ sinkApp.Stop (Seconds (simulationTime + 1));
+
+ OnOffHelper onoff ("ns3::TcpSocketFactory",Ipv4Address::GetAny ());
+ onoff.SetAttribute ("OnTime", StringValue ("ns3::ConstantRandomVariable[Constant=1]"));
+ onoff.SetAttribute ("OffTime", StringValue ("ns3::ConstantRandomVariable[Constant=0]"));
+ onoff.SetAttribute ("PacketSize", UintegerValue (payloadSize));
+ onoff.SetAttribute ("DataRate", DataRateValue (1000000000)); //bit/s
+ ApplicationContainer apps;
+
+ AddressValue remoteAddress (InetSocketAddress (staNodeInterface.GetAddress (0), port));
+ onoff.SetAttribute ("Remote", remoteAddress);
+ apps.Add (onoff.Install (wifiApNode.Get (0)));
+ apps.Start (Seconds (1.0));
+ apps.Stop (Seconds (simulationTime + 1));
+ }
+ // Configure waveform generator
+
+ Ptr wgPsd = Create (SpectrumModelWifi5180MHz);
+ *wgPsd = waveformPower / (100 * 180000);
+ NS_LOG_INFO ("wgPsd : " << *wgPsd << " integrated power: " << Integral (*(GetPointer (wgPsd))));
+
+ if (wifiType == "ns3::SpectrumWifiPhy")
+ {
+ WaveformGeneratorHelper waveformGeneratorHelper;
+ waveformGeneratorHelper.SetChannel (spectrumChannel);
+ waveformGeneratorHelper.SetTxPowerSpectralDensity (wgPsd);
+
+ waveformGeneratorHelper.SetPhyAttribute ("Period", TimeValue (Seconds (0.0007)));
+ waveformGeneratorHelper.SetPhyAttribute ("DutyCycle", DoubleValue (1));
+ NetDeviceContainer waveformGeneratorDevices = waveformGeneratorHelper.Install (interferingNode);
+
+ Simulator::Schedule (Seconds (0.002), &WaveformGenerator::Start,
+ waveformGeneratorDevices.Get (0)->GetObject ()->GetPhy ()->GetObject ());
+ }
+
+ Config::ConnectWithoutContext ("/NodeList/0/DeviceList/*/Phy/MonitorSnifferRx", MakeCallback (&MonitorSniffRx));
+
+ if (enablePcap)
+ {
+ std::stringstream ss;
+ ss << "wifi-spectrum-per-example-" << i;
+ phy.EnablePcap (ss.str (), apDevice);
+ }
+ g_signalDbmAvg = 0;
+ g_noiseDbmAvg = 0;
+ g_samples = 0;
+ g_channelNumber = 0;
+ g_rate = 0;
+
+ // Make sure we are tuned to 5180 MHz; if not, the example will
+ // not work properly
+ Ptr staDevicePtr = staDevice.Get (0);
+ Ptr wifiStaDevicePtr = staDevicePtr->GetObject ();
+ UintegerValue val;
+ wifiStaDevicePtr->GetPhy ()->GetAttribute ("Frequency", val);
+ if (val.Get () != 5180)
+ {
+ NS_FATAL_ERROR ("Error: Wi-Fi nodes must be tuned to 5180 MHz to match the waveform generator");
+ }
+
+ Simulator::Stop (Seconds (simulationTime + 1));
+ Simulator::Run ();
+ Simulator::Destroy ();
+
+ double throughput = 0;
+ uint32_t totalPacketsThrough = 0;
+ if (udp)
+ {
+ //UDP
+ totalPacketsThrough = DynamicCast (serverApp.Get (0))->GetReceived ();
+ throughput = totalPacketsThrough * payloadSize * 8 / (simulationTime * 1000000.0); //Mbit/s
+ }
+ else
+ {
+ //TCP
+ uint32_t totalBytesRx = DynamicCast (sinkApp.Get (0))->GetTotalRx ();
+ totalPacketsThrough = totalBytesRx / tcpPacketSize;
+ throughput = totalBytesRx * 8 / (simulationTime * 1000000.0); //Mbit/s
+ }
+ std::cout << std::setw (5) << i <<
+ std::setw (6) << (i % 8) <<
+ std::setw (10) << datarate <<
+ std::setw (12) << throughput <<
+ std::setw (8) << totalPacketsThrough;
+ if (totalPacketsThrough > 0)
+ {
+ std::cout << std::setw (12) << g_signalDbmAvg <<
+ std::setw (12) << g_noiseDbmAvg <<
+ std::setw (12) << (g_signalDbmAvg - g_noiseDbmAvg) <<
+ std::endl;
+ }
+ else
+ {
+ std::cout << std::setw (12) << "N/A" <<
+ std::setw (12) << "N/A" <<
+ std::setw (12) << "N/A" <<
+ std::endl;
+ }
+ }
+ return 0;
+}
diff --git a/examples/wireless/wifi-spectrum-saturation-example.cc b/examples/wireless/wifi-spectrum-saturation-example.cc
new file mode 100644
index 00000000000..4dedf297974
--- /dev/null
+++ b/examples/wireless/wifi-spectrum-saturation-example.cc
@@ -0,0 +1,701 @@
+/* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2009 MIRKO BANCHI
+ * Copyright (c) 2015 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
+ *
+ * Authors: Mirko Banchi
+ * Sebastien Deronne
+ * Tom Henderson
+ *
+ * Adapted from ht-wifi-network.cc example
+ */
+#include
+#include
+
+#include "ns3/core-module.h"
+#include "ns3/config-store-module.h"
+#include "ns3/network-module.h"
+#include "ns3/applications-module.h"
+#include "ns3/wifi-module.h"
+#include "ns3/mobility-module.h"
+#include "ns3/spectrum-module.h"
+#include "ns3/internet-module.h"
+
+// This is a simple example of an IEEE 802.11n Wi-Fi network.
+//
+// The main use case is to enable and test SpectrumWifiPhy vs YansWifiPhy
+// under saturation conditions (for max throughput).
+//
+// Network topology:
+//
+// Wi-Fi 192.168.1.0
+//
+// STA AP
+// * <-- distance --> *
+// | |
+// n1 n2
+//
+// Users may vary the following command-line arguments in addition to the
+// attributes, global values, and default values typically available:
+//
+// --simulationTime: Simulation time in seconds [10]
+// --distance: meters separation between nodes [50]
+// --index: restrict index to single value between 0 and 31 [256]
+// --wifiType: select ns3::SpectrumWifiPhy or ns3::YansWifiPhy [ns3::SpectrumWifiPhy]
+// --errorModelType: select ns3::NistErrorRateModel or ns3::YansErrorRateModel [ns3::NistErrorRateModel]
+// --enablePcap: enable pcap output [false]
+//
+// By default, the program will step through 64 index values, corresponding
+// to the following MCS, channel width, and guard interval combinations:
+// index 0-7: MCS 0-7, long guard interval, 20 MHz channel
+// index 8-15: MCS 0-7, short guard interval, 20 MHz channel
+// index 16-23: MCS 0-7, long guard interval, 40 MHz channel
+// index 24-31: MCS 0-7, short guard interval, 40 MHz channel
+// index 32-39: MCS 8-15, long guard interval, 20 MHz channel
+// index 40-47: MCS 8-15, short guard interval, 20 MHz channel
+// index 48-55: MCS 8-15, long guard interval, 40 MHz channel
+// index 56-63: MCS 8-15, short guard interval, 40 MHz channel
+// and send packets at a high rate using each MCS, using the SpectrumWifiPhy
+// and the NistErrorRateModel, at a distance of 1 meter. The program outputs
+// results such as:
+//
+// wifiType: ns3::SpectrumWifiPhy distance: 1m
+// index MCS width Rate (Mb/s) Tput (Mb/s) Received
+// 0 0 20 6.5 5.96219 5063
+// 1 1 20 13 11.9491 10147
+// 2 2 20 19.5 17.9184 15216
+// 3 3 20 26 23.9253 20317
+// ...
+//
+// selection of index values 32-63 will result in MCS selection 8-15
+// involving two spatial streams
+
+using namespace ns3;
+
+NS_LOG_COMPONENT_DEFINE ("WifiSpectrumSaturationExample");
+
+int main (int argc, char *argv[])
+{
+ double distance = 1;
+ double simulationTime = 10; //seconds
+ uint16_t index = 256;
+ uint32_t channelWidth;
+ std::string wifiType = "ns3::SpectrumWifiPhy";
+ std::string errorModelType = "ns3::NistErrorRateModel";
+ bool enablePcap = false;
+
+ CommandLine cmd;
+ cmd.AddValue ("simulationTime", "Simulation time in seconds", simulationTime);
+ cmd.AddValue ("distance", "meters separation between nodes", distance);
+ cmd.AddValue ("index", "restrict index to single value between 0 and 63", index);
+ cmd.AddValue ("wifiType", "select ns3::SpectrumWifiPhy or ns3::YansWifiPhy", wifiType);
+ cmd.AddValue ("errorModelType", "select ns3::NistErrorRateModel or ns3::YansErrorRateModel", errorModelType);
+ cmd.AddValue ("enablePcap", "enable pcap output", enablePcap);
+ cmd.Parse (argc,argv);
+
+ uint16_t startIndex = 0;
+ uint16_t stopIndex = 63;
+ if (index < 64)
+ {
+ startIndex = index;
+ stopIndex = index;
+ }
+
+ std::cout << "wifiType: " << wifiType << " distance: " << distance << "m" << std::endl;
+ std::cout << std::setw (5) << "index" <<
+ std::setw (6) << "MCS" <<
+ std::setw (8) << "width" <<
+ std::setw (12) << "Rate (Mb/s)" <<
+ std::setw (12) << "Tput (Mb/s)" <<
+ std::setw (10) << "Received " <<
+ std::endl;
+ for (uint16_t i = startIndex; i <= stopIndex; i++)
+ {
+ uint32_t payloadSize;
+ payloadSize = 1472; // 1500 bytes IPv4
+
+ NodeContainer wifiStaNode;
+ wifiStaNode.Create (1);
+ NodeContainer wifiApNode;
+ wifiApNode.Create (1);
+
+ YansWifiPhyHelper phy = YansWifiPhyHelper::Default ();
+ SpectrumWifiPhyHelper spectrumPhy = SpectrumWifiPhyHelper::Default ();
+ if (wifiType == "ns3::YansWifiPhy")
+ {
+ YansWifiChannelHelper channel;
+ channel.AddPropagationLoss ("ns3::FriisPropagationLossModel");
+ channel.SetPropagationDelay ("ns3::ConstantSpeedPropagationDelayModel");
+ phy.SetChannel (channel.Create ());
+ phy.Set ("TxPowerStart", DoubleValue (1));
+ phy.Set ("TxPowerEnd", DoubleValue (1));
+
+ if (i <= 7)
+ {
+ phy.Set ("ShortGuardEnabled", BooleanValue (false));
+ channelWidth = 20;
+ }
+ else if (i > 7 && i <= 15)
+ {
+ phy.Set ("ShortGuardEnabled", BooleanValue (true));
+ channelWidth = 20;
+ }
+ else if (i > 15 && i <= 23)
+ {
+ phy.Set ("ShortGuardEnabled", BooleanValue (false));
+ channelWidth = 40;
+ }
+ else if (i > 23 && i <= 31)
+ {
+ phy.Set ("ShortGuardEnabled", BooleanValue (true));
+ channelWidth = 40;
+ }
+ else if (i > 31 && i <= 39)
+ {
+ phy.Set ("ShortGuardEnabled", BooleanValue (false));
+ phy.Set ("RxAntennas", UintegerValue (2));
+ phy.Set ("TxAntennas", UintegerValue (2));
+ channelWidth = 20;
+ }
+ else if (i > 39 && i <= 47)
+ {
+ phy.Set ("ShortGuardEnabled", BooleanValue (true));
+ phy.Set ("RxAntennas", UintegerValue (2));
+ phy.Set ("TxAntennas", UintegerValue (2));
+ channelWidth = 20;
+ }
+ else if (i > 47 && i <= 55)
+ {
+ phy.Set ("ShortGuardEnabled", BooleanValue (false));
+ phy.Set ("RxAntennas", UintegerValue (2));
+ phy.Set ("TxAntennas", UintegerValue (2));
+ channelWidth = 40;
+ }
+ else if (i > 55 && i <= 63)
+ {
+ phy.Set ("ShortGuardEnabled", BooleanValue (true));
+ phy.Set ("RxAntennas", UintegerValue (2));
+ phy.Set ("TxAntennas", UintegerValue (2));
+ channelWidth = 40;
+ }
+ }
+ else if (wifiType == "ns3::SpectrumWifiPhy")
+ {
+ Ptr spectrumChannel
+ = CreateObject ();
+ Ptr lossModel
+ = CreateObject ();
+ spectrumChannel->AddPropagationLossModel (lossModel);
+
+ Ptr delayModel
+ = CreateObject ();
+ spectrumChannel->SetPropagationDelayModel (delayModel);
+
+ spectrumPhy.SetChannel (spectrumChannel);
+ spectrumPhy.SetErrorRateModel (errorModelType);
+ spectrumPhy.Set ("Frequency", UintegerValue (5180)); // channel 36 at 20 MHz
+ spectrumPhy.Set ("TxPowerStart", DoubleValue (1));
+ spectrumPhy.Set ("TxPowerEnd", DoubleValue (1));
+
+ if (i <= 7)
+ {
+ spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (false));
+ channelWidth = 20;
+ }
+ else if (i > 7 && i <= 15)
+ {
+ spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (true));
+ channelWidth = 20;
+ }
+ else if (i > 15 && i <= 23)
+ {
+ spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (false));
+ channelWidth = 40;
+ }
+ else if (i > 23 && i <= 31)
+ {
+ spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (true));
+ channelWidth = 40;
+ }
+ else if (i > 31 && i <= 39)
+ {
+ spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (false));
+ spectrumPhy.Set ("RxAntennas", UintegerValue (2));
+ spectrumPhy.Set ("TxAntennas", UintegerValue (2));
+ channelWidth = 20;
+ }
+ else if (i > 39 && i <= 47)
+ {
+ spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (true));
+ spectrumPhy.Set ("RxAntennas", UintegerValue (2));
+ spectrumPhy.Set ("TxAntennas", UintegerValue (2));
+ channelWidth = 20;
+ }
+ else if (i > 47 && i <= 55)
+ {
+ spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (false));
+ spectrumPhy.Set ("RxAntennas", UintegerValue (2));
+ spectrumPhy.Set ("TxAntennas", UintegerValue (2));
+ channelWidth = 40;
+ }
+ else if (i > 55 && i <= 63)
+ {
+ spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (true));
+ spectrumPhy.Set ("RxAntennas", UintegerValue (2));
+ spectrumPhy.Set ("TxAntennas", UintegerValue (2));
+ channelWidth = 40;
+ }
+ }
+ else
+ {
+ NS_FATAL_ERROR ("Unsupported WiFi type " << wifiType);
+ }
+
+
+ WifiHelper wifi;
+ wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);
+ WifiMacHelper mac;
+
+ Ssid ssid = Ssid ("ns380211n");
+
+ double datarate = 0;
+ StringValue DataRate;
+ if (i == 0)
+ {
+ DataRate = StringValue ("HtMcs0");
+ datarate = 6.5;
+ }
+ else if (i == 1)
+ {
+ DataRate = StringValue ("HtMcs1");
+ datarate = 13;
+ }
+ else if (i == 2)
+ {
+ DataRate = StringValue ("HtMcs2");
+ datarate = 19.5;
+ }
+ else if (i == 3)
+ {
+ DataRate = StringValue ("HtMcs3");
+ datarate = 26;
+ }
+ else if (i == 4)
+ {
+ DataRate = StringValue ("HtMcs4");
+ datarate = 39;
+ }
+ else if (i == 5)
+ {
+ DataRate = StringValue ("HtMcs5");
+ datarate = 52;
+ }
+ else if (i == 6)
+ {
+ DataRate = StringValue ("HtMcs6");
+ datarate = 58.5;
+ }
+ else if (i == 7)
+ {
+ DataRate = StringValue ("HtMcs7");
+ datarate = 65;
+ }
+ else if (i == 8)
+ {
+ DataRate = StringValue ("HtMcs0");
+ datarate = 7.2;
+ }
+ else if (i == 9)
+ {
+ DataRate = StringValue ("HtMcs1");
+ datarate = 14.4;
+ }
+ else if (i == 10)
+ {
+ DataRate = StringValue ("HtMcs2");
+ datarate = 21.7;
+ }
+ else if (i == 11)
+ {
+ DataRate = StringValue ("HtMcs3");
+ datarate = 28.9;
+ }
+ else if (i == 12)
+ {
+ DataRate = StringValue ("HtMcs4");
+ datarate = 43.3;
+ }
+ else if (i == 13)
+ {
+ DataRate = StringValue ("HtMcs5");
+ datarate = 57.8;
+ }
+ else if (i == 14)
+ {
+ DataRate = StringValue ("HtMcs6");
+ datarate = 65;
+ }
+ else if (i == 15)
+ {
+ DataRate = StringValue ("HtMcs7");
+ datarate = 72.2;
+ }
+ else if (i == 16)
+ {
+ DataRate = StringValue ("HtMcs0");
+ datarate = 13.5;
+ }
+ else if (i == 17)
+ {
+ DataRate = StringValue ("HtMcs1");
+ datarate = 27;
+ }
+ else if (i == 18)
+ {
+ DataRate = StringValue ("HtMcs2");
+ datarate = 40.5;
+ }
+ else if (i == 19)
+ {
+ DataRate = StringValue ("HtMcs3");
+ datarate = 54;
+ }
+ else if (i == 20)
+ {
+ DataRate = StringValue ("HtMcs4");
+ datarate = 81;
+ }
+ else if (i == 21)
+ {
+ DataRate = StringValue ("HtMcs5");
+ datarate = 108;
+ }
+ else if (i == 22)
+ {
+ DataRate = StringValue ("HtMcs6");
+ datarate = 121.5;
+ }
+ else if (i == 23)
+ {
+ DataRate = StringValue ("HtMcs7");
+ datarate = 135;
+ }
+ else if (i == 24)
+ {
+ DataRate = StringValue ("HtMcs0");
+ datarate = 15;
+ }
+ else if (i == 25)
+ {
+ DataRate = StringValue ("HtMcs1");
+ datarate = 30;
+ }
+ else if (i == 26)
+ {
+ DataRate = StringValue ("HtMcs2");
+ datarate = 45;
+ }
+ else if (i == 27)
+ {
+ DataRate = StringValue ("HtMcs3");
+ datarate = 60;
+ }
+ else if (i == 28)
+ {
+ DataRate = StringValue ("HtMcs4");
+ datarate = 90;
+ }
+ else if (i == 29)
+ {
+ DataRate = StringValue ("HtMcs5");
+ datarate = 120;
+ }
+ else if (i == 30)
+ {
+ DataRate = StringValue ("HtMcs6");
+ datarate = 135;
+ }
+ else if (i == 31)
+ {
+ DataRate = StringValue ("HtMcs7");
+ datarate = 150;
+ }
+ else if (i == 32)
+ {
+ DataRate = StringValue ("HtMcs8");
+ datarate = 13;
+ }
+ else if (i == 33)
+ {
+ DataRate = StringValue ("HtMcs9");
+ datarate = 26;
+ }
+ else if (i == 34)
+ {
+ DataRate = StringValue ("HtMcs10");
+ datarate = 39;
+ }
+ else if (i == 35)
+ {
+ DataRate = StringValue ("HtMcs11");
+ datarate = 52;
+ }
+ else if (i == 36)
+ {
+ DataRate = StringValue ("HtMcs12");
+ datarate = 78;
+ }
+ else if (i == 37)
+ {
+ DataRate = StringValue ("HtMcs13");
+ datarate = 104;
+ }
+ else if (i == 38)
+ {
+ DataRate = StringValue ("HtMcs14");
+ datarate = 117;
+ }
+ else if (i == 39)
+ {
+ DataRate = StringValue ("HtMcs15");
+ datarate = 130;
+ }
+ else if (i == 40)
+ {
+ DataRate = StringValue ("HtMcs8");
+ datarate = 14.4;
+ }
+ else if (i == 41)
+ {
+ DataRate = StringValue ("HtMcs9");
+ datarate = 28.9;
+ }
+ else if (i == 42)
+ {
+ DataRate = StringValue ("HtMcs10");
+ datarate = 43.3;
+ }
+ else if (i == 43)
+ {
+ DataRate = StringValue ("HtMcs11");
+ datarate = 57.8;
+ }
+ else if (i == 44)
+ {
+ DataRate = StringValue ("HtMcs12");
+ datarate = 86.7;
+ }
+ else if (i == 45)
+ {
+ DataRate = StringValue ("HtMcs13");
+ datarate = 115.6;
+ }
+ else if (i == 46)
+ {
+ DataRate = StringValue ("HtMcs14");
+ datarate = 130.3;
+ }
+ else if (i == 47)
+ {
+ DataRate = StringValue ("HtMcs15");
+ datarate = 144.4;
+ }
+ else if (i == 48)
+ {
+ DataRate = StringValue ("HtMcs8");
+ datarate = 27;
+ }
+ else if (i == 49)
+ {
+ DataRate = StringValue ("HtMcs9");
+ datarate = 54;
+ }
+ else if (i == 50)
+ {
+ DataRate = StringValue ("HtMcs10");
+ datarate = 81;
+ }
+ else if (i == 51)
+ {
+ DataRate = StringValue ("HtMcs11");
+ datarate = 108;
+ }
+ else if (i == 52)
+ {
+ DataRate = StringValue ("HtMcs12");
+ datarate = 162;
+ }
+ else if (i == 53)
+ {
+ DataRate = StringValue ("HtMcs13");
+ datarate = 216;
+ }
+ else if (i == 54)
+ {
+ DataRate = StringValue ("HtMcs14");
+ datarate = 243;
+ }
+ else if (i == 55)
+ {
+ DataRate = StringValue ("HtMcs15");
+ datarate = 270;
+ }
+ else if (i == 56)
+ {
+ DataRate = StringValue ("HtMcs8");
+ datarate = 30;
+ }
+ else if (i == 57)
+ {
+ DataRate = StringValue ("HtMcs9");
+ datarate = 60;
+ }
+ else if (i == 58)
+ {
+ DataRate = StringValue ("HtMcs10");
+ datarate = 90;
+ }
+ else if (i == 59)
+ {
+ DataRate = StringValue ("HtMcs11");
+ datarate = 120;
+ }
+ else if (i == 60)
+ {
+ DataRate = StringValue ("HtMcs12");
+ datarate = 180;
+ }
+ else if (i == 61)
+ {
+ DataRate = StringValue ("HtMcs13");
+ datarate = 240;
+ }
+ else if (i == 62)
+ {
+ DataRate = StringValue ("HtMcs14");
+ datarate = 270;
+ }
+ else if (i == 63)
+ {
+ DataRate = StringValue ("HtMcs15");
+ datarate = 300;
+ }
+ else
+ {
+ NS_FATAL_ERROR ("Illegal index i " << i);
+ }
+
+ wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager","DataMode", DataRate,
+ "ControlMode", DataRate);
+
+ NetDeviceContainer staDevice;
+ NetDeviceContainer apDevice;
+
+ if (wifiType == "ns3::YansWifiPhy")
+ {
+ mac.SetType ("ns3::StaWifiMac",
+ "Ssid", SsidValue (ssid),
+ "ActiveProbing", BooleanValue (false));
+ staDevice = wifi.Install (phy, mac, wifiStaNode);
+ mac.SetType ("ns3::ApWifiMac",
+ "Ssid", SsidValue (ssid));
+ apDevice = wifi.Install (phy, mac, wifiApNode);
+
+ }
+ else if (wifiType == "ns3::SpectrumWifiPhy")
+ {
+ mac.SetType ("ns3::StaWifiMac",
+ "Ssid", SsidValue (ssid),
+ "ActiveProbing", BooleanValue (false));
+ staDevice = wifi.Install (spectrumPhy, mac, wifiStaNode);
+ mac.SetType ("ns3::ApWifiMac",
+ "Ssid", SsidValue (ssid));
+ apDevice = wifi.Install (spectrumPhy, mac, wifiApNode);
+ }
+
+ // Channel width must be set *after* installation because the attribute
+ // is overwritten by the ConfigureStandard method ()
+ Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/ChannelWidth", UintegerValue (channelWidth));
+
+ // mobility.
+ MobilityHelper mobility;
+ Ptr positionAlloc = CreateObject ();
+
+ positionAlloc->Add (Vector (0.0, 0.0, 0.0));
+ positionAlloc->Add (Vector (distance, 0.0, 0.0));
+ mobility.SetPositionAllocator (positionAlloc);
+
+ mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
+
+ mobility.Install (wifiApNode);
+ mobility.Install (wifiStaNode);
+
+ /* Internet stack*/
+ InternetStackHelper stack;
+ stack.Install (wifiApNode);
+ stack.Install (wifiStaNode);
+
+ Ipv4AddressHelper address;
+
+ address.SetBase ("192.168.1.0", "255.255.255.0");
+ Ipv4InterfaceContainer staNodeInterface;
+ Ipv4InterfaceContainer apNodeInterface;
+
+ staNodeInterface = address.Assign (staDevice);
+ apNodeInterface = address.Assign (apDevice);
+
+ /* Setting applications */
+ ApplicationContainer serverApp, sinkApp;
+ //UDP flow
+ UdpServerHelper myServer (9);
+ serverApp = myServer.Install (wifiStaNode.Get (0));
+ serverApp.Start (Seconds (0.0));
+ serverApp.Stop (Seconds (simulationTime + 1));
+
+ UdpClientHelper myClient (staNodeInterface.GetAddress (0), 9);
+ myClient.SetAttribute ("MaxPackets", UintegerValue (4294967295u));
+ myClient.SetAttribute ("Interval", TimeValue (Time ("0.00002"))); //packets/s
+ myClient.SetAttribute ("PacketSize", UintegerValue (payloadSize));
+
+ ApplicationContainer clientApp = myClient.Install (wifiApNode.Get (0));
+ clientApp.Start (Seconds (1.0));
+ clientApp.Stop (Seconds (simulationTime + 1));
+
+ if (enablePcap)
+ {
+ std::stringstream ss;
+ ss << "wifi-spectrum-saturation-example-" << i;
+ phy.EnablePcap (ss.str (), apDevice);
+ }
+
+ Simulator::Stop (Seconds (simulationTime + 1));
+ Simulator::Run ();
+ Simulator::Destroy ();
+
+ double throughput;
+ uint32_t totalPacketsThrough;
+ totalPacketsThrough = DynamicCast (serverApp.Get (0))->GetReceived ();
+ throughput = totalPacketsThrough * payloadSize * 8 / (simulationTime * 1000000.0); //Mbit/s
+ std::cout << std::setw (5) << i <<
+ std::setw (6) << (i % 8) + 8 * (i / 32) <<
+ std::setw (8) << channelWidth <<
+ std::setw (10) << datarate <<
+ std::setw (12) << throughput <<
+ std::setw (8) << totalPacketsThrough <<
+ std::endl;
+ }
+ return 0;
+}
diff --git a/examples/wireless/wscript b/examples/wireless/wscript
index 9d093e808e2..8459450db0f 100644
--- a/examples/wireless/wscript
+++ b/examples/wireless/wscript
@@ -91,3 +91,11 @@ def build(bld):
obj = bld.create_ns3_program('80211e-txop', ['internet', 'mobility', 'wifi', 'applications'])
obj.source = '80211e-txop.cc'
+ obj = bld.create_ns3_program('wifi-spectrum-per-example', ['internet', 'mobility', 'wifi', 'applications', 'spectrum'])
+ obj.source = 'wifi-spectrum-per-example.cc'
+
+ obj = bld.create_ns3_program('wifi-spectrum-per-interference', ['internet', 'mobility', 'wifi', 'applications', 'spectrum'])
+ obj.source = 'wifi-spectrum-per-interference.cc'
+
+ obj = bld.create_ns3_program('wifi-spectrum-saturation-example', ['internet', 'mobility', 'wifi', 'applications', 'spectrum'])
+ obj.source = 'wifi-spectrum-saturation-example.cc'
diff --git a/src/antenna/bindings/modulegen__gcc_ILP32.py b/src/antenna/bindings/modulegen__gcc_ILP32.py
index b5e5611c979..1a35dc17f41 100644
--- a/src/antenna/bindings/modulegen__gcc_ILP32.py
+++ b/src/antenna/bindings/modulegen__gcc_ILP32.py
@@ -667,6 +667,11 @@ def register_Ns3Object_methods(root_module, cls):
cls.add_method('Initialize',
'void',
[])
+ ## object.h (module 'core'): bool ns3::Object::IsInitialized() const [member function]
+ cls.add_method('IsInitialized',
+ 'bool',
+ [],
+ is_const=True)
## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
cls.add_constructor([param('ns3::Object const &', 'o')],
visibility='protected')
diff --git a/src/antenna/bindings/modulegen__gcc_LP64.py b/src/antenna/bindings/modulegen__gcc_LP64.py
index b5e5611c979..1a35dc17f41 100644
--- a/src/antenna/bindings/modulegen__gcc_LP64.py
+++ b/src/antenna/bindings/modulegen__gcc_LP64.py
@@ -667,6 +667,11 @@ def register_Ns3Object_methods(root_module, cls):
cls.add_method('Initialize',
'void',
[])
+ ## object.h (module 'core'): bool ns3::Object::IsInitialized() const [member function]
+ cls.add_method('IsInitialized',
+ 'bool',
+ [],
+ is_const=True)
## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
cls.add_constructor([param('ns3::Object const &', 'o')],
visibility='protected')
diff --git a/src/aodv/bindings/callbacks_list.py b/src/aodv/bindings/callbacks_list.py
index 810f9898de1..201a1d394e3 100644
--- a/src/aodv/bindings/callbacks_list.py
+++ b/src/aodv/bindings/callbacks_list.py
@@ -1,4 +1,5 @@
callback_classes = [
+ ['unsigned char', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['void', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['void', 'ns3::Ptr', 'ns3::Ipv4Header const&', 'ns3::Socket::SocketErrno', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
@@ -11,5 +12,4 @@
['void', 'ns3::Ptr', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['bool', 'ns3::Ptr', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['void', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'ns3::Address const&', 'ns3::Address const&', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
- ['unsigned char', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
]
diff --git a/src/aodv/bindings/modulegen__gcc_ILP32.py b/src/aodv/bindings/modulegen__gcc_ILP32.py
index d29edc99842..94c771fc2ce 100644
--- a/src/aodv/bindings/modulegen__gcc_ILP32.py
+++ b/src/aodv/bindings/modulegen__gcc_ILP32.py
@@ -236,6 +236,8 @@ def register_types(module):
module.add_enum('SocketErrno', ['ERROR_NOTERROR', 'ERROR_ISCONN', 'ERROR_NOTCONN', 'ERROR_MSGSIZE', 'ERROR_AGAIN', 'ERROR_SHUTDOWN', 'ERROR_OPNOTSUPP', 'ERROR_AFNOSUPPORT', 'ERROR_INVAL', 'ERROR_BADF', 'ERROR_NOROUTETOHOST', 'ERROR_NODEV', 'ERROR_ADDRNOTAVAIL', 'ERROR_ADDRINUSE', 'SOCKET_ERRNO_LAST'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::SocketType [enumeration]
module.add_enum('SocketType', ['NS3_SOCK_STREAM', 'NS3_SOCK_SEQPACKET', 'NS3_SOCK_DGRAM', 'NS3_SOCK_RAW'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
+ ## socket.h (module 'network'): ns3::Socket::SocketPriority [enumeration]
+ module.add_enum('SocketPriority', ['NS3_PRIO_BESTEFFORT', 'NS3_PRIO_FILLER', 'NS3_PRIO_BULK', 'NS3_PRIO_INTERACTIVE_BULK', 'NS3_PRIO_INTERACTIVE', 'NS3_PRIO_CONTROL'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::Ipv6MulticastFilterMode [enumeration]
module.add_enum('Ipv6MulticastFilterMode', ['INCLUDE', 'EXCLUDE'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::SocketIpTosTag [class]
@@ -246,6 +248,8 @@ def register_types(module):
module.add_class('SocketIpv6HopLimitTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketIpv6TclassTag [class]
module.add_class('SocketIpv6TclassTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
+ ## socket.h (module 'network'): ns3::SocketPriorityTag [class]
+ module.add_class('SocketPriorityTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketSetDontFragmentTag [class]
module.add_class('SocketSetDontFragmentTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## nstime.h (module 'core'): ns3::Time [class]
@@ -382,6 +386,8 @@ def register_types(module):
module.add_class('ParetoRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream'])
## net-device.h (module 'network'): ns3::QueueItem [class]
module.add_class('QueueItem', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >'])
+ ## net-device.h (module 'network'): ns3::QueueItem::Uint8Values [enumeration]
+ module.add_enum('Uint8Values', ['IP_DSFIELD'], outer_class=root_module['ns3::QueueItem'], import_from_module='ns.network')
## nstime.h (module 'core'): ns3::TimeValue [class]
module.add_class('TimeValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
## type-id.h (module 'core'): ns3::TypeIdChecker [class]
@@ -626,6 +632,7 @@ def register_methods(root_module):
register_Ns3SocketIpTtlTag_methods(root_module, root_module['ns3::SocketIpTtlTag'])
register_Ns3SocketIpv6HopLimitTag_methods(root_module, root_module['ns3::SocketIpv6HopLimitTag'])
register_Ns3SocketIpv6TclassTag_methods(root_module, root_module['ns3::SocketIpv6TclassTag'])
+ register_Ns3SocketPriorityTag_methods(root_module, root_module['ns3::SocketPriorityTag'])
register_Ns3SocketSetDontFragmentTag_methods(root_module, root_module['ns3::SocketSetDontFragmentTag'])
register_Ns3Time_methods(root_module, root_module['ns3::Time'])
register_Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::TraceSourceAccessor'])
@@ -1332,6 +1339,11 @@ def register_Ns3InetSocketAddress_methods(root_module, cls):
'uint16_t',
[],
is_const=True)
+ ## inet-socket-address.h (module 'network'): uint8_t ns3::InetSocketAddress::GetTos() const [member function]
+ cls.add_method('GetTos',
+ 'uint8_t',
+ [],
+ is_const=True)
## inet-socket-address.h (module 'network'): static bool ns3::InetSocketAddress::IsMatchingType(ns3::Address const & address) [member function]
cls.add_method('IsMatchingType',
'bool',
@@ -1345,6 +1357,10 @@ def register_Ns3InetSocketAddress_methods(root_module, cls):
cls.add_method('SetPort',
'void',
[param('uint16_t', 'port')])
+ ## inet-socket-address.h (module 'network'): void ns3::InetSocketAddress::SetTos(uint8_t tos) [member function]
+ cls.add_method('SetTos',
+ 'void',
+ [param('uint8_t', 'tos')])
return
def register_Ns3IntToType__0_methods(root_module, cls):
@@ -3262,6 +3278,11 @@ def register_Ns3Object_methods(root_module, cls):
cls.add_method('Initialize',
'void',
[])
+ ## object.h (module 'core'): bool ns3::Object::IsInitialized() const [member function]
+ cls.add_method('IsInitialized',
+ 'bool',
+ [],
+ is_const=True)
## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
cls.add_constructor([param('ns3::Object const &', 'o')],
visibility='protected')
@@ -4000,6 +4021,11 @@ def register_Ns3Socket_methods(root_module, cls):
'int',
[param('ns3::Address &', 'address')],
is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): uint8_t ns3::Socket::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
## socket.h (module 'network'): uint32_t ns3::Socket::GetRxAvailable() const [member function]
cls.add_method('GetRxAvailable',
'uint32_t',
@@ -4025,6 +4051,11 @@ def register_Ns3Socket_methods(root_module, cls):
'ns3::TypeId',
[],
is_static=True)
+ ## socket.h (module 'network'): static uint8_t ns3::Socket::IpTos2Priority(uint8_t ipTos) [member function]
+ cls.add_method('IpTos2Priority',
+ 'uint8_t',
+ [param('uint8_t', 'ipTos')],
+ is_static=True)
## socket.h (module 'network'): void ns3::Socket::Ipv6JoinGroup(ns3::Ipv6Address address, ns3::Socket::Ipv6MulticastFilterMode filterMode, std::vector > sourceAddresses) [member function]
cls.add_method('Ipv6JoinGroup',
'void',
@@ -4173,6 +4204,10 @@ def register_Ns3Socket_methods(root_module, cls):
cls.add_method('SetIpv6Tclass',
'void',
[param('int', 'ipTclass')])
+ ## socket.h (module 'network'): void ns3::Socket::SetPriority(uint8_t priority) [member function]
+ cls.add_method('SetPriority',
+ 'void',
+ [param('uint8_t', 'priority')])
## socket.h (module 'network'): void ns3::Socket::SetRecvCallback(ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> arg0) [member function]
cls.add_method('SetRecvCallback',
'void',
@@ -4200,11 +4235,6 @@ def register_Ns3Socket_methods(root_module, cls):
'void',
[],
visibility='protected', is_virtual=True)
- ## socket.h (module 'network'): bool ns3::Socket::IsManualIpTos() const [member function]
- cls.add_method('IsManualIpTos',
- 'bool',
- [],
- is_const=True, visibility='protected')
## socket.h (module 'network'): bool ns3::Socket::IsManualIpTtl() const [member function]
cls.add_method('IsManualIpTtl',
'bool',
@@ -4451,6 +4481,52 @@ def register_Ns3SocketIpv6TclassTag_methods(root_module, cls):
[param('uint8_t', 'tclass')])
return
+def register_Ns3SocketPriorityTag_methods(root_module, cls):
+ ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag(ns3::SocketPriorityTag const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::SocketPriorityTag const &', 'arg0')])
+ ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag() [constructor]
+ cls.add_constructor([])
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Deserialize(ns3::TagBuffer i) [member function]
+ cls.add_method('Deserialize',
+ 'void',
+ [param('ns3::TagBuffer', 'i')],
+ is_virtual=True)
+ ## socket.h (module 'network'): ns3::TypeId ns3::SocketPriorityTag::GetInstanceTypeId() const [member function]
+ cls.add_method('GetInstanceTypeId',
+ 'ns3::TypeId',
+ [],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): uint8_t ns3::SocketPriorityTag::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
+ ## socket.h (module 'network'): uint32_t ns3::SocketPriorityTag::GetSerializedSize() const [member function]
+ cls.add_method('GetSerializedSize',
+ 'uint32_t',
+ [],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): static ns3::TypeId ns3::SocketPriorityTag::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Print(std::ostream & os) const [member function]
+ cls.add_method('Print',
+ 'void',
+ [param('std::ostream &', 'os')],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Serialize(ns3::TagBuffer i) const [member function]
+ cls.add_method('Serialize',
+ 'void',
+ [param('ns3::TagBuffer', 'i')],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::SetPriority(uint8_t priority) [member function]
+ cls.add_method('SetPriority',
+ 'void',
+ [param('uint8_t', 'priority')])
+ return
+
def register_Ns3SocketSetDontFragmentTag_methods(root_module, cls):
## socket.h (module 'network'): ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag(ns3::SocketSetDontFragmentTag const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SocketSetDontFragmentTag const &', 'arg0')])
@@ -7281,11 +7357,6 @@ def register_Ns3NetDeviceQueue_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueue const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueue::NetDeviceQueue() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): bool ns3::NetDeviceQueue::HasWakeCallbackSet() const [member function]
- cls.add_method('HasWakeCallbackSet',
- 'bool',
- [],
- is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDeviceQueue::IsStopped() const [member function]
cls.add_method('IsStopped',
'bool',
@@ -7318,21 +7389,25 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueueInterface const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetSelectedQueue(ns3::Ptr item) const [member function]
- cls.add_method('GetSelectedQueue',
+ ## net-device.h (module 'network'): void ns3::NetDeviceQueueInterface::CreateTxQueues() [member function]
+ cls.add_method('CreateTxQueues',
+ 'void',
+ [])
+ ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetNTxQueues() const [member function]
+ cls.add_method('GetNTxQueues',
'uint8_t',
- [param('ns3::Ptr< ns3::QueueItem >', 'item')],
+ [],
+ is_const=True)
+ ## net-device.h (module 'network'): ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ns3::NetDeviceQueueInterface::GetSelectQueueCallback() const [member function]
+ cls.add_method('GetSelectQueueCallback',
+ 'ns3::Callback< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >',
+ [],
is_const=True)
## net-device.h (module 'network'): ns3::Ptr ns3::NetDeviceQueueInterface::GetTxQueue(uint8_t i) const [member function]
cls.add_method('GetTxQueue',
'ns3::Ptr< ns3::NetDeviceQueue >',
[param('uint8_t', 'i')],
is_const=True)
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetTxQueuesN() const [member function]
- cls.add_method('GetTxQueuesN',
- 'uint8_t',
- [],
- is_const=True)
## net-device.h (module 'network'): static ns3::TypeId ns3::NetDeviceQueueInterface::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
@@ -7825,6 +7900,11 @@ def register_Ns3QueueItem_methods(root_module, cls):
'uint32_t',
[],
is_const=True, is_virtual=True)
+ ## net-device.h (module 'network'): bool ns3::QueueItem::GetUint8Value(ns3::QueueItem::Uint8Values field, uint8_t & value) const [member function]
+ cls.add_method('GetUint8Value',
+ 'bool',
+ [param('ns3::QueueItem::Uint8Values', 'field'), param('uint8_t &', 'value')],
+ is_const=True, is_virtual=True)
## net-device.h (module 'network'): void ns3::QueueItem::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
diff --git a/src/aodv/bindings/modulegen__gcc_LP64.py b/src/aodv/bindings/modulegen__gcc_LP64.py
index d29edc99842..94c771fc2ce 100644
--- a/src/aodv/bindings/modulegen__gcc_LP64.py
+++ b/src/aodv/bindings/modulegen__gcc_LP64.py
@@ -236,6 +236,8 @@ def register_types(module):
module.add_enum('SocketErrno', ['ERROR_NOTERROR', 'ERROR_ISCONN', 'ERROR_NOTCONN', 'ERROR_MSGSIZE', 'ERROR_AGAIN', 'ERROR_SHUTDOWN', 'ERROR_OPNOTSUPP', 'ERROR_AFNOSUPPORT', 'ERROR_INVAL', 'ERROR_BADF', 'ERROR_NOROUTETOHOST', 'ERROR_NODEV', 'ERROR_ADDRNOTAVAIL', 'ERROR_ADDRINUSE', 'SOCKET_ERRNO_LAST'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::SocketType [enumeration]
module.add_enum('SocketType', ['NS3_SOCK_STREAM', 'NS3_SOCK_SEQPACKET', 'NS3_SOCK_DGRAM', 'NS3_SOCK_RAW'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
+ ## socket.h (module 'network'): ns3::Socket::SocketPriority [enumeration]
+ module.add_enum('SocketPriority', ['NS3_PRIO_BESTEFFORT', 'NS3_PRIO_FILLER', 'NS3_PRIO_BULK', 'NS3_PRIO_INTERACTIVE_BULK', 'NS3_PRIO_INTERACTIVE', 'NS3_PRIO_CONTROL'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::Ipv6MulticastFilterMode [enumeration]
module.add_enum('Ipv6MulticastFilterMode', ['INCLUDE', 'EXCLUDE'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::SocketIpTosTag [class]
@@ -246,6 +248,8 @@ def register_types(module):
module.add_class('SocketIpv6HopLimitTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketIpv6TclassTag [class]
module.add_class('SocketIpv6TclassTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
+ ## socket.h (module 'network'): ns3::SocketPriorityTag [class]
+ module.add_class('SocketPriorityTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketSetDontFragmentTag [class]
module.add_class('SocketSetDontFragmentTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## nstime.h (module 'core'): ns3::Time [class]
@@ -382,6 +386,8 @@ def register_types(module):
module.add_class('ParetoRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream'])
## net-device.h (module 'network'): ns3::QueueItem [class]
module.add_class('QueueItem', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >'])
+ ## net-device.h (module 'network'): ns3::QueueItem::Uint8Values [enumeration]
+ module.add_enum('Uint8Values', ['IP_DSFIELD'], outer_class=root_module['ns3::QueueItem'], import_from_module='ns.network')
## nstime.h (module 'core'): ns3::TimeValue [class]
module.add_class('TimeValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
## type-id.h (module 'core'): ns3::TypeIdChecker [class]
@@ -626,6 +632,7 @@ def register_methods(root_module):
register_Ns3SocketIpTtlTag_methods(root_module, root_module['ns3::SocketIpTtlTag'])
register_Ns3SocketIpv6HopLimitTag_methods(root_module, root_module['ns3::SocketIpv6HopLimitTag'])
register_Ns3SocketIpv6TclassTag_methods(root_module, root_module['ns3::SocketIpv6TclassTag'])
+ register_Ns3SocketPriorityTag_methods(root_module, root_module['ns3::SocketPriorityTag'])
register_Ns3SocketSetDontFragmentTag_methods(root_module, root_module['ns3::SocketSetDontFragmentTag'])
register_Ns3Time_methods(root_module, root_module['ns3::Time'])
register_Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::TraceSourceAccessor'])
@@ -1332,6 +1339,11 @@ def register_Ns3InetSocketAddress_methods(root_module, cls):
'uint16_t',
[],
is_const=True)
+ ## inet-socket-address.h (module 'network'): uint8_t ns3::InetSocketAddress::GetTos() const [member function]
+ cls.add_method('GetTos',
+ 'uint8_t',
+ [],
+ is_const=True)
## inet-socket-address.h (module 'network'): static bool ns3::InetSocketAddress::IsMatchingType(ns3::Address const & address) [member function]
cls.add_method('IsMatchingType',
'bool',
@@ -1345,6 +1357,10 @@ def register_Ns3InetSocketAddress_methods(root_module, cls):
cls.add_method('SetPort',
'void',
[param('uint16_t', 'port')])
+ ## inet-socket-address.h (module 'network'): void ns3::InetSocketAddress::SetTos(uint8_t tos) [member function]
+ cls.add_method('SetTos',
+ 'void',
+ [param('uint8_t', 'tos')])
return
def register_Ns3IntToType__0_methods(root_module, cls):
@@ -3262,6 +3278,11 @@ def register_Ns3Object_methods(root_module, cls):
cls.add_method('Initialize',
'void',
[])
+ ## object.h (module 'core'): bool ns3::Object::IsInitialized() const [member function]
+ cls.add_method('IsInitialized',
+ 'bool',
+ [],
+ is_const=True)
## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
cls.add_constructor([param('ns3::Object const &', 'o')],
visibility='protected')
@@ -4000,6 +4021,11 @@ def register_Ns3Socket_methods(root_module, cls):
'int',
[param('ns3::Address &', 'address')],
is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): uint8_t ns3::Socket::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
## socket.h (module 'network'): uint32_t ns3::Socket::GetRxAvailable() const [member function]
cls.add_method('GetRxAvailable',
'uint32_t',
@@ -4025,6 +4051,11 @@ def register_Ns3Socket_methods(root_module, cls):
'ns3::TypeId',
[],
is_static=True)
+ ## socket.h (module 'network'): static uint8_t ns3::Socket::IpTos2Priority(uint8_t ipTos) [member function]
+ cls.add_method('IpTos2Priority',
+ 'uint8_t',
+ [param('uint8_t', 'ipTos')],
+ is_static=True)
## socket.h (module 'network'): void ns3::Socket::Ipv6JoinGroup(ns3::Ipv6Address address, ns3::Socket::Ipv6MulticastFilterMode filterMode, std::vector > sourceAddresses) [member function]
cls.add_method('Ipv6JoinGroup',
'void',
@@ -4173,6 +4204,10 @@ def register_Ns3Socket_methods(root_module, cls):
cls.add_method('SetIpv6Tclass',
'void',
[param('int', 'ipTclass')])
+ ## socket.h (module 'network'): void ns3::Socket::SetPriority(uint8_t priority) [member function]
+ cls.add_method('SetPriority',
+ 'void',
+ [param('uint8_t', 'priority')])
## socket.h (module 'network'): void ns3::Socket::SetRecvCallback(ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> arg0) [member function]
cls.add_method('SetRecvCallback',
'void',
@@ -4200,11 +4235,6 @@ def register_Ns3Socket_methods(root_module, cls):
'void',
[],
visibility='protected', is_virtual=True)
- ## socket.h (module 'network'): bool ns3::Socket::IsManualIpTos() const [member function]
- cls.add_method('IsManualIpTos',
- 'bool',
- [],
- is_const=True, visibility='protected')
## socket.h (module 'network'): bool ns3::Socket::IsManualIpTtl() const [member function]
cls.add_method('IsManualIpTtl',
'bool',
@@ -4451,6 +4481,52 @@ def register_Ns3SocketIpv6TclassTag_methods(root_module, cls):
[param('uint8_t', 'tclass')])
return
+def register_Ns3SocketPriorityTag_methods(root_module, cls):
+ ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag(ns3::SocketPriorityTag const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::SocketPriorityTag const &', 'arg0')])
+ ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag() [constructor]
+ cls.add_constructor([])
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Deserialize(ns3::TagBuffer i) [member function]
+ cls.add_method('Deserialize',
+ 'void',
+ [param('ns3::TagBuffer', 'i')],
+ is_virtual=True)
+ ## socket.h (module 'network'): ns3::TypeId ns3::SocketPriorityTag::GetInstanceTypeId() const [member function]
+ cls.add_method('GetInstanceTypeId',
+ 'ns3::TypeId',
+ [],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): uint8_t ns3::SocketPriorityTag::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
+ ## socket.h (module 'network'): uint32_t ns3::SocketPriorityTag::GetSerializedSize() const [member function]
+ cls.add_method('GetSerializedSize',
+ 'uint32_t',
+ [],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): static ns3::TypeId ns3::SocketPriorityTag::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Print(std::ostream & os) const [member function]
+ cls.add_method('Print',
+ 'void',
+ [param('std::ostream &', 'os')],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Serialize(ns3::TagBuffer i) const [member function]
+ cls.add_method('Serialize',
+ 'void',
+ [param('ns3::TagBuffer', 'i')],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::SetPriority(uint8_t priority) [member function]
+ cls.add_method('SetPriority',
+ 'void',
+ [param('uint8_t', 'priority')])
+ return
+
def register_Ns3SocketSetDontFragmentTag_methods(root_module, cls):
## socket.h (module 'network'): ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag(ns3::SocketSetDontFragmentTag const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SocketSetDontFragmentTag const &', 'arg0')])
@@ -7281,11 +7357,6 @@ def register_Ns3NetDeviceQueue_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueue const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueue::NetDeviceQueue() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): bool ns3::NetDeviceQueue::HasWakeCallbackSet() const [member function]
- cls.add_method('HasWakeCallbackSet',
- 'bool',
- [],
- is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDeviceQueue::IsStopped() const [member function]
cls.add_method('IsStopped',
'bool',
@@ -7318,21 +7389,25 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueueInterface const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetSelectedQueue(ns3::Ptr item) const [member function]
- cls.add_method('GetSelectedQueue',
+ ## net-device.h (module 'network'): void ns3::NetDeviceQueueInterface::CreateTxQueues() [member function]
+ cls.add_method('CreateTxQueues',
+ 'void',
+ [])
+ ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetNTxQueues() const [member function]
+ cls.add_method('GetNTxQueues',
'uint8_t',
- [param('ns3::Ptr< ns3::QueueItem >', 'item')],
+ [],
+ is_const=True)
+ ## net-device.h (module 'network'): ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ns3::NetDeviceQueueInterface::GetSelectQueueCallback() const [member function]
+ cls.add_method('GetSelectQueueCallback',
+ 'ns3::Callback< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >',
+ [],
is_const=True)
## net-device.h (module 'network'): ns3::Ptr ns3::NetDeviceQueueInterface::GetTxQueue(uint8_t i) const [member function]
cls.add_method('GetTxQueue',
'ns3::Ptr< ns3::NetDeviceQueue >',
[param('uint8_t', 'i')],
is_const=True)
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetTxQueuesN() const [member function]
- cls.add_method('GetTxQueuesN',
- 'uint8_t',
- [],
- is_const=True)
## net-device.h (module 'network'): static ns3::TypeId ns3::NetDeviceQueueInterface::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
@@ -7825,6 +7900,11 @@ def register_Ns3QueueItem_methods(root_module, cls):
'uint32_t',
[],
is_const=True, is_virtual=True)
+ ## net-device.h (module 'network'): bool ns3::QueueItem::GetUint8Value(ns3::QueueItem::Uint8Values field, uint8_t & value) const [member function]
+ cls.add_method('GetUint8Value',
+ 'bool',
+ [param('ns3::QueueItem::Uint8Values', 'field'), param('uint8_t &', 'value')],
+ is_const=True, is_virtual=True)
## net-device.h (module 'network'): void ns3::QueueItem::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
diff --git a/src/applications/bindings/modulegen__gcc_ILP32.py b/src/applications/bindings/modulegen__gcc_ILP32.py
index a511a8478e7..c79f6de126d 100644
--- a/src/applications/bindings/modulegen__gcc_ILP32.py
+++ b/src/applications/bindings/modulegen__gcc_ILP32.py
@@ -290,6 +290,8 @@ def register_types(module):
module.add_enum('SocketErrno', ['ERROR_NOTERROR', 'ERROR_ISCONN', 'ERROR_NOTCONN', 'ERROR_MSGSIZE', 'ERROR_AGAIN', 'ERROR_SHUTDOWN', 'ERROR_OPNOTSUPP', 'ERROR_AFNOSUPPORT', 'ERROR_INVAL', 'ERROR_BADF', 'ERROR_NOROUTETOHOST', 'ERROR_NODEV', 'ERROR_ADDRNOTAVAIL', 'ERROR_ADDRINUSE', 'SOCKET_ERRNO_LAST'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::SocketType [enumeration]
module.add_enum('SocketType', ['NS3_SOCK_STREAM', 'NS3_SOCK_SEQPACKET', 'NS3_SOCK_DGRAM', 'NS3_SOCK_RAW'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
+ ## socket.h (module 'network'): ns3::Socket::SocketPriority [enumeration]
+ module.add_enum('SocketPriority', ['NS3_PRIO_BESTEFFORT', 'NS3_PRIO_FILLER', 'NS3_PRIO_BULK', 'NS3_PRIO_INTERACTIVE_BULK', 'NS3_PRIO_INTERACTIVE', 'NS3_PRIO_CONTROL'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::Ipv6MulticastFilterMode [enumeration]
module.add_enum('Ipv6MulticastFilterMode', ['INCLUDE', 'EXCLUDE'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket-factory.h (module 'network'): ns3::SocketFactory [class]
@@ -302,6 +304,8 @@ def register_types(module):
module.add_class('SocketIpv6HopLimitTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketIpv6TclassTag [class]
module.add_class('SocketIpv6TclassTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
+ ## socket.h (module 'network'): ns3::SocketPriorityTag [class]
+ module.add_class('SocketPriorityTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketSetDontFragmentTag [class]
module.add_class('SocketSetDontFragmentTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## nstime.h (module 'core'): ns3::Time [class]
@@ -480,6 +484,8 @@ def register_types(module):
module.add_class('Probe', import_from_module='ns.stats', parent=root_module['ns3::DataCollectionObject'])
## net-device.h (module 'network'): ns3::QueueItem [class]
module.add_class('QueueItem', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >'])
+ ## net-device.h (module 'network'): ns3::QueueItem::Uint8Values [enumeration]
+ module.add_enum('Uint8Values', ['IP_DSFIELD'], outer_class=root_module['ns3::QueueItem'], import_from_module='ns.network')
## error-model.h (module 'network'): ns3::RateErrorModel [class]
module.add_class('RateErrorModel', import_from_module='ns.network', parent=root_module['ns3::ErrorModel'])
## error-model.h (module 'network'): ns3::RateErrorModel::ErrorUnit [enumeration]
@@ -772,6 +778,7 @@ def register_methods(root_module):
register_Ns3SocketIpTtlTag_methods(root_module, root_module['ns3::SocketIpTtlTag'])
register_Ns3SocketIpv6HopLimitTag_methods(root_module, root_module['ns3::SocketIpv6HopLimitTag'])
register_Ns3SocketIpv6TclassTag_methods(root_module, root_module['ns3::SocketIpv6TclassTag'])
+ register_Ns3SocketPriorityTag_methods(root_module, root_module['ns3::SocketPriorityTag'])
register_Ns3SocketSetDontFragmentTag_methods(root_module, root_module['ns3::SocketSetDontFragmentTag'])
register_Ns3Time_methods(root_module, root_module['ns3::Time'])
register_Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::TraceSourceAccessor'])
@@ -1862,6 +1869,11 @@ def register_Ns3InetSocketAddress_methods(root_module, cls):
'uint16_t',
[],
is_const=True)
+ ## inet-socket-address.h (module 'network'): uint8_t ns3::InetSocketAddress::GetTos() const [member function]
+ cls.add_method('GetTos',
+ 'uint8_t',
+ [],
+ is_const=True)
## inet-socket-address.h (module 'network'): static bool ns3::InetSocketAddress::IsMatchingType(ns3::Address const & address) [member function]
cls.add_method('IsMatchingType',
'bool',
@@ -1875,6 +1887,10 @@ def register_Ns3InetSocketAddress_methods(root_module, cls):
cls.add_method('SetPort',
'void',
[param('uint16_t', 'port')])
+ ## inet-socket-address.h (module 'network'): void ns3::InetSocketAddress::SetTos(uint8_t tos) [member function]
+ cls.add_method('SetTos',
+ 'void',
+ [param('uint8_t', 'tos')])
return
def register_Ns3Ipv4Address_methods(root_module, cls):
@@ -4418,6 +4434,11 @@ def register_Ns3Object_methods(root_module, cls):
cls.add_method('Initialize',
'void',
[])
+ ## object.h (module 'core'): bool ns3::Object::IsInitialized() const [member function]
+ cls.add_method('IsInitialized',
+ 'bool',
+ [],
+ is_const=True)
## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
cls.add_constructor([param('ns3::Object const &', 'o')],
visibility='protected')
@@ -5417,6 +5438,11 @@ def register_Ns3Socket_methods(root_module, cls):
'int',
[param('ns3::Address &', 'address')],
is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): uint8_t ns3::Socket::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
## socket.h (module 'network'): uint32_t ns3::Socket::GetRxAvailable() const [member function]
cls.add_method('GetRxAvailable',
'uint32_t',
@@ -5442,6 +5468,11 @@ def register_Ns3Socket_methods(root_module, cls):
'ns3::TypeId',
[],
is_static=True)
+ ## socket.h (module 'network'): static uint8_t ns3::Socket::IpTos2Priority(uint8_t ipTos) [member function]
+ cls.add_method('IpTos2Priority',
+ 'uint8_t',
+ [param('uint8_t', 'ipTos')],
+ is_static=True)
## socket.h (module 'network'): void ns3::Socket::Ipv6JoinGroup(ns3::Ipv6Address address, ns3::Socket::Ipv6MulticastFilterMode filterMode, std::vector > sourceAddresses) [member function]
cls.add_method('Ipv6JoinGroup',
'void',
@@ -5590,6 +5621,10 @@ def register_Ns3Socket_methods(root_module, cls):
cls.add_method('SetIpv6Tclass',
'void',
[param('int', 'ipTclass')])
+ ## socket.h (module 'network'): void ns3::Socket::SetPriority(uint8_t priority) [member function]
+ cls.add_method('SetPriority',
+ 'void',
+ [param('uint8_t', 'priority')])
## socket.h (module 'network'): void ns3::Socket::SetRecvCallback(ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> arg0) [member function]
cls.add_method('SetRecvCallback',
'void',
@@ -5617,11 +5652,6 @@ def register_Ns3Socket_methods(root_module, cls):
'void',
[],
visibility='protected', is_virtual=True)
- ## socket.h (module 'network'): bool ns3::Socket::IsManualIpTos() const [member function]
- cls.add_method('IsManualIpTos',
- 'bool',
- [],
- is_const=True, visibility='protected')
## socket.h (module 'network'): bool ns3::Socket::IsManualIpTtl() const [member function]
cls.add_method('IsManualIpTtl',
'bool',
@@ -5885,6 +5915,52 @@ def register_Ns3SocketIpv6TclassTag_methods(root_module, cls):
[param('uint8_t', 'tclass')])
return
+def register_Ns3SocketPriorityTag_methods(root_module, cls):
+ ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag(ns3::SocketPriorityTag const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::SocketPriorityTag const &', 'arg0')])
+ ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag() [constructor]
+ cls.add_constructor([])
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Deserialize(ns3::TagBuffer i) [member function]
+ cls.add_method('Deserialize',
+ 'void',
+ [param('ns3::TagBuffer', 'i')],
+ is_virtual=True)
+ ## socket.h (module 'network'): ns3::TypeId ns3::SocketPriorityTag::GetInstanceTypeId() const [member function]
+ cls.add_method('GetInstanceTypeId',
+ 'ns3::TypeId',
+ [],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): uint8_t ns3::SocketPriorityTag::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
+ ## socket.h (module 'network'): uint32_t ns3::SocketPriorityTag::GetSerializedSize() const [member function]
+ cls.add_method('GetSerializedSize',
+ 'uint32_t',
+ [],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): static ns3::TypeId ns3::SocketPriorityTag::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Print(std::ostream & os) const [member function]
+ cls.add_method('Print',
+ 'void',
+ [param('std::ostream &', 'os')],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Serialize(ns3::TagBuffer i) const [member function]
+ cls.add_method('Serialize',
+ 'void',
+ [param('ns3::TagBuffer', 'i')],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::SetPriority(uint8_t priority) [member function]
+ cls.add_method('SetPriority',
+ 'void',
+ [param('uint8_t', 'priority')])
+ return
+
def register_Ns3SocketSetDontFragmentTag_methods(root_module, cls):
## socket.h (module 'network'): ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag(ns3::SocketSetDontFragmentTag const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SocketSetDontFragmentTag const &', 'arg0')])
@@ -8031,11 +8107,6 @@ def register_Ns3NetDeviceQueue_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueue const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueue::NetDeviceQueue() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): bool ns3::NetDeviceQueue::HasWakeCallbackSet() const [member function]
- cls.add_method('HasWakeCallbackSet',
- 'bool',
- [],
- is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDeviceQueue::IsStopped() const [member function]
cls.add_method('IsStopped',
'bool',
@@ -8068,21 +8139,25 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueueInterface const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetSelectedQueue(ns3::Ptr item) const [member function]
- cls.add_method('GetSelectedQueue',
+ ## net-device.h (module 'network'): void ns3::NetDeviceQueueInterface::CreateTxQueues() [member function]
+ cls.add_method('CreateTxQueues',
+ 'void',
+ [])
+ ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetNTxQueues() const [member function]
+ cls.add_method('GetNTxQueues',
'uint8_t',
- [param('ns3::Ptr< ns3::QueueItem >', 'item')],
+ [],
+ is_const=True)
+ ## net-device.h (module 'network'): ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ns3::NetDeviceQueueInterface::GetSelectQueueCallback() const [member function]
+ cls.add_method('GetSelectQueueCallback',
+ 'ns3::Callback< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >',
+ [],
is_const=True)
## net-device.h (module 'network'): ns3::Ptr ns3::NetDeviceQueueInterface::GetTxQueue(uint8_t i) const [member function]
cls.add_method('GetTxQueue',
'ns3::Ptr< ns3::NetDeviceQueue >',
[param('uint8_t', 'i')],
is_const=True)
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetTxQueuesN() const [member function]
- cls.add_method('GetTxQueuesN',
- 'uint8_t',
- [],
- is_const=True)
## net-device.h (module 'network'): static ns3::TypeId ns3::NetDeviceQueueInterface::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
@@ -8756,6 +8831,11 @@ def register_Ns3PacketSocketClient_methods(root_module, cls):
cls.add_constructor([param('ns3::PacketSocketClient const &', 'arg0')])
## packet-socket-client.h (module 'network'): ns3::PacketSocketClient::PacketSocketClient() [constructor]
cls.add_constructor([])
+ ## packet-socket-client.h (module 'network'): uint8_t ns3::PacketSocketClient::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
## packet-socket-client.h (module 'network'): static ns3::TypeId ns3::PacketSocketClient::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
@@ -9899,6 +9979,11 @@ def register_Ns3QueueItem_methods(root_module, cls):
'uint32_t',
[],
is_const=True, is_virtual=True)
+ ## net-device.h (module 'network'): bool ns3::QueueItem::GetUint8Value(ns3::QueueItem::Uint8Values field, uint8_t & value) const [member function]
+ cls.add_method('GetUint8Value',
+ 'bool',
+ [param('ns3::QueueItem::Uint8Values', 'field'), param('uint8_t &', 'value')],
+ is_const=True, is_virtual=True)
## net-device.h (module 'network'): void ns3::QueueItem::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
diff --git a/src/applications/bindings/modulegen__gcc_LP64.py b/src/applications/bindings/modulegen__gcc_LP64.py
index a511a8478e7..c79f6de126d 100644
--- a/src/applications/bindings/modulegen__gcc_LP64.py
+++ b/src/applications/bindings/modulegen__gcc_LP64.py
@@ -290,6 +290,8 @@ def register_types(module):
module.add_enum('SocketErrno', ['ERROR_NOTERROR', 'ERROR_ISCONN', 'ERROR_NOTCONN', 'ERROR_MSGSIZE', 'ERROR_AGAIN', 'ERROR_SHUTDOWN', 'ERROR_OPNOTSUPP', 'ERROR_AFNOSUPPORT', 'ERROR_INVAL', 'ERROR_BADF', 'ERROR_NOROUTETOHOST', 'ERROR_NODEV', 'ERROR_ADDRNOTAVAIL', 'ERROR_ADDRINUSE', 'SOCKET_ERRNO_LAST'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::SocketType [enumeration]
module.add_enum('SocketType', ['NS3_SOCK_STREAM', 'NS3_SOCK_SEQPACKET', 'NS3_SOCK_DGRAM', 'NS3_SOCK_RAW'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
+ ## socket.h (module 'network'): ns3::Socket::SocketPriority [enumeration]
+ module.add_enum('SocketPriority', ['NS3_PRIO_BESTEFFORT', 'NS3_PRIO_FILLER', 'NS3_PRIO_BULK', 'NS3_PRIO_INTERACTIVE_BULK', 'NS3_PRIO_INTERACTIVE', 'NS3_PRIO_CONTROL'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::Ipv6MulticastFilterMode [enumeration]
module.add_enum('Ipv6MulticastFilterMode', ['INCLUDE', 'EXCLUDE'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket-factory.h (module 'network'): ns3::SocketFactory [class]
@@ -302,6 +304,8 @@ def register_types(module):
module.add_class('SocketIpv6HopLimitTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketIpv6TclassTag [class]
module.add_class('SocketIpv6TclassTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
+ ## socket.h (module 'network'): ns3::SocketPriorityTag [class]
+ module.add_class('SocketPriorityTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketSetDontFragmentTag [class]
module.add_class('SocketSetDontFragmentTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## nstime.h (module 'core'): ns3::Time [class]
@@ -480,6 +484,8 @@ def register_types(module):
module.add_class('Probe', import_from_module='ns.stats', parent=root_module['ns3::DataCollectionObject'])
## net-device.h (module 'network'): ns3::QueueItem [class]
module.add_class('QueueItem', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >'])
+ ## net-device.h (module 'network'): ns3::QueueItem::Uint8Values [enumeration]
+ module.add_enum('Uint8Values', ['IP_DSFIELD'], outer_class=root_module['ns3::QueueItem'], import_from_module='ns.network')
## error-model.h (module 'network'): ns3::RateErrorModel [class]
module.add_class('RateErrorModel', import_from_module='ns.network', parent=root_module['ns3::ErrorModel'])
## error-model.h (module 'network'): ns3::RateErrorModel::ErrorUnit [enumeration]
@@ -772,6 +778,7 @@ def register_methods(root_module):
register_Ns3SocketIpTtlTag_methods(root_module, root_module['ns3::SocketIpTtlTag'])
register_Ns3SocketIpv6HopLimitTag_methods(root_module, root_module['ns3::SocketIpv6HopLimitTag'])
register_Ns3SocketIpv6TclassTag_methods(root_module, root_module['ns3::SocketIpv6TclassTag'])
+ register_Ns3SocketPriorityTag_methods(root_module, root_module['ns3::SocketPriorityTag'])
register_Ns3SocketSetDontFragmentTag_methods(root_module, root_module['ns3::SocketSetDontFragmentTag'])
register_Ns3Time_methods(root_module, root_module['ns3::Time'])
register_Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::TraceSourceAccessor'])
@@ -1862,6 +1869,11 @@ def register_Ns3InetSocketAddress_methods(root_module, cls):
'uint16_t',
[],
is_const=True)
+ ## inet-socket-address.h (module 'network'): uint8_t ns3::InetSocketAddress::GetTos() const [member function]
+ cls.add_method('GetTos',
+ 'uint8_t',
+ [],
+ is_const=True)
## inet-socket-address.h (module 'network'): static bool ns3::InetSocketAddress::IsMatchingType(ns3::Address const & address) [member function]
cls.add_method('IsMatchingType',
'bool',
@@ -1875,6 +1887,10 @@ def register_Ns3InetSocketAddress_methods(root_module, cls):
cls.add_method('SetPort',
'void',
[param('uint16_t', 'port')])
+ ## inet-socket-address.h (module 'network'): void ns3::InetSocketAddress::SetTos(uint8_t tos) [member function]
+ cls.add_method('SetTos',
+ 'void',
+ [param('uint8_t', 'tos')])
return
def register_Ns3Ipv4Address_methods(root_module, cls):
@@ -4418,6 +4434,11 @@ def register_Ns3Object_methods(root_module, cls):
cls.add_method('Initialize',
'void',
[])
+ ## object.h (module 'core'): bool ns3::Object::IsInitialized() const [member function]
+ cls.add_method('IsInitialized',
+ 'bool',
+ [],
+ is_const=True)
## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
cls.add_constructor([param('ns3::Object const &', 'o')],
visibility='protected')
@@ -5417,6 +5438,11 @@ def register_Ns3Socket_methods(root_module, cls):
'int',
[param('ns3::Address &', 'address')],
is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): uint8_t ns3::Socket::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
## socket.h (module 'network'): uint32_t ns3::Socket::GetRxAvailable() const [member function]
cls.add_method('GetRxAvailable',
'uint32_t',
@@ -5442,6 +5468,11 @@ def register_Ns3Socket_methods(root_module, cls):
'ns3::TypeId',
[],
is_static=True)
+ ## socket.h (module 'network'): static uint8_t ns3::Socket::IpTos2Priority(uint8_t ipTos) [member function]
+ cls.add_method('IpTos2Priority',
+ 'uint8_t',
+ [param('uint8_t', 'ipTos')],
+ is_static=True)
## socket.h (module 'network'): void ns3::Socket::Ipv6JoinGroup(ns3::Ipv6Address address, ns3::Socket::Ipv6MulticastFilterMode filterMode, std::vector > sourceAddresses) [member function]
cls.add_method('Ipv6JoinGroup',
'void',
@@ -5590,6 +5621,10 @@ def register_Ns3Socket_methods(root_module, cls):
cls.add_method('SetIpv6Tclass',
'void',
[param('int', 'ipTclass')])
+ ## socket.h (module 'network'): void ns3::Socket::SetPriority(uint8_t priority) [member function]
+ cls.add_method('SetPriority',
+ 'void',
+ [param('uint8_t', 'priority')])
## socket.h (module 'network'): void ns3::Socket::SetRecvCallback(ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> arg0) [member function]
cls.add_method('SetRecvCallback',
'void',
@@ -5617,11 +5652,6 @@ def register_Ns3Socket_methods(root_module, cls):
'void',
[],
visibility='protected', is_virtual=True)
- ## socket.h (module 'network'): bool ns3::Socket::IsManualIpTos() const [member function]
- cls.add_method('IsManualIpTos',
- 'bool',
- [],
- is_const=True, visibility='protected')
## socket.h (module 'network'): bool ns3::Socket::IsManualIpTtl() const [member function]
cls.add_method('IsManualIpTtl',
'bool',
@@ -5885,6 +5915,52 @@ def register_Ns3SocketIpv6TclassTag_methods(root_module, cls):
[param('uint8_t', 'tclass')])
return
+def register_Ns3SocketPriorityTag_methods(root_module, cls):
+ ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag(ns3::SocketPriorityTag const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::SocketPriorityTag const &', 'arg0')])
+ ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag() [constructor]
+ cls.add_constructor([])
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Deserialize(ns3::TagBuffer i) [member function]
+ cls.add_method('Deserialize',
+ 'void',
+ [param('ns3::TagBuffer', 'i')],
+ is_virtual=True)
+ ## socket.h (module 'network'): ns3::TypeId ns3::SocketPriorityTag::GetInstanceTypeId() const [member function]
+ cls.add_method('GetInstanceTypeId',
+ 'ns3::TypeId',
+ [],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): uint8_t ns3::SocketPriorityTag::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
+ ## socket.h (module 'network'): uint32_t ns3::SocketPriorityTag::GetSerializedSize() const [member function]
+ cls.add_method('GetSerializedSize',
+ 'uint32_t',
+ [],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): static ns3::TypeId ns3::SocketPriorityTag::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Print(std::ostream & os) const [member function]
+ cls.add_method('Print',
+ 'void',
+ [param('std::ostream &', 'os')],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Serialize(ns3::TagBuffer i) const [member function]
+ cls.add_method('Serialize',
+ 'void',
+ [param('ns3::TagBuffer', 'i')],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::SetPriority(uint8_t priority) [member function]
+ cls.add_method('SetPriority',
+ 'void',
+ [param('uint8_t', 'priority')])
+ return
+
def register_Ns3SocketSetDontFragmentTag_methods(root_module, cls):
## socket.h (module 'network'): ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag(ns3::SocketSetDontFragmentTag const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SocketSetDontFragmentTag const &', 'arg0')])
@@ -8031,11 +8107,6 @@ def register_Ns3NetDeviceQueue_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueue const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueue::NetDeviceQueue() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): bool ns3::NetDeviceQueue::HasWakeCallbackSet() const [member function]
- cls.add_method('HasWakeCallbackSet',
- 'bool',
- [],
- is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDeviceQueue::IsStopped() const [member function]
cls.add_method('IsStopped',
'bool',
@@ -8068,21 +8139,25 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueueInterface const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetSelectedQueue(ns3::Ptr item) const [member function]
- cls.add_method('GetSelectedQueue',
+ ## net-device.h (module 'network'): void ns3::NetDeviceQueueInterface::CreateTxQueues() [member function]
+ cls.add_method('CreateTxQueues',
+ 'void',
+ [])
+ ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetNTxQueues() const [member function]
+ cls.add_method('GetNTxQueues',
'uint8_t',
- [param('ns3::Ptr< ns3::QueueItem >', 'item')],
+ [],
+ is_const=True)
+ ## net-device.h (module 'network'): ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ns3::NetDeviceQueueInterface::GetSelectQueueCallback() const [member function]
+ cls.add_method('GetSelectQueueCallback',
+ 'ns3::Callback< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >',
+ [],
is_const=True)
## net-device.h (module 'network'): ns3::Ptr ns3::NetDeviceQueueInterface::GetTxQueue(uint8_t i) const [member function]
cls.add_method('GetTxQueue',
'ns3::Ptr< ns3::NetDeviceQueue >',
[param('uint8_t', 'i')],
is_const=True)
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetTxQueuesN() const [member function]
- cls.add_method('GetTxQueuesN',
- 'uint8_t',
- [],
- is_const=True)
## net-device.h (module 'network'): static ns3::TypeId ns3::NetDeviceQueueInterface::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
@@ -8756,6 +8831,11 @@ def register_Ns3PacketSocketClient_methods(root_module, cls):
cls.add_constructor([param('ns3::PacketSocketClient const &', 'arg0')])
## packet-socket-client.h (module 'network'): ns3::PacketSocketClient::PacketSocketClient() [constructor]
cls.add_constructor([])
+ ## packet-socket-client.h (module 'network'): uint8_t ns3::PacketSocketClient::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
## packet-socket-client.h (module 'network'): static ns3::TypeId ns3::PacketSocketClient::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
@@ -9899,6 +9979,11 @@ def register_Ns3QueueItem_methods(root_module, cls):
'uint32_t',
[],
is_const=True, is_virtual=True)
+ ## net-device.h (module 'network'): bool ns3::QueueItem::GetUint8Value(ns3::QueueItem::Uint8Values field, uint8_t & value) const [member function]
+ cls.add_method('GetUint8Value',
+ 'bool',
+ [param('ns3::QueueItem::Uint8Values', 'field'), param('uint8_t &', 'value')],
+ is_const=True, is_virtual=True)
## net-device.h (module 'network'): void ns3::QueueItem::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
diff --git a/src/bridge/bindings/modulegen__gcc_ILP32.py b/src/bridge/bindings/modulegen__gcc_ILP32.py
index a0bf46ea3fd..94c15da4cac 100644
--- a/src/bridge/bindings/modulegen__gcc_ILP32.py
+++ b/src/bridge/bindings/modulegen__gcc_ILP32.py
@@ -156,6 +156,8 @@ def register_types(module):
module.add_class('ObjectFactoryValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
## net-device.h (module 'network'): ns3::QueueItem [class]
module.add_class('QueueItem', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >'])
+ ## net-device.h (module 'network'): ns3::QueueItem::Uint8Values [enumeration]
+ module.add_enum('Uint8Values', ['IP_DSFIELD'], outer_class=root_module['ns3::QueueItem'], import_from_module='ns.network')
## nstime.h (module 'core'): ns3::TimeValue [class]
module.add_class('TimeValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
## type-id.h (module 'core'): ns3::TypeIdChecker [class]
@@ -1532,6 +1534,11 @@ def register_Ns3Object_methods(root_module, cls):
cls.add_method('Initialize',
'void',
[])
+ ## object.h (module 'core'): bool ns3::Object::IsInitialized() const [member function]
+ cls.add_method('IsInitialized',
+ 'bool',
+ [],
+ is_const=True)
## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
cls.add_constructor([param('ns3::Object const &', 'o')],
visibility='protected')
@@ -2423,11 +2430,6 @@ def register_Ns3NetDeviceQueue_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueue const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueue::NetDeviceQueue() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): bool ns3::NetDeviceQueue::HasWakeCallbackSet() const [member function]
- cls.add_method('HasWakeCallbackSet',
- 'bool',
- [],
- is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDeviceQueue::IsStopped() const [member function]
cls.add_method('IsStopped',
'bool',
@@ -2460,21 +2462,25 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueueInterface const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetSelectedQueue(ns3::Ptr item) const [member function]
- cls.add_method('GetSelectedQueue',
+ ## net-device.h (module 'network'): void ns3::NetDeviceQueueInterface::CreateTxQueues() [member function]
+ cls.add_method('CreateTxQueues',
+ 'void',
+ [])
+ ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetNTxQueues() const [member function]
+ cls.add_method('GetNTxQueues',
'uint8_t',
- [param('ns3::Ptr< ns3::QueueItem >', 'item')],
+ [],
+ is_const=True)
+ ## net-device.h (module 'network'): ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ns3::NetDeviceQueueInterface::GetSelectQueueCallback() const [member function]
+ cls.add_method('GetSelectQueueCallback',
+ 'ns3::Callback< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >',
+ [],
is_const=True)
## net-device.h (module 'network'): ns3::Ptr ns3::NetDeviceQueueInterface::GetTxQueue(uint8_t i) const [member function]
cls.add_method('GetTxQueue',
'ns3::Ptr< ns3::NetDeviceQueue >',
[param('uint8_t', 'i')],
is_const=True)
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetTxQueuesN() const [member function]
- cls.add_method('GetTxQueuesN',
- 'uint8_t',
- [],
- is_const=True)
## net-device.h (module 'network'): static ns3::TypeId ns3::NetDeviceQueueInterface::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
@@ -2549,6 +2555,11 @@ def register_Ns3QueueItem_methods(root_module, cls):
'uint32_t',
[],
is_const=True, is_virtual=True)
+ ## net-device.h (module 'network'): bool ns3::QueueItem::GetUint8Value(ns3::QueueItem::Uint8Values field, uint8_t & value) const [member function]
+ cls.add_method('GetUint8Value',
+ 'bool',
+ [param('ns3::QueueItem::Uint8Values', 'field'), param('uint8_t &', 'value')],
+ is_const=True, is_virtual=True)
## net-device.h (module 'network'): void ns3::QueueItem::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
diff --git a/src/bridge/bindings/modulegen__gcc_LP64.py b/src/bridge/bindings/modulegen__gcc_LP64.py
index a0bf46ea3fd..94c15da4cac 100644
--- a/src/bridge/bindings/modulegen__gcc_LP64.py
+++ b/src/bridge/bindings/modulegen__gcc_LP64.py
@@ -156,6 +156,8 @@ def register_types(module):
module.add_class('ObjectFactoryValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
## net-device.h (module 'network'): ns3::QueueItem [class]
module.add_class('QueueItem', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >'])
+ ## net-device.h (module 'network'): ns3::QueueItem::Uint8Values [enumeration]
+ module.add_enum('Uint8Values', ['IP_DSFIELD'], outer_class=root_module['ns3::QueueItem'], import_from_module='ns.network')
## nstime.h (module 'core'): ns3::TimeValue [class]
module.add_class('TimeValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
## type-id.h (module 'core'): ns3::TypeIdChecker [class]
@@ -1532,6 +1534,11 @@ def register_Ns3Object_methods(root_module, cls):
cls.add_method('Initialize',
'void',
[])
+ ## object.h (module 'core'): bool ns3::Object::IsInitialized() const [member function]
+ cls.add_method('IsInitialized',
+ 'bool',
+ [],
+ is_const=True)
## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
cls.add_constructor([param('ns3::Object const &', 'o')],
visibility='protected')
@@ -2423,11 +2430,6 @@ def register_Ns3NetDeviceQueue_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueue const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueue::NetDeviceQueue() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): bool ns3::NetDeviceQueue::HasWakeCallbackSet() const [member function]
- cls.add_method('HasWakeCallbackSet',
- 'bool',
- [],
- is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDeviceQueue::IsStopped() const [member function]
cls.add_method('IsStopped',
'bool',
@@ -2460,21 +2462,25 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueueInterface const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetSelectedQueue(ns3::Ptr item) const [member function]
- cls.add_method('GetSelectedQueue',
+ ## net-device.h (module 'network'): void ns3::NetDeviceQueueInterface::CreateTxQueues() [member function]
+ cls.add_method('CreateTxQueues',
+ 'void',
+ [])
+ ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetNTxQueues() const [member function]
+ cls.add_method('GetNTxQueues',
'uint8_t',
- [param('ns3::Ptr< ns3::QueueItem >', 'item')],
+ [],
+ is_const=True)
+ ## net-device.h (module 'network'): ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ns3::NetDeviceQueueInterface::GetSelectQueueCallback() const [member function]
+ cls.add_method('GetSelectQueueCallback',
+ 'ns3::Callback< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >',
+ [],
is_const=True)
## net-device.h (module 'network'): ns3::Ptr ns3::NetDeviceQueueInterface::GetTxQueue(uint8_t i) const [member function]
cls.add_method('GetTxQueue',
'ns3::Ptr< ns3::NetDeviceQueue >',
[param('uint8_t', 'i')],
is_const=True)
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetTxQueuesN() const [member function]
- cls.add_method('GetTxQueuesN',
- 'uint8_t',
- [],
- is_const=True)
## net-device.h (module 'network'): static ns3::TypeId ns3::NetDeviceQueueInterface::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
@@ -2549,6 +2555,11 @@ def register_Ns3QueueItem_methods(root_module, cls):
'uint32_t',
[],
is_const=True, is_virtual=True)
+ ## net-device.h (module 'network'): bool ns3::QueueItem::GetUint8Value(ns3::QueueItem::Uint8Values field, uint8_t & value) const [member function]
+ cls.add_method('GetUint8Value',
+ 'bool',
+ [param('ns3::QueueItem::Uint8Values', 'field'), param('uint8_t &', 'value')],
+ is_const=True, is_virtual=True)
## net-device.h (module 'network'): void ns3::QueueItem::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
diff --git a/src/buildings/bindings/modulegen__gcc_ILP32.py b/src/buildings/bindings/modulegen__gcc_ILP32.py
index 4aaee5ad44d..963fdbcf81a 100644
--- a/src/buildings/bindings/modulegen__gcc_ILP32.py
+++ b/src/buildings/bindings/modulegen__gcc_ILP32.py
@@ -264,6 +264,8 @@ def register_types(module):
module.add_class('ParetoRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream'])
## net-device.h (module 'network'): ns3::QueueItem [class]
module.add_class('QueueItem', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >'])
+ ## net-device.h (module 'network'): ns3::QueueItem::Uint8Values [enumeration]
+ module.add_enum('Uint8Values', ['IP_DSFIELD'], outer_class=root_module['ns3::QueueItem'], import_from_module='ns.network')
## nstime.h (module 'core'): ns3::TimeValue [class]
module.add_class('TimeValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
## type-id.h (module 'core'): ns3::TypeIdChecker [class]
@@ -1865,6 +1867,11 @@ def register_Ns3Object_methods(root_module, cls):
cls.add_method('Initialize',
'void',
[])
+ ## object.h (module 'core'): bool ns3::Object::IsInitialized() const [member function]
+ cls.add_method('IsInitialized',
+ 'bool',
+ [],
+ is_const=True)
## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
cls.add_constructor([param('ns3::Object const &', 'o')],
visibility='protected')
@@ -4175,11 +4182,6 @@ def register_Ns3NetDeviceQueue_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueue const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueue::NetDeviceQueue() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): bool ns3::NetDeviceQueue::HasWakeCallbackSet() const [member function]
- cls.add_method('HasWakeCallbackSet',
- 'bool',
- [],
- is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDeviceQueue::IsStopped() const [member function]
cls.add_method('IsStopped',
'bool',
@@ -4212,21 +4214,25 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueueInterface const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetSelectedQueue(ns3::Ptr item) const [member function]
- cls.add_method('GetSelectedQueue',
+ ## net-device.h (module 'network'): void ns3::NetDeviceQueueInterface::CreateTxQueues() [member function]
+ cls.add_method('CreateTxQueues',
+ 'void',
+ [])
+ ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetNTxQueues() const [member function]
+ cls.add_method('GetNTxQueues',
'uint8_t',
- [param('ns3::Ptr< ns3::QueueItem >', 'item')],
+ [],
+ is_const=True)
+ ## net-device.h (module 'network'): ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ns3::NetDeviceQueueInterface::GetSelectQueueCallback() const [member function]
+ cls.add_method('GetSelectQueueCallback',
+ 'ns3::Callback< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >',
+ [],
is_const=True)
## net-device.h (module 'network'): ns3::Ptr ns3::NetDeviceQueueInterface::GetTxQueue(uint8_t i) const [member function]
cls.add_method('GetTxQueue',
'ns3::Ptr< ns3::NetDeviceQueue >',
[param('uint8_t', 'i')],
is_const=True)
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetTxQueuesN() const [member function]
- cls.add_method('GetTxQueuesN',
- 'uint8_t',
- [],
- is_const=True)
## net-device.h (module 'network'): static ns3::TypeId ns3::NetDeviceQueueInterface::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
@@ -4492,6 +4498,11 @@ def register_Ns3QueueItem_methods(root_module, cls):
'uint32_t',
[],
is_const=True, is_virtual=True)
+ ## net-device.h (module 'network'): bool ns3::QueueItem::GetUint8Value(ns3::QueueItem::Uint8Values field, uint8_t & value) const [member function]
+ cls.add_method('GetUint8Value',
+ 'bool',
+ [param('ns3::QueueItem::Uint8Values', 'field'), param('uint8_t &', 'value')],
+ is_const=True, is_virtual=True)
## net-device.h (module 'network'): void ns3::QueueItem::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
diff --git a/src/buildings/bindings/modulegen__gcc_LP64.py b/src/buildings/bindings/modulegen__gcc_LP64.py
index 4aaee5ad44d..963fdbcf81a 100644
--- a/src/buildings/bindings/modulegen__gcc_LP64.py
+++ b/src/buildings/bindings/modulegen__gcc_LP64.py
@@ -264,6 +264,8 @@ def register_types(module):
module.add_class('ParetoRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream'])
## net-device.h (module 'network'): ns3::QueueItem [class]
module.add_class('QueueItem', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >'])
+ ## net-device.h (module 'network'): ns3::QueueItem::Uint8Values [enumeration]
+ module.add_enum('Uint8Values', ['IP_DSFIELD'], outer_class=root_module['ns3::QueueItem'], import_from_module='ns.network')
## nstime.h (module 'core'): ns3::TimeValue [class]
module.add_class('TimeValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
## type-id.h (module 'core'): ns3::TypeIdChecker [class]
@@ -1865,6 +1867,11 @@ def register_Ns3Object_methods(root_module, cls):
cls.add_method('Initialize',
'void',
[])
+ ## object.h (module 'core'): bool ns3::Object::IsInitialized() const [member function]
+ cls.add_method('IsInitialized',
+ 'bool',
+ [],
+ is_const=True)
## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
cls.add_constructor([param('ns3::Object const &', 'o')],
visibility='protected')
@@ -4175,11 +4182,6 @@ def register_Ns3NetDeviceQueue_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueue const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueue::NetDeviceQueue() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): bool ns3::NetDeviceQueue::HasWakeCallbackSet() const [member function]
- cls.add_method('HasWakeCallbackSet',
- 'bool',
- [],
- is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDeviceQueue::IsStopped() const [member function]
cls.add_method('IsStopped',
'bool',
@@ -4212,21 +4214,25 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueueInterface const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetSelectedQueue(ns3::Ptr item) const [member function]
- cls.add_method('GetSelectedQueue',
+ ## net-device.h (module 'network'): void ns3::NetDeviceQueueInterface::CreateTxQueues() [member function]
+ cls.add_method('CreateTxQueues',
+ 'void',
+ [])
+ ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetNTxQueues() const [member function]
+ cls.add_method('GetNTxQueues',
'uint8_t',
- [param('ns3::Ptr< ns3::QueueItem >', 'item')],
+ [],
+ is_const=True)
+ ## net-device.h (module 'network'): ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ns3::NetDeviceQueueInterface::GetSelectQueueCallback() const [member function]
+ cls.add_method('GetSelectQueueCallback',
+ 'ns3::Callback< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >',
+ [],
is_const=True)
## net-device.h (module 'network'): ns3::Ptr ns3::NetDeviceQueueInterface::GetTxQueue(uint8_t i) const [member function]
cls.add_method('GetTxQueue',
'ns3::Ptr< ns3::NetDeviceQueue >',
[param('uint8_t', 'i')],
is_const=True)
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetTxQueuesN() const [member function]
- cls.add_method('GetTxQueuesN',
- 'uint8_t',
- [],
- is_const=True)
## net-device.h (module 'network'): static ns3::TypeId ns3::NetDeviceQueueInterface::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
@@ -4492,6 +4498,11 @@ def register_Ns3QueueItem_methods(root_module, cls):
'uint32_t',
[],
is_const=True, is_virtual=True)
+ ## net-device.h (module 'network'): bool ns3::QueueItem::GetUint8Value(ns3::QueueItem::Uint8Values field, uint8_t & value) const [member function]
+ cls.add_method('GetUint8Value',
+ 'bool',
+ [param('ns3::QueueItem::Uint8Values', 'field'), param('uint8_t &', 'value')],
+ is_const=True, is_virtual=True)
## net-device.h (module 'network'): void ns3::QueueItem::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
diff --git a/src/click/bindings/callbacks_list.py b/src/click/bindings/callbacks_list.py
index 82149b537a3..92a20845a1e 100644
--- a/src/click/bindings/callbacks_list.py
+++ b/src/click/bindings/callbacks_list.py
@@ -1,4 +1,5 @@
callback_classes = [
+ ['unsigned char', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['void', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['void', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'ns3::Address const&', 'ns3::Address const&', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
@@ -6,5 +7,4 @@
['void', 'ns3::Ptr', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['void', 'ns3::Ptr', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['bool', 'ns3::Ptr', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
- ['unsigned char', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
]
diff --git a/src/click/bindings/modulegen__gcc_ILP32.py b/src/click/bindings/modulegen__gcc_ILP32.py
index 61452e0a6b6..14f2cc62648 100644
--- a/src/click/bindings/modulegen__gcc_ILP32.py
+++ b/src/click/bindings/modulegen__gcc_ILP32.py
@@ -182,6 +182,8 @@ def register_types(module):
module.add_enum('SocketErrno', ['ERROR_NOTERROR', 'ERROR_ISCONN', 'ERROR_NOTCONN', 'ERROR_MSGSIZE', 'ERROR_AGAIN', 'ERROR_SHUTDOWN', 'ERROR_OPNOTSUPP', 'ERROR_AFNOSUPPORT', 'ERROR_INVAL', 'ERROR_BADF', 'ERROR_NOROUTETOHOST', 'ERROR_NODEV', 'ERROR_ADDRNOTAVAIL', 'ERROR_ADDRINUSE', 'SOCKET_ERRNO_LAST'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::SocketType [enumeration]
module.add_enum('SocketType', ['NS3_SOCK_STREAM', 'NS3_SOCK_SEQPACKET', 'NS3_SOCK_DGRAM', 'NS3_SOCK_RAW'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
+ ## socket.h (module 'network'): ns3::Socket::SocketPriority [enumeration]
+ module.add_enum('SocketPriority', ['NS3_PRIO_BESTEFFORT', 'NS3_PRIO_FILLER', 'NS3_PRIO_BULK', 'NS3_PRIO_INTERACTIVE_BULK', 'NS3_PRIO_INTERACTIVE', 'NS3_PRIO_CONTROL'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::Ipv6MulticastFilterMode [enumeration]
module.add_enum('Ipv6MulticastFilterMode', ['INCLUDE', 'EXCLUDE'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::SocketIpTosTag [class]
@@ -192,6 +194,8 @@ def register_types(module):
module.add_class('SocketIpv6HopLimitTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketIpv6TclassTag [class]
module.add_class('SocketIpv6TclassTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
+ ## socket.h (module 'network'): ns3::SocketPriorityTag [class]
+ module.add_class('SocketPriorityTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketSetDontFragmentTag [class]
module.add_class('SocketSetDontFragmentTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor [class]
@@ -276,6 +280,8 @@ def register_types(module):
module.add_class('Packet', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter >'])
## net-device.h (module 'network'): ns3::QueueItem [class]
module.add_class('QueueItem', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >'])
+ ## net-device.h (module 'network'): ns3::QueueItem::Uint8Values [enumeration]
+ module.add_enum('Uint8Values', ['IP_DSFIELD'], outer_class=root_module['ns3::QueueItem'], import_from_module='ns.network')
## type-id.h (module 'core'): ns3::TypeIdChecker [class]
module.add_class('TypeIdChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])
## type-id.h (module 'core'): ns3::TypeIdValue [class]
@@ -460,6 +466,7 @@ def register_methods(root_module):
register_Ns3SocketIpTtlTag_methods(root_module, root_module['ns3::SocketIpTtlTag'])
register_Ns3SocketIpv6HopLimitTag_methods(root_module, root_module['ns3::SocketIpv6HopLimitTag'])
register_Ns3SocketIpv6TclassTag_methods(root_module, root_module['ns3::SocketIpv6TclassTag'])
+ register_Ns3SocketPriorityTag_methods(root_module, root_module['ns3::SocketPriorityTag'])
register_Ns3SocketSetDontFragmentTag_methods(root_module, root_module['ns3::SocketSetDontFragmentTag'])
register_Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::TraceSourceAccessor'])
register_Ns3TrafficControlLayer_methods(root_module, root_module['ns3::TrafficControlLayer'])
@@ -1085,6 +1092,11 @@ def register_Ns3InetSocketAddress_methods(root_module, cls):
'uint16_t',
[],
is_const=True)
+ ## inet-socket-address.h (module 'network'): uint8_t ns3::InetSocketAddress::GetTos() const [member function]
+ cls.add_method('GetTos',
+ 'uint8_t',
+ [],
+ is_const=True)
## inet-socket-address.h (module 'network'): static bool ns3::InetSocketAddress::IsMatchingType(ns3::Address const & address) [member function]
cls.add_method('IsMatchingType',
'bool',
@@ -1098,6 +1110,10 @@ def register_Ns3InetSocketAddress_methods(root_module, cls):
cls.add_method('SetPort',
'void',
[param('uint16_t', 'port')])
+ ## inet-socket-address.h (module 'network'): void ns3::InetSocketAddress::SetTos(uint8_t tos) [member function]
+ cls.add_method('SetTos',
+ 'void',
+ [param('uint8_t', 'tos')])
return
def register_Ns3Ipv4Address_methods(root_module, cls):
@@ -3280,6 +3296,11 @@ def register_Ns3Socket_methods(root_module, cls):
'int',
[param('ns3::Address &', 'address')],
is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): uint8_t ns3::Socket::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
## socket.h (module 'network'): uint32_t ns3::Socket::GetRxAvailable() const [member function]
cls.add_method('GetRxAvailable',
'uint32_t',
@@ -3305,6 +3326,11 @@ def register_Ns3Socket_methods(root_module, cls):
'ns3::TypeId',
[],
is_static=True)
+ ## socket.h (module 'network'): static uint8_t ns3::Socket::IpTos2Priority(uint8_t ipTos) [member function]
+ cls.add_method('IpTos2Priority',
+ 'uint8_t',
+ [param('uint8_t', 'ipTos')],
+ is_static=True)
## socket.h (module 'network'): void ns3::Socket::Ipv6JoinGroup(ns3::Ipv6Address address, ns3::Socket::Ipv6MulticastFilterMode filterMode, std::vector > sourceAddresses) [member function]
cls.add_method('Ipv6JoinGroup',
'void',
@@ -3453,6 +3479,10 @@ def register_Ns3Socket_methods(root_module, cls):
cls.add_method('SetIpv6Tclass',
'void',
[param('int', 'ipTclass')])
+ ## socket.h (module 'network'): void ns3::Socket::SetPriority(uint8_t priority) [member function]
+ cls.add_method('SetPriority',
+ 'void',
+ [param('uint8_t', 'priority')])
## socket.h (module 'network'): void ns3::Socket::SetRecvCallback(ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> arg0) [member function]
cls.add_method('SetRecvCallback',
'void',
@@ -3480,11 +3510,6 @@ def register_Ns3Socket_methods(root_module, cls):
'void',
[],
visibility='protected', is_virtual=True)
- ## socket.h (module 'network'): bool ns3::Socket::IsManualIpTos() const [member function]
- cls.add_method('IsManualIpTos',
- 'bool',
- [],
- is_const=True, visibility='protected')
## socket.h (module 'network'): bool ns3::Socket::IsManualIpTtl() const [member function]
cls.add_method('IsManualIpTtl',
'bool',
@@ -3731,6 +3756,52 @@ def register_Ns3SocketIpv6TclassTag_methods(root_module, cls):
[param('uint8_t', 'tclass')])
return
+def register_Ns3SocketPriorityTag_methods(root_module, cls):
+ ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag(ns3::SocketPriorityTag const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::SocketPriorityTag const &', 'arg0')])
+ ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag() [constructor]
+ cls.add_constructor([])
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Deserialize(ns3::TagBuffer i) [member function]
+ cls.add_method('Deserialize',
+ 'void',
+ [param('ns3::TagBuffer', 'i')],
+ is_virtual=True)
+ ## socket.h (module 'network'): ns3::TypeId ns3::SocketPriorityTag::GetInstanceTypeId() const [member function]
+ cls.add_method('GetInstanceTypeId',
+ 'ns3::TypeId',
+ [],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): uint8_t ns3::SocketPriorityTag::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
+ ## socket.h (module 'network'): uint32_t ns3::SocketPriorityTag::GetSerializedSize() const [member function]
+ cls.add_method('GetSerializedSize',
+ 'uint32_t',
+ [],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): static ns3::TypeId ns3::SocketPriorityTag::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Print(std::ostream & os) const [member function]
+ cls.add_method('Print',
+ 'void',
+ [param('std::ostream &', 'os')],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Serialize(ns3::TagBuffer i) const [member function]
+ cls.add_method('Serialize',
+ 'void',
+ [param('ns3::TagBuffer', 'i')],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::SetPriority(uint8_t priority) [member function]
+ cls.add_method('SetPriority',
+ 'void',
+ [param('uint8_t', 'priority')])
+ return
+
def register_Ns3SocketSetDontFragmentTag_methods(root_module, cls):
## socket.h (module 'network'): ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag(ns3::SocketSetDontFragmentTag const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SocketSetDontFragmentTag const &', 'arg0')])
@@ -5097,21 +5168,21 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueueInterface const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetSelectedQueue(ns3::Ptr item) const [member function]
- cls.add_method('GetSelectedQueue',
+ ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetNTxQueues() const [member function]
+ cls.add_method('GetNTxQueues',
'uint8_t',
- [param('ns3::Ptr< ns3::QueueItem >', 'item')],
+ [],
+ is_const=True)
+ ## net-device.h (module 'network'): ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ns3::NetDeviceQueueInterface::GetSelectQueueCallback() const [member function]
+ cls.add_method('GetSelectQueueCallback',
+ 'ns3::Callback< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >',
+ [],
is_const=True)
## net-device.h (module 'network'): ns3::Ptr ns3::NetDeviceQueueInterface::GetTxQueue(uint8_t i) const [member function]
cls.add_method('GetTxQueue',
'ns3::Ptr< ns3::NetDeviceQueue >',
[param('uint8_t', 'i')],
is_const=True)
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetTxQueuesN() const [member function]
- cls.add_method('GetTxQueuesN',
- 'uint8_t',
- [],
- is_const=True)
## net-device.h (module 'network'): static ns3::TypeId ns3::NetDeviceQueueInterface::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
@@ -5476,6 +5547,11 @@ def register_Ns3QueueItem_methods(root_module, cls):
'uint32_t',
[],
is_const=True, is_virtual=True)
+ ## net-device.h (module 'network'): bool ns3::QueueItem::GetUint8Value(ns3::QueueItem::Uint8Values field, uint8_t & value) const [member function]
+ cls.add_method('GetUint8Value',
+ 'bool',
+ [param('ns3::QueueItem::Uint8Values', 'field'), param('uint8_t &', 'value')],
+ is_const=True, is_virtual=True)
## net-device.h (module 'network'): void ns3::QueueItem::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
diff --git a/src/click/bindings/modulegen__gcc_LP64.py b/src/click/bindings/modulegen__gcc_LP64.py
index 61452e0a6b6..14f2cc62648 100644
--- a/src/click/bindings/modulegen__gcc_LP64.py
+++ b/src/click/bindings/modulegen__gcc_LP64.py
@@ -182,6 +182,8 @@ def register_types(module):
module.add_enum('SocketErrno', ['ERROR_NOTERROR', 'ERROR_ISCONN', 'ERROR_NOTCONN', 'ERROR_MSGSIZE', 'ERROR_AGAIN', 'ERROR_SHUTDOWN', 'ERROR_OPNOTSUPP', 'ERROR_AFNOSUPPORT', 'ERROR_INVAL', 'ERROR_BADF', 'ERROR_NOROUTETOHOST', 'ERROR_NODEV', 'ERROR_ADDRNOTAVAIL', 'ERROR_ADDRINUSE', 'SOCKET_ERRNO_LAST'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::SocketType [enumeration]
module.add_enum('SocketType', ['NS3_SOCK_STREAM', 'NS3_SOCK_SEQPACKET', 'NS3_SOCK_DGRAM', 'NS3_SOCK_RAW'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
+ ## socket.h (module 'network'): ns3::Socket::SocketPriority [enumeration]
+ module.add_enum('SocketPriority', ['NS3_PRIO_BESTEFFORT', 'NS3_PRIO_FILLER', 'NS3_PRIO_BULK', 'NS3_PRIO_INTERACTIVE_BULK', 'NS3_PRIO_INTERACTIVE', 'NS3_PRIO_CONTROL'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::Ipv6MulticastFilterMode [enumeration]
module.add_enum('Ipv6MulticastFilterMode', ['INCLUDE', 'EXCLUDE'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::SocketIpTosTag [class]
@@ -192,6 +194,8 @@ def register_types(module):
module.add_class('SocketIpv6HopLimitTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketIpv6TclassTag [class]
module.add_class('SocketIpv6TclassTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
+ ## socket.h (module 'network'): ns3::SocketPriorityTag [class]
+ module.add_class('SocketPriorityTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketSetDontFragmentTag [class]
module.add_class('SocketSetDontFragmentTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor [class]
@@ -276,6 +280,8 @@ def register_types(module):
module.add_class('Packet', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter >'])
## net-device.h (module 'network'): ns3::QueueItem [class]
module.add_class('QueueItem', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >'])
+ ## net-device.h (module 'network'): ns3::QueueItem::Uint8Values [enumeration]
+ module.add_enum('Uint8Values', ['IP_DSFIELD'], outer_class=root_module['ns3::QueueItem'], import_from_module='ns.network')
## type-id.h (module 'core'): ns3::TypeIdChecker [class]
module.add_class('TypeIdChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])
## type-id.h (module 'core'): ns3::TypeIdValue [class]
@@ -460,6 +466,7 @@ def register_methods(root_module):
register_Ns3SocketIpTtlTag_methods(root_module, root_module['ns3::SocketIpTtlTag'])
register_Ns3SocketIpv6HopLimitTag_methods(root_module, root_module['ns3::SocketIpv6HopLimitTag'])
register_Ns3SocketIpv6TclassTag_methods(root_module, root_module['ns3::SocketIpv6TclassTag'])
+ register_Ns3SocketPriorityTag_methods(root_module, root_module['ns3::SocketPriorityTag'])
register_Ns3SocketSetDontFragmentTag_methods(root_module, root_module['ns3::SocketSetDontFragmentTag'])
register_Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::TraceSourceAccessor'])
register_Ns3TrafficControlLayer_methods(root_module, root_module['ns3::TrafficControlLayer'])
@@ -1085,6 +1092,11 @@ def register_Ns3InetSocketAddress_methods(root_module, cls):
'uint16_t',
[],
is_const=True)
+ ## inet-socket-address.h (module 'network'): uint8_t ns3::InetSocketAddress::GetTos() const [member function]
+ cls.add_method('GetTos',
+ 'uint8_t',
+ [],
+ is_const=True)
## inet-socket-address.h (module 'network'): static bool ns3::InetSocketAddress::IsMatchingType(ns3::Address const & address) [member function]
cls.add_method('IsMatchingType',
'bool',
@@ -1098,6 +1110,10 @@ def register_Ns3InetSocketAddress_methods(root_module, cls):
cls.add_method('SetPort',
'void',
[param('uint16_t', 'port')])
+ ## inet-socket-address.h (module 'network'): void ns3::InetSocketAddress::SetTos(uint8_t tos) [member function]
+ cls.add_method('SetTos',
+ 'void',
+ [param('uint8_t', 'tos')])
return
def register_Ns3Ipv4Address_methods(root_module, cls):
@@ -3280,6 +3296,11 @@ def register_Ns3Socket_methods(root_module, cls):
'int',
[param('ns3::Address &', 'address')],
is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): uint8_t ns3::Socket::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
## socket.h (module 'network'): uint32_t ns3::Socket::GetRxAvailable() const [member function]
cls.add_method('GetRxAvailable',
'uint32_t',
@@ -3305,6 +3326,11 @@ def register_Ns3Socket_methods(root_module, cls):
'ns3::TypeId',
[],
is_static=True)
+ ## socket.h (module 'network'): static uint8_t ns3::Socket::IpTos2Priority(uint8_t ipTos) [member function]
+ cls.add_method('IpTos2Priority',
+ 'uint8_t',
+ [param('uint8_t', 'ipTos')],
+ is_static=True)
## socket.h (module 'network'): void ns3::Socket::Ipv6JoinGroup(ns3::Ipv6Address address, ns3::Socket::Ipv6MulticastFilterMode filterMode, std::vector > sourceAddresses) [member function]
cls.add_method('Ipv6JoinGroup',
'void',
@@ -3453,6 +3479,10 @@ def register_Ns3Socket_methods(root_module, cls):
cls.add_method('SetIpv6Tclass',
'void',
[param('int', 'ipTclass')])
+ ## socket.h (module 'network'): void ns3::Socket::SetPriority(uint8_t priority) [member function]
+ cls.add_method('SetPriority',
+ 'void',
+ [param('uint8_t', 'priority')])
## socket.h (module 'network'): void ns3::Socket::SetRecvCallback(ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> arg0) [member function]
cls.add_method('SetRecvCallback',
'void',
@@ -3480,11 +3510,6 @@ def register_Ns3Socket_methods(root_module, cls):
'void',
[],
visibility='protected', is_virtual=True)
- ## socket.h (module 'network'): bool ns3::Socket::IsManualIpTos() const [member function]
- cls.add_method('IsManualIpTos',
- 'bool',
- [],
- is_const=True, visibility='protected')
## socket.h (module 'network'): bool ns3::Socket::IsManualIpTtl() const [member function]
cls.add_method('IsManualIpTtl',
'bool',
@@ -3731,6 +3756,52 @@ def register_Ns3SocketIpv6TclassTag_methods(root_module, cls):
[param('uint8_t', 'tclass')])
return
+def register_Ns3SocketPriorityTag_methods(root_module, cls):
+ ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag(ns3::SocketPriorityTag const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::SocketPriorityTag const &', 'arg0')])
+ ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag() [constructor]
+ cls.add_constructor([])
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Deserialize(ns3::TagBuffer i) [member function]
+ cls.add_method('Deserialize',
+ 'void',
+ [param('ns3::TagBuffer', 'i')],
+ is_virtual=True)
+ ## socket.h (module 'network'): ns3::TypeId ns3::SocketPriorityTag::GetInstanceTypeId() const [member function]
+ cls.add_method('GetInstanceTypeId',
+ 'ns3::TypeId',
+ [],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): uint8_t ns3::SocketPriorityTag::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
+ ## socket.h (module 'network'): uint32_t ns3::SocketPriorityTag::GetSerializedSize() const [member function]
+ cls.add_method('GetSerializedSize',
+ 'uint32_t',
+ [],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): static ns3::TypeId ns3::SocketPriorityTag::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Print(std::ostream & os) const [member function]
+ cls.add_method('Print',
+ 'void',
+ [param('std::ostream &', 'os')],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Serialize(ns3::TagBuffer i) const [member function]
+ cls.add_method('Serialize',
+ 'void',
+ [param('ns3::TagBuffer', 'i')],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::SetPriority(uint8_t priority) [member function]
+ cls.add_method('SetPriority',
+ 'void',
+ [param('uint8_t', 'priority')])
+ return
+
def register_Ns3SocketSetDontFragmentTag_methods(root_module, cls):
## socket.h (module 'network'): ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag(ns3::SocketSetDontFragmentTag const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SocketSetDontFragmentTag const &', 'arg0')])
@@ -5097,21 +5168,21 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueueInterface const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetSelectedQueue(ns3::Ptr item) const [member function]
- cls.add_method('GetSelectedQueue',
+ ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetNTxQueues() const [member function]
+ cls.add_method('GetNTxQueues',
'uint8_t',
- [param('ns3::Ptr< ns3::QueueItem >', 'item')],
+ [],
+ is_const=True)
+ ## net-device.h (module 'network'): ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ns3::NetDeviceQueueInterface::GetSelectQueueCallback() const [member function]
+ cls.add_method('GetSelectQueueCallback',
+ 'ns3::Callback< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >',
+ [],
is_const=True)
## net-device.h (module 'network'): ns3::Ptr ns3::NetDeviceQueueInterface::GetTxQueue(uint8_t i) const [member function]
cls.add_method('GetTxQueue',
'ns3::Ptr< ns3::NetDeviceQueue >',
[param('uint8_t', 'i')],
is_const=True)
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetTxQueuesN() const [member function]
- cls.add_method('GetTxQueuesN',
- 'uint8_t',
- [],
- is_const=True)
## net-device.h (module 'network'): static ns3::TypeId ns3::NetDeviceQueueInterface::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
@@ -5476,6 +5547,11 @@ def register_Ns3QueueItem_methods(root_module, cls):
'uint32_t',
[],
is_const=True, is_virtual=True)
+ ## net-device.h (module 'network'): bool ns3::QueueItem::GetUint8Value(ns3::QueueItem::Uint8Values field, uint8_t & value) const [member function]
+ cls.add_method('GetUint8Value',
+ 'bool',
+ [param('ns3::QueueItem::Uint8Values', 'field'), param('uint8_t &', 'value')],
+ is_const=True, is_virtual=True)
## net-device.h (module 'network'): void ns3::QueueItem::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
diff --git a/src/core/bindings/modulegen__gcc_ILP32.py b/src/core/bindings/modulegen__gcc_ILP32.py
index f08146d9c03..986b75c37af 100644
--- a/src/core/bindings/modulegen__gcc_ILP32.py
+++ b/src/core/bindings/modulegen__gcc_ILP32.py
@@ -1762,6 +1762,11 @@ def register_Ns3Object_methods(root_module, cls):
cls.add_method('Initialize',
'void',
[])
+ ## object.h (module 'core'): bool ns3::Object::IsInitialized() const [member function]
+ cls.add_method('IsInitialized',
+ 'bool',
+ [],
+ is_const=True)
## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
cls.add_constructor([param('ns3::Object const &', 'o')],
visibility='protected')
diff --git a/src/core/bindings/modulegen__gcc_LP64.py b/src/core/bindings/modulegen__gcc_LP64.py
index 57f505fe07d..74331b28574 100644
--- a/src/core/bindings/modulegen__gcc_LP64.py
+++ b/src/core/bindings/modulegen__gcc_LP64.py
@@ -1762,6 +1762,11 @@ def register_Ns3Object_methods(root_module, cls):
cls.add_method('Initialize',
'void',
[])
+ ## object.h (module 'core'): bool ns3::Object::IsInitialized() const [member function]
+ cls.add_method('IsInitialized',
+ 'bool',
+ [],
+ is_const=True)
## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
cls.add_constructor([param('ns3::Object const &', 'o')],
visibility='protected')
diff --git a/src/core/model/object.cc b/src/core/model/object.cc
index 17ea1e53956..c08246fac71 100644
--- a/src/core/model/object.cc
+++ b/src/core/model/object.cc
@@ -204,6 +204,12 @@ Object::Initialize (void)
}
}
}
+bool
+Object::IsInitialized (void) const
+{
+ NS_LOG_FUNCTION (this);
+ return m_initialized;
+}
void
Object::Dispose (void)
{
diff --git a/src/core/model/object.h b/src/core/model/object.h
index f3da04a0491..1b8207191a5 100644
--- a/src/core/model/object.h
+++ b/src/core/model/object.h
@@ -219,6 +219,13 @@ class Object : public SimpleRefCount
*/
void Initialize (void);
+ /**
+ * Check if the object has been initialized.
+ *
+ * \brief returns true if the object has been initialized.
+ */
+ bool IsInitialized (void) const;
+
protected:
/**
* Notify all Objects aggregated to this one of a new Object being
diff --git a/src/csma-layout/bindings/modulegen__gcc_ILP32.py b/src/csma-layout/bindings/modulegen__gcc_ILP32.py
index 9c4368ebcba..e5a4a1373a8 100644
--- a/src/csma-layout/bindings/modulegen__gcc_ILP32.py
+++ b/src/csma-layout/bindings/modulegen__gcc_ILP32.py
@@ -234,6 +234,8 @@ def register_types(module):
module.add_enum('SocketErrno', ['ERROR_NOTERROR', 'ERROR_ISCONN', 'ERROR_NOTCONN', 'ERROR_MSGSIZE', 'ERROR_AGAIN', 'ERROR_SHUTDOWN', 'ERROR_OPNOTSUPP', 'ERROR_AFNOSUPPORT', 'ERROR_INVAL', 'ERROR_BADF', 'ERROR_NOROUTETOHOST', 'ERROR_NODEV', 'ERROR_ADDRNOTAVAIL', 'ERROR_ADDRINUSE', 'SOCKET_ERRNO_LAST'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::SocketType [enumeration]
module.add_enum('SocketType', ['NS3_SOCK_STREAM', 'NS3_SOCK_SEQPACKET', 'NS3_SOCK_DGRAM', 'NS3_SOCK_RAW'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
+ ## socket.h (module 'network'): ns3::Socket::SocketPriority [enumeration]
+ module.add_enum('SocketPriority', ['NS3_PRIO_BESTEFFORT', 'NS3_PRIO_FILLER', 'NS3_PRIO_BULK', 'NS3_PRIO_INTERACTIVE_BULK', 'NS3_PRIO_INTERACTIVE', 'NS3_PRIO_CONTROL'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::Ipv6MulticastFilterMode [enumeration]
module.add_enum('Ipv6MulticastFilterMode', ['INCLUDE', 'EXCLUDE'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::SocketIpTosTag [class]
@@ -244,6 +246,8 @@ def register_types(module):
module.add_class('SocketIpv6HopLimitTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketIpv6TclassTag [class]
module.add_class('SocketIpv6TclassTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
+ ## socket.h (module 'network'): ns3::SocketPriorityTag [class]
+ module.add_class('SocketPriorityTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketSetDontFragmentTag [class]
module.add_class('SocketSetDontFragmentTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## nstime.h (module 'core'): ns3::Time [class]
@@ -342,6 +346,8 @@ def register_types(module):
module.add_class('Packet', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter >'])
## net-device.h (module 'network'): ns3::QueueItem [class]
module.add_class('QueueItem', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >'])
+ ## net-device.h (module 'network'): ns3::QueueItem::Uint8Values [enumeration]
+ module.add_enum('Uint8Values', ['IP_DSFIELD'], outer_class=root_module['ns3::QueueItem'], import_from_module='ns.network')
## nstime.h (module 'core'): ns3::TimeValue [class]
module.add_class('TimeValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
## type-id.h (module 'core'): ns3::TypeIdChecker [class]
@@ -505,6 +511,7 @@ def register_methods(root_module):
register_Ns3SocketIpTtlTag_methods(root_module, root_module['ns3::SocketIpTtlTag'])
register_Ns3SocketIpv6HopLimitTag_methods(root_module, root_module['ns3::SocketIpv6HopLimitTag'])
register_Ns3SocketIpv6TclassTag_methods(root_module, root_module['ns3::SocketIpv6TclassTag'])
+ register_Ns3SocketPriorityTag_methods(root_module, root_module['ns3::SocketPriorityTag'])
register_Ns3SocketSetDontFragmentTag_methods(root_module, root_module['ns3::SocketSetDontFragmentTag'])
register_Ns3Time_methods(root_module, root_module['ns3::Time'])
register_Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::TraceSourceAccessor'])
@@ -1534,6 +1541,11 @@ def register_Ns3InetSocketAddress_methods(root_module, cls):
'uint16_t',
[],
is_const=True)
+ ## inet-socket-address.h (module 'network'): uint8_t ns3::InetSocketAddress::GetTos() const [member function]
+ cls.add_method('GetTos',
+ 'uint8_t',
+ [],
+ is_const=True)
## inet-socket-address.h (module 'network'): static bool ns3::InetSocketAddress::IsMatchingType(ns3::Address const & address) [member function]
cls.add_method('IsMatchingType',
'bool',
@@ -1547,6 +1559,10 @@ def register_Ns3InetSocketAddress_methods(root_module, cls):
cls.add_method('SetPort',
'void',
[param('uint16_t', 'port')])
+ ## inet-socket-address.h (module 'network'): void ns3::InetSocketAddress::SetTos(uint8_t tos) [member function]
+ cls.add_method('SetTos',
+ 'void',
+ [param('uint8_t', 'tos')])
return
def register_Ns3Ipv4Address_methods(root_module, cls):
@@ -4056,6 +4072,11 @@ def register_Ns3Object_methods(root_module, cls):
cls.add_method('Initialize',
'void',
[])
+ ## object.h (module 'core'): bool ns3::Object::IsInitialized() const [member function]
+ cls.add_method('IsInitialized',
+ 'bool',
+ [],
+ is_const=True)
## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
cls.add_constructor([param('ns3::Object const &', 'o')],
visibility='protected')
@@ -4424,6 +4445,11 @@ def register_Ns3Socket_methods(root_module, cls):
'int',
[param('ns3::Address &', 'address')],
is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): uint8_t ns3::Socket::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
## socket.h (module 'network'): uint32_t ns3::Socket::GetRxAvailable() const [member function]
cls.add_method('GetRxAvailable',
'uint32_t',
@@ -4449,6 +4475,11 @@ def register_Ns3Socket_methods(root_module, cls):
'ns3::TypeId',
[],
is_static=True)
+ ## socket.h (module 'network'): static uint8_t ns3::Socket::IpTos2Priority(uint8_t ipTos) [member function]
+ cls.add_method('IpTos2Priority',
+ 'uint8_t',
+ [param('uint8_t', 'ipTos')],
+ is_static=True)
## socket.h (module 'network'): void ns3::Socket::Ipv6JoinGroup(ns3::Ipv6Address address, ns3::Socket::Ipv6MulticastFilterMode filterMode, std::vector > sourceAddresses) [member function]
cls.add_method('Ipv6JoinGroup',
'void',
@@ -4597,6 +4628,10 @@ def register_Ns3Socket_methods(root_module, cls):
cls.add_method('SetIpv6Tclass',
'void',
[param('int', 'ipTclass')])
+ ## socket.h (module 'network'): void ns3::Socket::SetPriority(uint8_t priority) [member function]
+ cls.add_method('SetPriority',
+ 'void',
+ [param('uint8_t', 'priority')])
## socket.h (module 'network'): void ns3::Socket::SetRecvCallback(ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> arg0) [member function]
cls.add_method('SetRecvCallback',
'void',
@@ -4624,11 +4659,6 @@ def register_Ns3Socket_methods(root_module, cls):
'void',
[],
visibility='protected', is_virtual=True)
- ## socket.h (module 'network'): bool ns3::Socket::IsManualIpTos() const [member function]
- cls.add_method('IsManualIpTos',
- 'bool',
- [],
- is_const=True, visibility='protected')
## socket.h (module 'network'): bool ns3::Socket::IsManualIpTtl() const [member function]
cls.add_method('IsManualIpTtl',
'bool',
@@ -4875,6 +4905,52 @@ def register_Ns3SocketIpv6TclassTag_methods(root_module, cls):
[param('uint8_t', 'tclass')])
return
+def register_Ns3SocketPriorityTag_methods(root_module, cls):
+ ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag(ns3::SocketPriorityTag const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::SocketPriorityTag const &', 'arg0')])
+ ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag() [constructor]
+ cls.add_constructor([])
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Deserialize(ns3::TagBuffer i) [member function]
+ cls.add_method('Deserialize',
+ 'void',
+ [param('ns3::TagBuffer', 'i')],
+ is_virtual=True)
+ ## socket.h (module 'network'): ns3::TypeId ns3::SocketPriorityTag::GetInstanceTypeId() const [member function]
+ cls.add_method('GetInstanceTypeId',
+ 'ns3::TypeId',
+ [],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): uint8_t ns3::SocketPriorityTag::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
+ ## socket.h (module 'network'): uint32_t ns3::SocketPriorityTag::GetSerializedSize() const [member function]
+ cls.add_method('GetSerializedSize',
+ 'uint32_t',
+ [],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): static ns3::TypeId ns3::SocketPriorityTag::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Print(std::ostream & os) const [member function]
+ cls.add_method('Print',
+ 'void',
+ [param('std::ostream &', 'os')],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Serialize(ns3::TagBuffer i) const [member function]
+ cls.add_method('Serialize',
+ 'void',
+ [param('ns3::TagBuffer', 'i')],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::SetPriority(uint8_t priority) [member function]
+ cls.add_method('SetPriority',
+ 'void',
+ [param('uint8_t', 'priority')])
+ return
+
def register_Ns3SocketSetDontFragmentTag_methods(root_module, cls):
## socket.h (module 'network'): ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag(ns3::SocketSetDontFragmentTag const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SocketSetDontFragmentTag const &', 'arg0')])
@@ -6960,11 +7036,6 @@ def register_Ns3NetDeviceQueue_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueue const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueue::NetDeviceQueue() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): bool ns3::NetDeviceQueue::HasWakeCallbackSet() const [member function]
- cls.add_method('HasWakeCallbackSet',
- 'bool',
- [],
- is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDeviceQueue::IsStopped() const [member function]
cls.add_method('IsStopped',
'bool',
@@ -6997,21 +7068,25 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueueInterface const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetSelectedQueue(ns3::Ptr item) const [member function]
- cls.add_method('GetSelectedQueue',
+ ## net-device.h (module 'network'): void ns3::NetDeviceQueueInterface::CreateTxQueues() [member function]
+ cls.add_method('CreateTxQueues',
+ 'void',
+ [])
+ ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetNTxQueues() const [member function]
+ cls.add_method('GetNTxQueues',
'uint8_t',
- [param('ns3::Ptr< ns3::QueueItem >', 'item')],
+ [],
+ is_const=True)
+ ## net-device.h (module 'network'): ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ns3::NetDeviceQueueInterface::GetSelectQueueCallback() const [member function]
+ cls.add_method('GetSelectQueueCallback',
+ 'ns3::Callback< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >',
+ [],
is_const=True)
## net-device.h (module 'network'): ns3::Ptr ns3::NetDeviceQueueInterface::GetTxQueue(uint8_t i) const [member function]
cls.add_method('GetTxQueue',
'ns3::Ptr< ns3::NetDeviceQueue >',
[param('uint8_t', 'i')],
is_const=True)
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetTxQueuesN() const [member function]
- cls.add_method('GetTxQueuesN',
- 'uint8_t',
- [],
- is_const=True)
## net-device.h (module 'network'): static ns3::TypeId ns3::NetDeviceQueueInterface::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
@@ -7416,6 +7491,11 @@ def register_Ns3QueueItem_methods(root_module, cls):
'uint32_t',
[],
is_const=True, is_virtual=True)
+ ## net-device.h (module 'network'): bool ns3::QueueItem::GetUint8Value(ns3::QueueItem::Uint8Values field, uint8_t & value) const [member function]
+ cls.add_method('GetUint8Value',
+ 'bool',
+ [param('ns3::QueueItem::Uint8Values', 'field'), param('uint8_t &', 'value')],
+ is_const=True, is_virtual=True)
## net-device.h (module 'network'): void ns3::QueueItem::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
diff --git a/src/csma-layout/bindings/modulegen__gcc_LP64.py b/src/csma-layout/bindings/modulegen__gcc_LP64.py
index 9c4368ebcba..e5a4a1373a8 100644
--- a/src/csma-layout/bindings/modulegen__gcc_LP64.py
+++ b/src/csma-layout/bindings/modulegen__gcc_LP64.py
@@ -234,6 +234,8 @@ def register_types(module):
module.add_enum('SocketErrno', ['ERROR_NOTERROR', 'ERROR_ISCONN', 'ERROR_NOTCONN', 'ERROR_MSGSIZE', 'ERROR_AGAIN', 'ERROR_SHUTDOWN', 'ERROR_OPNOTSUPP', 'ERROR_AFNOSUPPORT', 'ERROR_INVAL', 'ERROR_BADF', 'ERROR_NOROUTETOHOST', 'ERROR_NODEV', 'ERROR_ADDRNOTAVAIL', 'ERROR_ADDRINUSE', 'SOCKET_ERRNO_LAST'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::SocketType [enumeration]
module.add_enum('SocketType', ['NS3_SOCK_STREAM', 'NS3_SOCK_SEQPACKET', 'NS3_SOCK_DGRAM', 'NS3_SOCK_RAW'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
+ ## socket.h (module 'network'): ns3::Socket::SocketPriority [enumeration]
+ module.add_enum('SocketPriority', ['NS3_PRIO_BESTEFFORT', 'NS3_PRIO_FILLER', 'NS3_PRIO_BULK', 'NS3_PRIO_INTERACTIVE_BULK', 'NS3_PRIO_INTERACTIVE', 'NS3_PRIO_CONTROL'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::Ipv6MulticastFilterMode [enumeration]
module.add_enum('Ipv6MulticastFilterMode', ['INCLUDE', 'EXCLUDE'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::SocketIpTosTag [class]
@@ -244,6 +246,8 @@ def register_types(module):
module.add_class('SocketIpv6HopLimitTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketIpv6TclassTag [class]
module.add_class('SocketIpv6TclassTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
+ ## socket.h (module 'network'): ns3::SocketPriorityTag [class]
+ module.add_class('SocketPriorityTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketSetDontFragmentTag [class]
module.add_class('SocketSetDontFragmentTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## nstime.h (module 'core'): ns3::Time [class]
@@ -342,6 +346,8 @@ def register_types(module):
module.add_class('Packet', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter >'])
## net-device.h (module 'network'): ns3::QueueItem [class]
module.add_class('QueueItem', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >'])
+ ## net-device.h (module 'network'): ns3::QueueItem::Uint8Values [enumeration]
+ module.add_enum('Uint8Values', ['IP_DSFIELD'], outer_class=root_module['ns3::QueueItem'], import_from_module='ns.network')
## nstime.h (module 'core'): ns3::TimeValue [class]
module.add_class('TimeValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
## type-id.h (module 'core'): ns3::TypeIdChecker [class]
@@ -505,6 +511,7 @@ def register_methods(root_module):
register_Ns3SocketIpTtlTag_methods(root_module, root_module['ns3::SocketIpTtlTag'])
register_Ns3SocketIpv6HopLimitTag_methods(root_module, root_module['ns3::SocketIpv6HopLimitTag'])
register_Ns3SocketIpv6TclassTag_methods(root_module, root_module['ns3::SocketIpv6TclassTag'])
+ register_Ns3SocketPriorityTag_methods(root_module, root_module['ns3::SocketPriorityTag'])
register_Ns3SocketSetDontFragmentTag_methods(root_module, root_module['ns3::SocketSetDontFragmentTag'])
register_Ns3Time_methods(root_module, root_module['ns3::Time'])
register_Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::TraceSourceAccessor'])
@@ -1534,6 +1541,11 @@ def register_Ns3InetSocketAddress_methods(root_module, cls):
'uint16_t',
[],
is_const=True)
+ ## inet-socket-address.h (module 'network'): uint8_t ns3::InetSocketAddress::GetTos() const [member function]
+ cls.add_method('GetTos',
+ 'uint8_t',
+ [],
+ is_const=True)
## inet-socket-address.h (module 'network'): static bool ns3::InetSocketAddress::IsMatchingType(ns3::Address const & address) [member function]
cls.add_method('IsMatchingType',
'bool',
@@ -1547,6 +1559,10 @@ def register_Ns3InetSocketAddress_methods(root_module, cls):
cls.add_method('SetPort',
'void',
[param('uint16_t', 'port')])
+ ## inet-socket-address.h (module 'network'): void ns3::InetSocketAddress::SetTos(uint8_t tos) [member function]
+ cls.add_method('SetTos',
+ 'void',
+ [param('uint8_t', 'tos')])
return
def register_Ns3Ipv4Address_methods(root_module, cls):
@@ -4056,6 +4072,11 @@ def register_Ns3Object_methods(root_module, cls):
cls.add_method('Initialize',
'void',
[])
+ ## object.h (module 'core'): bool ns3::Object::IsInitialized() const [member function]
+ cls.add_method('IsInitialized',
+ 'bool',
+ [],
+ is_const=True)
## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
cls.add_constructor([param('ns3::Object const &', 'o')],
visibility='protected')
@@ -4424,6 +4445,11 @@ def register_Ns3Socket_methods(root_module, cls):
'int',
[param('ns3::Address &', 'address')],
is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): uint8_t ns3::Socket::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
## socket.h (module 'network'): uint32_t ns3::Socket::GetRxAvailable() const [member function]
cls.add_method('GetRxAvailable',
'uint32_t',
@@ -4449,6 +4475,11 @@ def register_Ns3Socket_methods(root_module, cls):
'ns3::TypeId',
[],
is_static=True)
+ ## socket.h (module 'network'): static uint8_t ns3::Socket::IpTos2Priority(uint8_t ipTos) [member function]
+ cls.add_method('IpTos2Priority',
+ 'uint8_t',
+ [param('uint8_t', 'ipTos')],
+ is_static=True)
## socket.h (module 'network'): void ns3::Socket::Ipv6JoinGroup(ns3::Ipv6Address address, ns3::Socket::Ipv6MulticastFilterMode filterMode, std::vector > sourceAddresses) [member function]
cls.add_method('Ipv6JoinGroup',
'void',
@@ -4597,6 +4628,10 @@ def register_Ns3Socket_methods(root_module, cls):
cls.add_method('SetIpv6Tclass',
'void',
[param('int', 'ipTclass')])
+ ## socket.h (module 'network'): void ns3::Socket::SetPriority(uint8_t priority) [member function]
+ cls.add_method('SetPriority',
+ 'void',
+ [param('uint8_t', 'priority')])
## socket.h (module 'network'): void ns3::Socket::SetRecvCallback(ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> arg0) [member function]
cls.add_method('SetRecvCallback',
'void',
@@ -4624,11 +4659,6 @@ def register_Ns3Socket_methods(root_module, cls):
'void',
[],
visibility='protected', is_virtual=True)
- ## socket.h (module 'network'): bool ns3::Socket::IsManualIpTos() const [member function]
- cls.add_method('IsManualIpTos',
- 'bool',
- [],
- is_const=True, visibility='protected')
## socket.h (module 'network'): bool ns3::Socket::IsManualIpTtl() const [member function]
cls.add_method('IsManualIpTtl',
'bool',
@@ -4875,6 +4905,52 @@ def register_Ns3SocketIpv6TclassTag_methods(root_module, cls):
[param('uint8_t', 'tclass')])
return
+def register_Ns3SocketPriorityTag_methods(root_module, cls):
+ ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag(ns3::SocketPriorityTag const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::SocketPriorityTag const &', 'arg0')])
+ ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag() [constructor]
+ cls.add_constructor([])
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Deserialize(ns3::TagBuffer i) [member function]
+ cls.add_method('Deserialize',
+ 'void',
+ [param('ns3::TagBuffer', 'i')],
+ is_virtual=True)
+ ## socket.h (module 'network'): ns3::TypeId ns3::SocketPriorityTag::GetInstanceTypeId() const [member function]
+ cls.add_method('GetInstanceTypeId',
+ 'ns3::TypeId',
+ [],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): uint8_t ns3::SocketPriorityTag::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
+ ## socket.h (module 'network'): uint32_t ns3::SocketPriorityTag::GetSerializedSize() const [member function]
+ cls.add_method('GetSerializedSize',
+ 'uint32_t',
+ [],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): static ns3::TypeId ns3::SocketPriorityTag::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Print(std::ostream & os) const [member function]
+ cls.add_method('Print',
+ 'void',
+ [param('std::ostream &', 'os')],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Serialize(ns3::TagBuffer i) const [member function]
+ cls.add_method('Serialize',
+ 'void',
+ [param('ns3::TagBuffer', 'i')],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::SetPriority(uint8_t priority) [member function]
+ cls.add_method('SetPriority',
+ 'void',
+ [param('uint8_t', 'priority')])
+ return
+
def register_Ns3SocketSetDontFragmentTag_methods(root_module, cls):
## socket.h (module 'network'): ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag(ns3::SocketSetDontFragmentTag const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SocketSetDontFragmentTag const &', 'arg0')])
@@ -6960,11 +7036,6 @@ def register_Ns3NetDeviceQueue_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueue const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueue::NetDeviceQueue() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): bool ns3::NetDeviceQueue::HasWakeCallbackSet() const [member function]
- cls.add_method('HasWakeCallbackSet',
- 'bool',
- [],
- is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDeviceQueue::IsStopped() const [member function]
cls.add_method('IsStopped',
'bool',
@@ -6997,21 +7068,25 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueueInterface const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetSelectedQueue(ns3::Ptr item) const [member function]
- cls.add_method('GetSelectedQueue',
+ ## net-device.h (module 'network'): void ns3::NetDeviceQueueInterface::CreateTxQueues() [member function]
+ cls.add_method('CreateTxQueues',
+ 'void',
+ [])
+ ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetNTxQueues() const [member function]
+ cls.add_method('GetNTxQueues',
'uint8_t',
- [param('ns3::Ptr< ns3::QueueItem >', 'item')],
+ [],
+ is_const=True)
+ ## net-device.h (module 'network'): ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ns3::NetDeviceQueueInterface::GetSelectQueueCallback() const [member function]
+ cls.add_method('GetSelectQueueCallback',
+ 'ns3::Callback< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >',
+ [],
is_const=True)
## net-device.h (module 'network'): ns3::Ptr ns3::NetDeviceQueueInterface::GetTxQueue(uint8_t i) const [member function]
cls.add_method('GetTxQueue',
'ns3::Ptr< ns3::NetDeviceQueue >',
[param('uint8_t', 'i')],
is_const=True)
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetTxQueuesN() const [member function]
- cls.add_method('GetTxQueuesN',
- 'uint8_t',
- [],
- is_const=True)
## net-device.h (module 'network'): static ns3::TypeId ns3::NetDeviceQueueInterface::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
@@ -7416,6 +7491,11 @@ def register_Ns3QueueItem_methods(root_module, cls):
'uint32_t',
[],
is_const=True, is_virtual=True)
+ ## net-device.h (module 'network'): bool ns3::QueueItem::GetUint8Value(ns3::QueueItem::Uint8Values field, uint8_t & value) const [member function]
+ cls.add_method('GetUint8Value',
+ 'bool',
+ [param('ns3::QueueItem::Uint8Values', 'field'), param('uint8_t &', 'value')],
+ is_const=True, is_virtual=True)
## net-device.h (module 'network'): void ns3::QueueItem::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
diff --git a/src/csma/bindings/modulegen__gcc_ILP32.py b/src/csma/bindings/modulegen__gcc_ILP32.py
index cee81400aaf..9b365433496 100644
--- a/src/csma/bindings/modulegen__gcc_ILP32.py
+++ b/src/csma/bindings/modulegen__gcc_ILP32.py
@@ -304,6 +304,8 @@ def register_types(module):
module.add_class('ParetoRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream'])
## net-device.h (module 'network'): ns3::QueueItem [class]
module.add_class('QueueItem', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >'])
+ ## net-device.h (module 'network'): ns3::QueueItem::Uint8Values [enumeration]
+ module.add_enum('Uint8Values', ['IP_DSFIELD'], outer_class=root_module['ns3::QueueItem'], import_from_module='ns.network')
## error-model.h (module 'network'): ns3::RateErrorModel [class]
module.add_class('RateErrorModel', import_from_module='ns.network', parent=root_module['ns3::ErrorModel'])
## error-model.h (module 'network'): ns3::RateErrorModel::ErrorUnit [enumeration]
@@ -3062,6 +3064,11 @@ def register_Ns3Object_methods(root_module, cls):
cls.add_method('Initialize',
'void',
[])
+ ## object.h (module 'core'): bool ns3::Object::IsInitialized() const [member function]
+ cls.add_method('IsInitialized',
+ 'bool',
+ [],
+ is_const=True)
## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
cls.add_constructor([param('ns3::Object const &', 'o')],
visibility='protected')
@@ -5172,11 +5179,6 @@ def register_Ns3NetDeviceQueue_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueue const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueue::NetDeviceQueue() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): bool ns3::NetDeviceQueue::HasWakeCallbackSet() const [member function]
- cls.add_method('HasWakeCallbackSet',
- 'bool',
- [],
- is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDeviceQueue::IsStopped() const [member function]
cls.add_method('IsStopped',
'bool',
@@ -5209,21 +5211,25 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueueInterface const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetSelectedQueue(ns3::Ptr item) const [member function]
- cls.add_method('GetSelectedQueue',
+ ## net-device.h (module 'network'): void ns3::NetDeviceQueueInterface::CreateTxQueues() [member function]
+ cls.add_method('CreateTxQueues',
+ 'void',
+ [])
+ ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetNTxQueues() const [member function]
+ cls.add_method('GetNTxQueues',
'uint8_t',
- [param('ns3::Ptr< ns3::QueueItem >', 'item')],
+ [],
+ is_const=True)
+ ## net-device.h (module 'network'): ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ns3::NetDeviceQueueInterface::GetSelectQueueCallback() const [member function]
+ cls.add_method('GetSelectQueueCallback',
+ 'ns3::Callback< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >',
+ [],
is_const=True)
## net-device.h (module 'network'): ns3::Ptr ns3::NetDeviceQueueInterface::GetTxQueue(uint8_t i) const [member function]
cls.add_method('GetTxQueue',
'ns3::Ptr< ns3::NetDeviceQueue >',
[param('uint8_t', 'i')],
is_const=True)
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetTxQueuesN() const [member function]
- cls.add_method('GetTxQueuesN',
- 'uint8_t',
- [],
- is_const=True)
## net-device.h (module 'network'): static ns3::TypeId ns3::NetDeviceQueueInterface::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
@@ -5716,6 +5722,11 @@ def register_Ns3QueueItem_methods(root_module, cls):
'uint32_t',
[],
is_const=True, is_virtual=True)
+ ## net-device.h (module 'network'): bool ns3::QueueItem::GetUint8Value(ns3::QueueItem::Uint8Values field, uint8_t & value) const [member function]
+ cls.add_method('GetUint8Value',
+ 'bool',
+ [param('ns3::QueueItem::Uint8Values', 'field'), param('uint8_t &', 'value')],
+ is_const=True, is_virtual=True)
## net-device.h (module 'network'): void ns3::QueueItem::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
diff --git a/src/csma/bindings/modulegen__gcc_LP64.py b/src/csma/bindings/modulegen__gcc_LP64.py
index cee81400aaf..9b365433496 100644
--- a/src/csma/bindings/modulegen__gcc_LP64.py
+++ b/src/csma/bindings/modulegen__gcc_LP64.py
@@ -304,6 +304,8 @@ def register_types(module):
module.add_class('ParetoRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream'])
## net-device.h (module 'network'): ns3::QueueItem [class]
module.add_class('QueueItem', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >'])
+ ## net-device.h (module 'network'): ns3::QueueItem::Uint8Values [enumeration]
+ module.add_enum('Uint8Values', ['IP_DSFIELD'], outer_class=root_module['ns3::QueueItem'], import_from_module='ns.network')
## error-model.h (module 'network'): ns3::RateErrorModel [class]
module.add_class('RateErrorModel', import_from_module='ns.network', parent=root_module['ns3::ErrorModel'])
## error-model.h (module 'network'): ns3::RateErrorModel::ErrorUnit [enumeration]
@@ -3062,6 +3064,11 @@ def register_Ns3Object_methods(root_module, cls):
cls.add_method('Initialize',
'void',
[])
+ ## object.h (module 'core'): bool ns3::Object::IsInitialized() const [member function]
+ cls.add_method('IsInitialized',
+ 'bool',
+ [],
+ is_const=True)
## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
cls.add_constructor([param('ns3::Object const &', 'o')],
visibility='protected')
@@ -5172,11 +5179,6 @@ def register_Ns3NetDeviceQueue_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueue const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueue::NetDeviceQueue() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): bool ns3::NetDeviceQueue::HasWakeCallbackSet() const [member function]
- cls.add_method('HasWakeCallbackSet',
- 'bool',
- [],
- is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDeviceQueue::IsStopped() const [member function]
cls.add_method('IsStopped',
'bool',
@@ -5209,21 +5211,25 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueueInterface const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetSelectedQueue(ns3::Ptr item) const [member function]
- cls.add_method('GetSelectedQueue',
+ ## net-device.h (module 'network'): void ns3::NetDeviceQueueInterface::CreateTxQueues() [member function]
+ cls.add_method('CreateTxQueues',
+ 'void',
+ [])
+ ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetNTxQueues() const [member function]
+ cls.add_method('GetNTxQueues',
'uint8_t',
- [param('ns3::Ptr< ns3::QueueItem >', 'item')],
+ [],
+ is_const=True)
+ ## net-device.h (module 'network'): ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ns3::NetDeviceQueueInterface::GetSelectQueueCallback() const [member function]
+ cls.add_method('GetSelectQueueCallback',
+ 'ns3::Callback< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >',
+ [],
is_const=True)
## net-device.h (module 'network'): ns3::Ptr ns3::NetDeviceQueueInterface::GetTxQueue(uint8_t i) const [member function]
cls.add_method('GetTxQueue',
'ns3::Ptr< ns3::NetDeviceQueue >',
[param('uint8_t', 'i')],
is_const=True)
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetTxQueuesN() const [member function]
- cls.add_method('GetTxQueuesN',
- 'uint8_t',
- [],
- is_const=True)
## net-device.h (module 'network'): static ns3::TypeId ns3::NetDeviceQueueInterface::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
@@ -5716,6 +5722,11 @@ def register_Ns3QueueItem_methods(root_module, cls):
'uint32_t',
[],
is_const=True, is_virtual=True)
+ ## net-device.h (module 'network'): bool ns3::QueueItem::GetUint8Value(ns3::QueueItem::Uint8Values field, uint8_t & value) const [member function]
+ cls.add_method('GetUint8Value',
+ 'bool',
+ [param('ns3::QueueItem::Uint8Values', 'field'), param('uint8_t &', 'value')],
+ is_const=True, is_virtual=True)
## net-device.h (module 'network'): void ns3::QueueItem::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
diff --git a/src/dsdv/bindings/callbacks_list.py b/src/dsdv/bindings/callbacks_list.py
index e9e49362dbf..daa353213df 100644
--- a/src/dsdv/bindings/callbacks_list.py
+++ b/src/dsdv/bindings/callbacks_list.py
@@ -1,4 +1,5 @@
callback_classes = [
+ ['unsigned char', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['void', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['void', 'ns3::Ptr', 'ns3::Ipv4Header const&', 'ns3::Socket::SocketErrno', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
@@ -8,5 +9,4 @@
['void', 'ns3::Ptr', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['bool', 'ns3::Ptr', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['void', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'ns3::Address const&', 'ns3::Address const&', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
- ['unsigned char', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
]
diff --git a/src/dsdv/bindings/modulegen__gcc_ILP32.py b/src/dsdv/bindings/modulegen__gcc_ILP32.py
index f5b260871a7..faf1e5a71a5 100644
--- a/src/dsdv/bindings/modulegen__gcc_ILP32.py
+++ b/src/dsdv/bindings/modulegen__gcc_ILP32.py
@@ -234,6 +234,8 @@ def register_types(module):
module.add_enum('SocketErrno', ['ERROR_NOTERROR', 'ERROR_ISCONN', 'ERROR_NOTCONN', 'ERROR_MSGSIZE', 'ERROR_AGAIN', 'ERROR_SHUTDOWN', 'ERROR_OPNOTSUPP', 'ERROR_AFNOSUPPORT', 'ERROR_INVAL', 'ERROR_BADF', 'ERROR_NOROUTETOHOST', 'ERROR_NODEV', 'ERROR_ADDRNOTAVAIL', 'ERROR_ADDRINUSE', 'SOCKET_ERRNO_LAST'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::SocketType [enumeration]
module.add_enum('SocketType', ['NS3_SOCK_STREAM', 'NS3_SOCK_SEQPACKET', 'NS3_SOCK_DGRAM', 'NS3_SOCK_RAW'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
+ ## socket.h (module 'network'): ns3::Socket::SocketPriority [enumeration]
+ module.add_enum('SocketPriority', ['NS3_PRIO_BESTEFFORT', 'NS3_PRIO_FILLER', 'NS3_PRIO_BULK', 'NS3_PRIO_INTERACTIVE_BULK', 'NS3_PRIO_INTERACTIVE', 'NS3_PRIO_CONTROL'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::Ipv6MulticastFilterMode [enumeration]
module.add_enum('Ipv6MulticastFilterMode', ['INCLUDE', 'EXCLUDE'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::SocketIpTosTag [class]
@@ -244,6 +246,8 @@ def register_types(module):
module.add_class('SocketIpv6HopLimitTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketIpv6TclassTag [class]
module.add_class('SocketIpv6TclassTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
+ ## socket.h (module 'network'): ns3::SocketPriorityTag [class]
+ module.add_class('SocketPriorityTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketSetDontFragmentTag [class]
module.add_class('SocketSetDontFragmentTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## nstime.h (module 'core'): ns3::Time [class]
@@ -370,6 +374,8 @@ def register_types(module):
module.add_class('ParetoRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream'])
## net-device.h (module 'network'): ns3::QueueItem [class]
module.add_class('QueueItem', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >'])
+ ## net-device.h (module 'network'): ns3::QueueItem::Uint8Values [enumeration]
+ module.add_enum('Uint8Values', ['IP_DSFIELD'], outer_class=root_module['ns3::QueueItem'], import_from_module='ns.network')
## nstime.h (module 'core'): ns3::TimeValue [class]
module.add_class('TimeValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
## type-id.h (module 'core'): ns3::TypeIdChecker [class]
@@ -593,6 +599,7 @@ def register_methods(root_module):
register_Ns3SocketIpTtlTag_methods(root_module, root_module['ns3::SocketIpTtlTag'])
register_Ns3SocketIpv6HopLimitTag_methods(root_module, root_module['ns3::SocketIpv6HopLimitTag'])
register_Ns3SocketIpv6TclassTag_methods(root_module, root_module['ns3::SocketIpv6TclassTag'])
+ register_Ns3SocketPriorityTag_methods(root_module, root_module['ns3::SocketPriorityTag'])
register_Ns3SocketSetDontFragmentTag_methods(root_module, root_module['ns3::SocketSetDontFragmentTag'])
register_Ns3Time_methods(root_module, root_module['ns3::Time'])
register_Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::TraceSourceAccessor'])
@@ -1288,6 +1295,11 @@ def register_Ns3InetSocketAddress_methods(root_module, cls):
'uint16_t',
[],
is_const=True)
+ ## inet-socket-address.h (module 'network'): uint8_t ns3::InetSocketAddress::GetTos() const [member function]
+ cls.add_method('GetTos',
+ 'uint8_t',
+ [],
+ is_const=True)
## inet-socket-address.h (module 'network'): static bool ns3::InetSocketAddress::IsMatchingType(ns3::Address const & address) [member function]
cls.add_method('IsMatchingType',
'bool',
@@ -1301,6 +1313,10 @@ def register_Ns3InetSocketAddress_methods(root_module, cls):
cls.add_method('SetPort',
'void',
[param('uint16_t', 'port')])
+ ## inet-socket-address.h (module 'network'): void ns3::InetSocketAddress::SetTos(uint8_t tos) [member function]
+ cls.add_method('SetTos',
+ 'void',
+ [param('uint8_t', 'tos')])
return
def register_Ns3IntToType__0_methods(root_module, cls):
@@ -3214,6 +3230,11 @@ def register_Ns3Object_methods(root_module, cls):
cls.add_method('Initialize',
'void',
[])
+ ## object.h (module 'core'): bool ns3::Object::IsInitialized() const [member function]
+ cls.add_method('IsInitialized',
+ 'bool',
+ [],
+ is_const=True)
## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
cls.add_constructor([param('ns3::Object const &', 'o')],
visibility='protected')
@@ -3952,6 +3973,11 @@ def register_Ns3Socket_methods(root_module, cls):
'int',
[param('ns3::Address &', 'address')],
is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): uint8_t ns3::Socket::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
## socket.h (module 'network'): uint32_t ns3::Socket::GetRxAvailable() const [member function]
cls.add_method('GetRxAvailable',
'uint32_t',
@@ -3977,6 +4003,11 @@ def register_Ns3Socket_methods(root_module, cls):
'ns3::TypeId',
[],
is_static=True)
+ ## socket.h (module 'network'): static uint8_t ns3::Socket::IpTos2Priority(uint8_t ipTos) [member function]
+ cls.add_method('IpTos2Priority',
+ 'uint8_t',
+ [param('uint8_t', 'ipTos')],
+ is_static=True)
## socket.h (module 'network'): void ns3::Socket::Ipv6JoinGroup(ns3::Ipv6Address address, ns3::Socket::Ipv6MulticastFilterMode filterMode, std::vector > sourceAddresses) [member function]
cls.add_method('Ipv6JoinGroup',
'void',
@@ -4125,6 +4156,10 @@ def register_Ns3Socket_methods(root_module, cls):
cls.add_method('SetIpv6Tclass',
'void',
[param('int', 'ipTclass')])
+ ## socket.h (module 'network'): void ns3::Socket::SetPriority(uint8_t priority) [member function]
+ cls.add_method('SetPriority',
+ 'void',
+ [param('uint8_t', 'priority')])
## socket.h (module 'network'): void ns3::Socket::SetRecvCallback(ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> arg0) [member function]
cls.add_method('SetRecvCallback',
'void',
@@ -4152,11 +4187,6 @@ def register_Ns3Socket_methods(root_module, cls):
'void',
[],
visibility='protected', is_virtual=True)
- ## socket.h (module 'network'): bool ns3::Socket::IsManualIpTos() const [member function]
- cls.add_method('IsManualIpTos',
- 'bool',
- [],
- is_const=True, visibility='protected')
## socket.h (module 'network'): bool ns3::Socket::IsManualIpTtl() const [member function]
cls.add_method('IsManualIpTtl',
'bool',
@@ -4403,6 +4433,52 @@ def register_Ns3SocketIpv6TclassTag_methods(root_module, cls):
[param('uint8_t', 'tclass')])
return
+def register_Ns3SocketPriorityTag_methods(root_module, cls):
+ ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag(ns3::SocketPriorityTag const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::SocketPriorityTag const &', 'arg0')])
+ ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag() [constructor]
+ cls.add_constructor([])
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Deserialize(ns3::TagBuffer i) [member function]
+ cls.add_method('Deserialize',
+ 'void',
+ [param('ns3::TagBuffer', 'i')],
+ is_virtual=True)
+ ## socket.h (module 'network'): ns3::TypeId ns3::SocketPriorityTag::GetInstanceTypeId() const [member function]
+ cls.add_method('GetInstanceTypeId',
+ 'ns3::TypeId',
+ [],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): uint8_t ns3::SocketPriorityTag::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
+ ## socket.h (module 'network'): uint32_t ns3::SocketPriorityTag::GetSerializedSize() const [member function]
+ cls.add_method('GetSerializedSize',
+ 'uint32_t',
+ [],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): static ns3::TypeId ns3::SocketPriorityTag::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Print(std::ostream & os) const [member function]
+ cls.add_method('Print',
+ 'void',
+ [param('std::ostream &', 'os')],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Serialize(ns3::TagBuffer i) const [member function]
+ cls.add_method('Serialize',
+ 'void',
+ [param('ns3::TagBuffer', 'i')],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::SetPriority(uint8_t priority) [member function]
+ cls.add_method('SetPriority',
+ 'void',
+ [param('uint8_t', 'priority')])
+ return
+
def register_Ns3SocketSetDontFragmentTag_methods(root_module, cls):
## socket.h (module 'network'): ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag(ns3::SocketSetDontFragmentTag const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SocketSetDontFragmentTag const &', 'arg0')])
@@ -6619,11 +6695,6 @@ def register_Ns3NetDeviceQueue_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueue const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueue::NetDeviceQueue() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): bool ns3::NetDeviceQueue::HasWakeCallbackSet() const [member function]
- cls.add_method('HasWakeCallbackSet',
- 'bool',
- [],
- is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDeviceQueue::IsStopped() const [member function]
cls.add_method('IsStopped',
'bool',
@@ -6656,21 +6727,25 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueueInterface const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetSelectedQueue(ns3::Ptr item) const [member function]
- cls.add_method('GetSelectedQueue',
+ ## net-device.h (module 'network'): void ns3::NetDeviceQueueInterface::CreateTxQueues() [member function]
+ cls.add_method('CreateTxQueues',
+ 'void',
+ [])
+ ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetNTxQueues() const [member function]
+ cls.add_method('GetNTxQueues',
'uint8_t',
- [param('ns3::Ptr< ns3::QueueItem >', 'item')],
+ [],
+ is_const=True)
+ ## net-device.h (module 'network'): ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ns3::NetDeviceQueueInterface::GetSelectQueueCallback() const [member function]
+ cls.add_method('GetSelectQueueCallback',
+ 'ns3::Callback< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >',
+ [],
is_const=True)
## net-device.h (module 'network'): ns3::Ptr ns3::NetDeviceQueueInterface::GetTxQueue(uint8_t i) const [member function]
cls.add_method('GetTxQueue',
'ns3::Ptr< ns3::NetDeviceQueue >',
[param('uint8_t', 'i')],
is_const=True)
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetTxQueuesN() const [member function]
- cls.add_method('GetTxQueuesN',
- 'uint8_t',
- [],
- is_const=True)
## net-device.h (module 'network'): static ns3::TypeId ns3::NetDeviceQueueInterface::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
@@ -7163,6 +7238,11 @@ def register_Ns3QueueItem_methods(root_module, cls):
'uint32_t',
[],
is_const=True, is_virtual=True)
+ ## net-device.h (module 'network'): bool ns3::QueueItem::GetUint8Value(ns3::QueueItem::Uint8Values field, uint8_t & value) const [member function]
+ cls.add_method('GetUint8Value',
+ 'bool',
+ [param('ns3::QueueItem::Uint8Values', 'field'), param('uint8_t &', 'value')],
+ is_const=True, is_virtual=True)
## net-device.h (module 'network'): void ns3::QueueItem::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
diff --git a/src/dsdv/bindings/modulegen__gcc_LP64.py b/src/dsdv/bindings/modulegen__gcc_LP64.py
index f5b260871a7..faf1e5a71a5 100644
--- a/src/dsdv/bindings/modulegen__gcc_LP64.py
+++ b/src/dsdv/bindings/modulegen__gcc_LP64.py
@@ -234,6 +234,8 @@ def register_types(module):
module.add_enum('SocketErrno', ['ERROR_NOTERROR', 'ERROR_ISCONN', 'ERROR_NOTCONN', 'ERROR_MSGSIZE', 'ERROR_AGAIN', 'ERROR_SHUTDOWN', 'ERROR_OPNOTSUPP', 'ERROR_AFNOSUPPORT', 'ERROR_INVAL', 'ERROR_BADF', 'ERROR_NOROUTETOHOST', 'ERROR_NODEV', 'ERROR_ADDRNOTAVAIL', 'ERROR_ADDRINUSE', 'SOCKET_ERRNO_LAST'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::SocketType [enumeration]
module.add_enum('SocketType', ['NS3_SOCK_STREAM', 'NS3_SOCK_SEQPACKET', 'NS3_SOCK_DGRAM', 'NS3_SOCK_RAW'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
+ ## socket.h (module 'network'): ns3::Socket::SocketPriority [enumeration]
+ module.add_enum('SocketPriority', ['NS3_PRIO_BESTEFFORT', 'NS3_PRIO_FILLER', 'NS3_PRIO_BULK', 'NS3_PRIO_INTERACTIVE_BULK', 'NS3_PRIO_INTERACTIVE', 'NS3_PRIO_CONTROL'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::Ipv6MulticastFilterMode [enumeration]
module.add_enum('Ipv6MulticastFilterMode', ['INCLUDE', 'EXCLUDE'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::SocketIpTosTag [class]
@@ -244,6 +246,8 @@ def register_types(module):
module.add_class('SocketIpv6HopLimitTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketIpv6TclassTag [class]
module.add_class('SocketIpv6TclassTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
+ ## socket.h (module 'network'): ns3::SocketPriorityTag [class]
+ module.add_class('SocketPriorityTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketSetDontFragmentTag [class]
module.add_class('SocketSetDontFragmentTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## nstime.h (module 'core'): ns3::Time [class]
@@ -370,6 +374,8 @@ def register_types(module):
module.add_class('ParetoRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream'])
## net-device.h (module 'network'): ns3::QueueItem [class]
module.add_class('QueueItem', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >'])
+ ## net-device.h (module 'network'): ns3::QueueItem::Uint8Values [enumeration]
+ module.add_enum('Uint8Values', ['IP_DSFIELD'], outer_class=root_module['ns3::QueueItem'], import_from_module='ns.network')
## nstime.h (module 'core'): ns3::TimeValue [class]
module.add_class('TimeValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
## type-id.h (module 'core'): ns3::TypeIdChecker [class]
@@ -593,6 +599,7 @@ def register_methods(root_module):
register_Ns3SocketIpTtlTag_methods(root_module, root_module['ns3::SocketIpTtlTag'])
register_Ns3SocketIpv6HopLimitTag_methods(root_module, root_module['ns3::SocketIpv6HopLimitTag'])
register_Ns3SocketIpv6TclassTag_methods(root_module, root_module['ns3::SocketIpv6TclassTag'])
+ register_Ns3SocketPriorityTag_methods(root_module, root_module['ns3::SocketPriorityTag'])
register_Ns3SocketSetDontFragmentTag_methods(root_module, root_module['ns3::SocketSetDontFragmentTag'])
register_Ns3Time_methods(root_module, root_module['ns3::Time'])
register_Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::TraceSourceAccessor'])
@@ -1288,6 +1295,11 @@ def register_Ns3InetSocketAddress_methods(root_module, cls):
'uint16_t',
[],
is_const=True)
+ ## inet-socket-address.h (module 'network'): uint8_t ns3::InetSocketAddress::GetTos() const [member function]
+ cls.add_method('GetTos',
+ 'uint8_t',
+ [],
+ is_const=True)
## inet-socket-address.h (module 'network'): static bool ns3::InetSocketAddress::IsMatchingType(ns3::Address const & address) [member function]
cls.add_method('IsMatchingType',
'bool',
@@ -1301,6 +1313,10 @@ def register_Ns3InetSocketAddress_methods(root_module, cls):
cls.add_method('SetPort',
'void',
[param('uint16_t', 'port')])
+ ## inet-socket-address.h (module 'network'): void ns3::InetSocketAddress::SetTos(uint8_t tos) [member function]
+ cls.add_method('SetTos',
+ 'void',
+ [param('uint8_t', 'tos')])
return
def register_Ns3IntToType__0_methods(root_module, cls):
@@ -3214,6 +3230,11 @@ def register_Ns3Object_methods(root_module, cls):
cls.add_method('Initialize',
'void',
[])
+ ## object.h (module 'core'): bool ns3::Object::IsInitialized() const [member function]
+ cls.add_method('IsInitialized',
+ 'bool',
+ [],
+ is_const=True)
## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
cls.add_constructor([param('ns3::Object const &', 'o')],
visibility='protected')
@@ -3952,6 +3973,11 @@ def register_Ns3Socket_methods(root_module, cls):
'int',
[param('ns3::Address &', 'address')],
is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): uint8_t ns3::Socket::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
## socket.h (module 'network'): uint32_t ns3::Socket::GetRxAvailable() const [member function]
cls.add_method('GetRxAvailable',
'uint32_t',
@@ -3977,6 +4003,11 @@ def register_Ns3Socket_methods(root_module, cls):
'ns3::TypeId',
[],
is_static=True)
+ ## socket.h (module 'network'): static uint8_t ns3::Socket::IpTos2Priority(uint8_t ipTos) [member function]
+ cls.add_method('IpTos2Priority',
+ 'uint8_t',
+ [param('uint8_t', 'ipTos')],
+ is_static=True)
## socket.h (module 'network'): void ns3::Socket::Ipv6JoinGroup(ns3::Ipv6Address address, ns3::Socket::Ipv6MulticastFilterMode filterMode, std::vector > sourceAddresses) [member function]
cls.add_method('Ipv6JoinGroup',
'void',
@@ -4125,6 +4156,10 @@ def register_Ns3Socket_methods(root_module, cls):
cls.add_method('SetIpv6Tclass',
'void',
[param('int', 'ipTclass')])
+ ## socket.h (module 'network'): void ns3::Socket::SetPriority(uint8_t priority) [member function]
+ cls.add_method('SetPriority',
+ 'void',
+ [param('uint8_t', 'priority')])
## socket.h (module 'network'): void ns3::Socket::SetRecvCallback(ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> arg0) [member function]
cls.add_method('SetRecvCallback',
'void',
@@ -4152,11 +4187,6 @@ def register_Ns3Socket_methods(root_module, cls):
'void',
[],
visibility='protected', is_virtual=True)
- ## socket.h (module 'network'): bool ns3::Socket::IsManualIpTos() const [member function]
- cls.add_method('IsManualIpTos',
- 'bool',
- [],
- is_const=True, visibility='protected')
## socket.h (module 'network'): bool ns3::Socket::IsManualIpTtl() const [member function]
cls.add_method('IsManualIpTtl',
'bool',
@@ -4403,6 +4433,52 @@ def register_Ns3SocketIpv6TclassTag_methods(root_module, cls):
[param('uint8_t', 'tclass')])
return
+def register_Ns3SocketPriorityTag_methods(root_module, cls):
+ ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag(ns3::SocketPriorityTag const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::SocketPriorityTag const &', 'arg0')])
+ ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag() [constructor]
+ cls.add_constructor([])
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Deserialize(ns3::TagBuffer i) [member function]
+ cls.add_method('Deserialize',
+ 'void',
+ [param('ns3::TagBuffer', 'i')],
+ is_virtual=True)
+ ## socket.h (module 'network'): ns3::TypeId ns3::SocketPriorityTag::GetInstanceTypeId() const [member function]
+ cls.add_method('GetInstanceTypeId',
+ 'ns3::TypeId',
+ [],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): uint8_t ns3::SocketPriorityTag::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
+ ## socket.h (module 'network'): uint32_t ns3::SocketPriorityTag::GetSerializedSize() const [member function]
+ cls.add_method('GetSerializedSize',
+ 'uint32_t',
+ [],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): static ns3::TypeId ns3::SocketPriorityTag::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Print(std::ostream & os) const [member function]
+ cls.add_method('Print',
+ 'void',
+ [param('std::ostream &', 'os')],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Serialize(ns3::TagBuffer i) const [member function]
+ cls.add_method('Serialize',
+ 'void',
+ [param('ns3::TagBuffer', 'i')],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::SetPriority(uint8_t priority) [member function]
+ cls.add_method('SetPriority',
+ 'void',
+ [param('uint8_t', 'priority')])
+ return
+
def register_Ns3SocketSetDontFragmentTag_methods(root_module, cls):
## socket.h (module 'network'): ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag(ns3::SocketSetDontFragmentTag const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SocketSetDontFragmentTag const &', 'arg0')])
@@ -6619,11 +6695,6 @@ def register_Ns3NetDeviceQueue_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueue const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueue::NetDeviceQueue() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): bool ns3::NetDeviceQueue::HasWakeCallbackSet() const [member function]
- cls.add_method('HasWakeCallbackSet',
- 'bool',
- [],
- is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDeviceQueue::IsStopped() const [member function]
cls.add_method('IsStopped',
'bool',
@@ -6656,21 +6727,25 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueueInterface const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetSelectedQueue(ns3::Ptr item) const [member function]
- cls.add_method('GetSelectedQueue',
+ ## net-device.h (module 'network'): void ns3::NetDeviceQueueInterface::CreateTxQueues() [member function]
+ cls.add_method('CreateTxQueues',
+ 'void',
+ [])
+ ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetNTxQueues() const [member function]
+ cls.add_method('GetNTxQueues',
'uint8_t',
- [param('ns3::Ptr< ns3::QueueItem >', 'item')],
+ [],
+ is_const=True)
+ ## net-device.h (module 'network'): ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ns3::NetDeviceQueueInterface::GetSelectQueueCallback() const [member function]
+ cls.add_method('GetSelectQueueCallback',
+ 'ns3::Callback< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >',
+ [],
is_const=True)
## net-device.h (module 'network'): ns3::Ptr ns3::NetDeviceQueueInterface::GetTxQueue(uint8_t i) const [member function]
cls.add_method('GetTxQueue',
'ns3::Ptr< ns3::NetDeviceQueue >',
[param('uint8_t', 'i')],
is_const=True)
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetTxQueuesN() const [member function]
- cls.add_method('GetTxQueuesN',
- 'uint8_t',
- [],
- is_const=True)
## net-device.h (module 'network'): static ns3::TypeId ns3::NetDeviceQueueInterface::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
@@ -7163,6 +7238,11 @@ def register_Ns3QueueItem_methods(root_module, cls):
'uint32_t',
[],
is_const=True, is_virtual=True)
+ ## net-device.h (module 'network'): bool ns3::QueueItem::GetUint8Value(ns3::QueueItem::Uint8Values field, uint8_t & value) const [member function]
+ cls.add_method('GetUint8Value',
+ 'bool',
+ [param('ns3::QueueItem::Uint8Values', 'field'), param('uint8_t &', 'value')],
+ is_const=True, is_virtual=True)
## net-device.h (module 'network'): void ns3::QueueItem::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
diff --git a/src/dsr/bindings/callbacks_list.py b/src/dsr/bindings/callbacks_list.py
index a2a397a79f2..e7c01c617cc 100644
--- a/src/dsr/bindings/callbacks_list.py
+++ b/src/dsr/bindings/callbacks_list.py
@@ -4,6 +4,7 @@
['void', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['void', 'ns3::Ipv4Address', 'unsigned char', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['void', 'ns3::Ptr', 'ns3::Ipv4Address', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
+ ['unsigned char', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['void', 'ns3::Ptr', 'ns3::Ipv4Address', 'ns3::Ipv4Address', 'unsigned char', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['void', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'ns3::Address const&', 'ns3::Address const&', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
@@ -11,5 +12,4 @@
['void', 'ns3::Ptr', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['void', 'ns3::Ptr', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['bool', 'ns3::Ptr', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
- ['unsigned char', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
]
diff --git a/src/dsr/bindings/modulegen__gcc_ILP32.py b/src/dsr/bindings/modulegen__gcc_ILP32.py
index 61a26dba86e..c9083943be9 100644
--- a/src/dsr/bindings/modulegen__gcc_ILP32.py
+++ b/src/dsr/bindings/modulegen__gcc_ILP32.py
@@ -29,7 +29,7 @@ def register_types(module):
## wifi-mode.h (module 'wifi'): ns3::WifiModulationClass [enumeration]
module.add_enum('WifiModulationClass', ['WIFI_MOD_CLASS_UNKNOWN', 'WIFI_MOD_CLASS_IR', 'WIFI_MOD_CLASS_FHSS', 'WIFI_MOD_CLASS_DSSS', 'WIFI_MOD_CLASS_HR_DSSS', 'WIFI_MOD_CLASS_ERP_PBCC', 'WIFI_MOD_CLASS_DSSS_OFDM', 'WIFI_MOD_CLASS_ERP_OFDM', 'WIFI_MOD_CLASS_OFDM', 'WIFI_MOD_CLASS_HT', 'WIFI_MOD_CLASS_VHT'], import_from_module='ns.wifi')
## wifi-phy-standard.h (module 'wifi'): ns3::WifiPhyStandard [enumeration]
- module.add_enum('WifiPhyStandard', ['WIFI_PHY_STANDARD_80211a', 'WIFI_PHY_STANDARD_80211b', 'WIFI_PHY_STANDARD_80211g', 'WIFI_PHY_STANDARD_80211_10MHZ', 'WIFI_PHY_STANDARD_80211_5MHZ', 'WIFI_PHY_STANDARD_holland', 'WIFI_PHY_STANDARD_80211n_2_4GHZ', 'WIFI_PHY_STANDARD_80211n_5GHZ', 'WIFI_PHY_STANDARD_80211ac'], import_from_module='ns.wifi')
+ module.add_enum('WifiPhyStandard', ['WIFI_PHY_STANDARD_80211a', 'WIFI_PHY_STANDARD_80211b', 'WIFI_PHY_STANDARD_80211g', 'WIFI_PHY_STANDARD_80211_10MHZ', 'WIFI_PHY_STANDARD_80211_5MHZ', 'WIFI_PHY_STANDARD_holland', 'WIFI_PHY_STANDARD_80211n_2_4GHZ', 'WIFI_PHY_STANDARD_80211n_5GHZ', 'WIFI_PHY_STANDARD_80211ac', 'WIFI_PHY_STANDARD_UNSPECIFIED'], import_from_module='ns.wifi')
## wifi-mode.h (module 'wifi'): ns3::WifiCodeRate [enumeration]
module.add_enum('WifiCodeRate', ['WIFI_CODE_RATE_UNDEFINED', 'WIFI_CODE_RATE_3_4', 'WIFI_CODE_RATE_2_3', 'WIFI_CODE_RATE_1_2', 'WIFI_CODE_RATE_5_6'], import_from_module='ns.wifi')
## qos-utils.h (module 'wifi'): ns3::AcIndex [enumeration]
@@ -118,12 +118,6 @@ def register_types(module):
module.add_class('Ipv6Address', import_from_module='ns.network')
## ipv6-address.h (module 'network'): ns3::Ipv6Address [class]
root_module['ns3::Ipv6Address'].implicitly_converts_to(root_module['ns3::Address'])
- ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress [class]
- module.add_class('Ipv6InterfaceAddress', import_from_module='ns.internet')
- ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::State_e [enumeration]
- module.add_enum('State_e', ['TENTATIVE', 'DEPRECATED', 'PREFERRED', 'PERMANENT', 'HOMEADDRESS', 'TENTATIVE_OPTIMISTIC', 'INVALID'], outer_class=root_module['ns3::Ipv6InterfaceAddress'], import_from_module='ns.internet')
- ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::Scope_e [enumeration]
- module.add_enum('Scope_e', ['HOST', 'LINKLOCAL', 'GLOBAL'], outer_class=root_module['ns3::Ipv6InterfaceAddress'], import_from_module='ns.internet')
## ipv6-address.h (module 'network'): ns3::Ipv6Prefix [class]
module.add_class('Ipv6Prefix', import_from_module='ns.network')
## mac48-address.h (module 'network'): ns3::Mac48Address [class]
@@ -302,6 +296,8 @@ def register_types(module):
module.add_enum('SocketErrno', ['ERROR_NOTERROR', 'ERROR_ISCONN', 'ERROR_NOTCONN', 'ERROR_MSGSIZE', 'ERROR_AGAIN', 'ERROR_SHUTDOWN', 'ERROR_OPNOTSUPP', 'ERROR_AFNOSUPPORT', 'ERROR_INVAL', 'ERROR_BADF', 'ERROR_NOROUTETOHOST', 'ERROR_NODEV', 'ERROR_ADDRNOTAVAIL', 'ERROR_ADDRINUSE', 'SOCKET_ERRNO_LAST'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::SocketType [enumeration]
module.add_enum('SocketType', ['NS3_SOCK_STREAM', 'NS3_SOCK_SEQPACKET', 'NS3_SOCK_DGRAM', 'NS3_SOCK_RAW'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
+ ## socket.h (module 'network'): ns3::Socket::SocketPriority [enumeration]
+ module.add_enum('SocketPriority', ['NS3_PRIO_BESTEFFORT', 'NS3_PRIO_FILLER', 'NS3_PRIO_BULK', 'NS3_PRIO_INTERACTIVE_BULK', 'NS3_PRIO_INTERACTIVE', 'NS3_PRIO_CONTROL'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::Ipv6MulticastFilterMode [enumeration]
module.add_enum('Ipv6MulticastFilterMode', ['INCLUDE', 'EXCLUDE'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::SocketIpTosTag [class]
@@ -312,6 +308,8 @@ def register_types(module):
module.add_class('SocketIpv6HopLimitTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketIpv6TclassTag [class]
module.add_class('SocketIpv6TclassTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
+ ## socket.h (module 'network'): ns3::SocketPriorityTag [class]
+ module.add_class('SocketPriorityTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketSetDontFragmentTag [class]
module.add_class('SocketSetDontFragmentTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## nstime.h (module 'core'): ns3::Time [class]
@@ -434,8 +432,6 @@ def register_types(module):
module.add_class('Ipv6AddressChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker'])
## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue [class]
module.add_class('Ipv6AddressValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue'])
- ## ipv6-interface.h (module 'internet'): ns3::Ipv6Interface [class]
- module.add_class('Ipv6Interface', import_from_module='ns.internet', parent=root_module['ns3::Object'])
## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker [class]
module.add_class('Ipv6PrefixChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker'])
## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue [class]
@@ -472,6 +468,8 @@ def register_types(module):
module.add_class('ParetoRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream'])
## net-device.h (module 'network'): ns3::QueueItem [class]
module.add_class('QueueItem', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >'])
+ ## net-device.h (module 'network'): ns3::QueueItem::Uint8Values [enumeration]
+ module.add_enum('Uint8Values', ['IP_DSFIELD'], outer_class=root_module['ns3::QueueItem'], import_from_module='ns.network')
## ssid.h (module 'wifi'): ns3::Ssid [class]
module.add_class('Ssid', import_from_module='ns.wifi', parent=root_module['ns3::WifiInformationElement'])
## ssid.h (module 'wifi'): ns3::SsidChecker [class]
@@ -786,7 +784,6 @@ def register_methods(root_module):
register_Ns3Ipv4InterfaceAddress_methods(root_module, root_module['ns3::Ipv4InterfaceAddress'])
register_Ns3Ipv4Mask_methods(root_module, root_module['ns3::Ipv4Mask'])
register_Ns3Ipv6Address_methods(root_module, root_module['ns3::Ipv6Address'])
- register_Ns3Ipv6InterfaceAddress_methods(root_module, root_module['ns3::Ipv6InterfaceAddress'])
register_Ns3Ipv6Prefix_methods(root_module, root_module['ns3::Ipv6Prefix'])
register_Ns3Mac48Address_methods(root_module, root_module['ns3::Mac48Address'])
register_Ns3NodeContainer_methods(root_module, root_module['ns3::NodeContainer'])
@@ -860,6 +857,7 @@ def register_methods(root_module):
register_Ns3SocketIpTtlTag_methods(root_module, root_module['ns3::SocketIpTtlTag'])
register_Ns3SocketIpv6HopLimitTag_methods(root_module, root_module['ns3::SocketIpv6HopLimitTag'])
register_Ns3SocketIpv6TclassTag_methods(root_module, root_module['ns3::SocketIpv6TclassTag'])
+ register_Ns3SocketPriorityTag_methods(root_module, root_module['ns3::SocketPriorityTag'])
register_Ns3SocketSetDontFragmentTag_methods(root_module, root_module['ns3::SocketSetDontFragmentTag'])
register_Ns3Time_methods(root_module, root_module['ns3::Time'])
register_Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::TraceSourceAccessor'])
@@ -913,7 +911,6 @@ def register_methods(root_module):
register_Ns3Ipv4RoutingProtocol_methods(root_module, root_module['ns3::Ipv4RoutingProtocol'])
register_Ns3Ipv6AddressChecker_methods(root_module, root_module['ns3::Ipv6AddressChecker'])
register_Ns3Ipv6AddressValue_methods(root_module, root_module['ns3::Ipv6AddressValue'])
- register_Ns3Ipv6Interface_methods(root_module, root_module['ns3::Ipv6Interface'])
register_Ns3Ipv6PrefixChecker_methods(root_module, root_module['ns3::Ipv6PrefixChecker'])
register_Ns3Ipv6PrefixValue_methods(root_module, root_module['ns3::Ipv6PrefixValue'])
register_Ns3LogNormalRandomVariable_methods(root_module, root_module['ns3::LogNormalRandomVariable'])
@@ -1668,6 +1665,11 @@ def register_Ns3InetSocketAddress_methods(root_module, cls):
'uint16_t',
[],
is_const=True)
+ ## inet-socket-address.h (module 'network'): uint8_t ns3::InetSocketAddress::GetTos() const [member function]
+ cls.add_method('GetTos',
+ 'uint8_t',
+ [],
+ is_const=True)
## inet-socket-address.h (module 'network'): static bool ns3::InetSocketAddress::IsMatchingType(ns3::Address const & address) [member function]
cls.add_method('IsMatchingType',
'bool',
@@ -1681,6 +1683,10 @@ def register_Ns3InetSocketAddress_methods(root_module, cls):
cls.add_method('SetPort',
'void',
[param('uint16_t', 'port')])
+ ## inet-socket-address.h (module 'network'): void ns3::InetSocketAddress::SetTos(uint8_t tos) [member function]
+ cls.add_method('SetTos',
+ 'void',
+ [param('uint8_t', 'tos')])
return
def register_Ns3IntToType__0_methods(root_module, cls):
@@ -2173,66 +2179,6 @@ def register_Ns3Ipv6Address_methods(root_module, cls):
[param('uint8_t *', 'address')])
return
-def register_Ns3Ipv6InterfaceAddress_methods(root_module, cls):
- cls.add_binary_comparison_operator('!=')
- cls.add_output_stream_operator()
- cls.add_binary_comparison_operator('==')
- ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::Ipv6InterfaceAddress() [constructor]
- cls.add_constructor([])
- ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::Ipv6InterfaceAddress(ns3::Ipv6Address address) [constructor]
- cls.add_constructor([param('ns3::Ipv6Address', 'address')])
- ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::Ipv6InterfaceAddress(ns3::Ipv6Address address, ns3::Ipv6Prefix prefix) [constructor]
- cls.add_constructor([param('ns3::Ipv6Address', 'address'), param('ns3::Ipv6Prefix', 'prefix')])
- ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::Ipv6InterfaceAddress(ns3::Ipv6InterfaceAddress const & o) [copy constructor]
- cls.add_constructor([param('ns3::Ipv6InterfaceAddress const &', 'o')])
- ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6Address ns3::Ipv6InterfaceAddress::GetAddress() const [member function]
- cls.add_method('GetAddress',
- 'ns3::Ipv6Address',
- [],
- is_const=True)
- ## ipv6-interface-address.h (module 'internet'): uint32_t ns3::Ipv6InterfaceAddress::GetNsDadUid() const [member function]
- cls.add_method('GetNsDadUid',
- 'uint32_t',
- [],
- is_const=True)
- ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6Prefix ns3::Ipv6InterfaceAddress::GetPrefix() const [member function]
- cls.add_method('GetPrefix',
- 'ns3::Ipv6Prefix',
- [],
- is_const=True)
- ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::Scope_e ns3::Ipv6InterfaceAddress::GetScope() const [member function]
- cls.add_method('GetScope',
- 'ns3::Ipv6InterfaceAddress::Scope_e',
- [],
- is_const=True)
- ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::State_e ns3::Ipv6InterfaceAddress::GetState() const [member function]
- cls.add_method('GetState',
- 'ns3::Ipv6InterfaceAddress::State_e',
- [],
- is_const=True)
- ## ipv6-interface-address.h (module 'internet'): bool ns3::Ipv6InterfaceAddress::IsInSameSubnet(ns3::Ipv6Address b) const [member function]
- cls.add_method('IsInSameSubnet',
- 'bool',
- [param('ns3::Ipv6Address', 'b')],
- is_const=True)
- ## ipv6-interface-address.h (module 'internet'): void ns3::Ipv6InterfaceAddress::SetAddress(ns3::Ipv6Address address) [member function]
- cls.add_method('SetAddress',
- 'void',
- [param('ns3::Ipv6Address', 'address')])
- ## ipv6-interface-address.h (module 'internet'): void ns3::Ipv6InterfaceAddress::SetNsDadUid(uint32_t uid) [member function]
- cls.add_method('SetNsDadUid',
- 'void',
- [param('uint32_t', 'uid')])
- ## ipv6-interface-address.h (module 'internet'): void ns3::Ipv6InterfaceAddress::SetScope(ns3::Ipv6InterfaceAddress::Scope_e scope) [member function]
- cls.add_method('SetScope',
- 'void',
- [param('ns3::Ipv6InterfaceAddress::Scope_e', 'scope')])
- ## ipv6-interface-address.h (module 'internet'): void ns3::Ipv6InterfaceAddress::SetState(ns3::Ipv6InterfaceAddress::State_e state) [member function]
- cls.add_method('SetState',
- 'void',
- [param('ns3::Ipv6InterfaceAddress::State_e', 'state')])
- return
-
def register_Ns3Ipv6Prefix_methods(root_module, cls):
cls.add_binary_comparison_operator('!=')
cls.add_output_stream_operator()
@@ -4301,6 +4247,11 @@ def register_Ns3Object_methods(root_module, cls):
cls.add_method('Initialize',
'void',
[])
+ ## object.h (module 'core'): bool ns3::Object::IsInitialized() const [member function]
+ cls.add_method('IsInitialized',
+ 'bool',
+ [],
+ is_const=True)
## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
cls.add_constructor([param('ns3::Object const &', 'o')],
visibility='protected')
@@ -5051,6 +5002,11 @@ def register_Ns3Socket_methods(root_module, cls):
'int',
[param('ns3::Address &', 'address')],
is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): uint8_t ns3::Socket::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
## socket.h (module 'network'): uint32_t ns3::Socket::GetRxAvailable() const [member function]
cls.add_method('GetRxAvailable',
'uint32_t',
@@ -5076,6 +5032,11 @@ def register_Ns3Socket_methods(root_module, cls):
'ns3::TypeId',
[],
is_static=True)
+ ## socket.h (module 'network'): static uint8_t ns3::Socket::IpTos2Priority(uint8_t ipTos) [member function]
+ cls.add_method('IpTos2Priority',
+ 'uint8_t',
+ [param('uint8_t', 'ipTos')],
+ is_static=True)
## socket.h (module 'network'): void ns3::Socket::Ipv6JoinGroup(ns3::Ipv6Address address, ns3::Socket::Ipv6MulticastFilterMode filterMode, std::vector > sourceAddresses) [member function]
cls.add_method('Ipv6JoinGroup',
'void',
@@ -5224,6 +5185,10 @@ def register_Ns3Socket_methods(root_module, cls):
cls.add_method('SetIpv6Tclass',
'void',
[param('int', 'ipTclass')])
+ ## socket.h (module 'network'): void ns3::Socket::SetPriority(uint8_t priority) [member function]
+ cls.add_method('SetPriority',
+ 'void',
+ [param('uint8_t', 'priority')])
## socket.h (module 'network'): void ns3::Socket::SetRecvCallback(ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> arg0) [member function]
cls.add_method('SetRecvCallback',
'void',
@@ -5251,11 +5216,6 @@ def register_Ns3Socket_methods(root_module, cls):
'void',
[],
visibility='protected', is_virtual=True)
- ## socket.h (module 'network'): bool ns3::Socket::IsManualIpTos() const [member function]
- cls.add_method('IsManualIpTos',
- 'bool',
- [],
- is_const=True, visibility='protected')
## socket.h (module 'network'): bool ns3::Socket::IsManualIpTtl() const [member function]
cls.add_method('IsManualIpTtl',
'bool',
@@ -5502,6 +5462,52 @@ def register_Ns3SocketIpv6TclassTag_methods(root_module, cls):
[param('uint8_t', 'tclass')])
return
+def register_Ns3SocketPriorityTag_methods(root_module, cls):
+ ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag(ns3::SocketPriorityTag const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::SocketPriorityTag const &', 'arg0')])
+ ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag() [constructor]
+ cls.add_constructor([])
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Deserialize(ns3::TagBuffer i) [member function]
+ cls.add_method('Deserialize',
+ 'void',
+ [param('ns3::TagBuffer', 'i')],
+ is_virtual=True)
+ ## socket.h (module 'network'): ns3::TypeId ns3::SocketPriorityTag::GetInstanceTypeId() const [member function]
+ cls.add_method('GetInstanceTypeId',
+ 'ns3::TypeId',
+ [],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): uint8_t ns3::SocketPriorityTag::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
+ ## socket.h (module 'network'): uint32_t ns3::SocketPriorityTag::GetSerializedSize() const [member function]
+ cls.add_method('GetSerializedSize',
+ 'uint32_t',
+ [],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): static ns3::TypeId ns3::SocketPriorityTag::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Print(std::ostream & os) const [member function]
+ cls.add_method('Print',
+ 'void',
+ [param('std::ostream &', 'os')],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Serialize(ns3::TagBuffer i) const [member function]
+ cls.add_method('Serialize',
+ 'void',
+ [param('ns3::TagBuffer', 'i')],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::SetPriority(uint8_t priority) [member function]
+ cls.add_method('SetPriority',
+ 'void',
+ [param('uint8_t', 'priority')])
+ return
+
def register_Ns3SocketSetDontFragmentTag_methods(root_module, cls):
## socket.h (module 'network'): ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag(ns3::SocketSetDontFragmentTag const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SocketSetDontFragmentTag const &', 'arg0')])
@@ -6287,10 +6293,10 @@ def register_Ns3WifiMac_methods(root_module, cls):
'bool',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
- ## wifi-mac.h (module 'wifi'): void ns3::WifiMac::ConfigureDcf(ns3::Ptr dcf, uint32_t cwmin, uint32_t cwmax, ns3::AcIndex ac) [member function]
+ ## wifi-mac.h (module 'wifi'): void ns3::WifiMac::ConfigureDcf(ns3::Ptr dcf, uint32_t cwmin, uint32_t cwmax, bool isDsss, ns3::AcIndex ac) [member function]
cls.add_method('ConfigureDcf',
'void',
- [param('ns3::Ptr< ns3::Dcf >', 'dcf'), param('uint32_t', 'cwmin'), param('uint32_t', 'cwmax'), param('ns3::AcIndex', 'ac')],
+ [param('ns3::Ptr< ns3::Dcf >', 'dcf'), param('uint32_t', 'cwmin'), param('uint32_t', 'cwmax'), param('bool', 'isDsss'), param('ns3::AcIndex', 'ac')],
visibility='protected')
## wifi-mac.h (module 'wifi'): void ns3::WifiMac::FinishConfigureStandard(ns3::WifiPhyStandard standard) [member function]
cls.add_method('FinishConfigureStandard',
@@ -6739,11 +6745,11 @@ def register_Ns3WifiPhy_methods(root_module, cls):
cls.add_constructor([param('ns3::WifiPhy const &', 'arg0')])
## wifi-phy.h (module 'wifi'): ns3::WifiPhy::WifiPhy() [constructor]
cls.add_constructor([])
- ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::AddSupportedChannelWidth(uint32_t width) [member function]
+ ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::AddSupportedChannelWidth(uint32_t channelwidth) [member function]
cls.add_method('AddSupportedChannelWidth',
'void',
- [param('uint32_t', 'width')],
- is_pure_virtual=True, is_virtual=True)
+ [param('uint32_t', 'channelwidth')],
+ is_virtual=True)
## wifi-phy.h (module 'wifi'): int64_t ns3::WifiPhy::AssignStreams(int64_t stream) [member function]
cls.add_method('AssignStreams',
'int64_t',
@@ -6770,7 +6776,7 @@ def register_Ns3WifiPhy_methods(root_module, cls):
cls.add_method('ConfigureStandard',
'void',
[param('ns3::WifiPhyStandard', 'standard')],
- is_pure_virtual=True, is_virtual=True)
+ is_virtual=True)
## wifi-phy.h (module 'wifi'): double ns3::WifiPhy::DbToRatio(double db) const [member function]
cls.add_method('DbToRatio',
'double',
@@ -6781,6 +6787,10 @@ def register_Ns3WifiPhy_methods(root_module, cls):
'double',
[param('double', 'dbm')],
is_const=True)
+ ## wifi-phy.h (module 'wifi'): bool ns3::WifiPhy::DefineChannelNumber(uint16_t channelNumber, ns3::WifiPhyStandard standard, uint32_t frequency, uint32_t channelWidth) [member function]
+ cls.add_method('DefineChannelNumber',
+ 'bool',
+ [param('uint16_t', 'channelNumber'), param('ns3::WifiPhyStandard', 'standard'), param('uint32_t', 'frequency'), param('uint32_t', 'channelWidth')])
## wifi-phy.h (module 'wifi'): uint32_t ns3::WifiPhy::GetBssMembershipSelector(uint32_t selector) const [member function]
cls.add_method('GetBssMembershipSelector',
'uint32_t',
@@ -6795,7 +6805,7 @@ def register_Ns3WifiPhy_methods(root_module, cls):
cls.add_method('GetChannelNumber',
'uint16_t',
[],
- is_pure_virtual=True, is_const=True, is_virtual=True)
+ is_const=True, is_virtual=True)
## wifi-phy.h (module 'wifi'): ns3::Time ns3::WifiPhy::GetChannelSwitchDelay() const [member function]
cls.add_method('GetChannelSwitchDelay',
'ns3::Time',
@@ -6805,7 +6815,7 @@ def register_Ns3WifiPhy_methods(root_module, cls):
cls.add_method('GetChannelWidth',
'uint32_t',
[],
- is_pure_virtual=True, is_const=True, is_virtual=True)
+ is_const=True, is_virtual=True)
## wifi-phy.h (module 'wifi'): ns3::Time ns3::WifiPhy::GetDelayUntilIdle() [member function]
cls.add_method('GetDelayUntilIdle',
'ns3::Time',
@@ -6875,7 +6885,7 @@ def register_Ns3WifiPhy_methods(root_module, cls):
cls.add_method('GetFrequency',
'uint32_t',
[],
- is_pure_virtual=True, is_const=True, is_virtual=True)
+ is_const=True, is_virtual=True)
## wifi-phy.h (module 'wifi'): bool ns3::WifiPhy::GetGreenfield() const [member function]
cls.add_method('GetGreenfield',
'bool',
@@ -7279,6 +7289,11 @@ def register_Ns3WifiPhy_methods(root_module, cls):
'bool',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## wifi-phy.h (module 'wifi'): ns3::WifiPhyStandard ns3::WifiPhy::GetStandard() const [member function]
+ cls.add_method('GetStandard',
+ 'ns3::WifiPhyStandard',
+ [],
+ is_const=True, is_virtual=True)
## wifi-phy.h (module 'wifi'): ns3::Time ns3::WifiPhy::GetStateDuration() [member function]
cls.add_method('GetStateDuration',
'ns3::Time',
@@ -7293,7 +7308,7 @@ def register_Ns3WifiPhy_methods(root_module, cls):
cls.add_method('GetSupportedChannelWidthSet',
'std::vector< unsigned int >',
[],
- is_pure_virtual=True, is_const=True, is_virtual=True)
+ is_const=True, is_virtual=True)
## wifi-phy.h (module 'wifi'): uint8_t ns3::WifiPhy::GetSupportedRxSpatialStreams() const [member function]
cls.add_method('GetSupportedRxSpatialStreams',
'uint8_t',
@@ -7480,17 +7495,17 @@ def register_Ns3WifiPhy_methods(root_module, cls):
cls.add_method('SetChannelNumber',
'void',
[param('uint16_t', 'id')],
- is_pure_virtual=True, is_virtual=True)
+ is_virtual=True)
## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::SetChannelWidth(uint32_t channelwidth) [member function]
cls.add_method('SetChannelWidth',
'void',
[param('uint32_t', 'channelwidth')],
- is_pure_virtual=True, is_virtual=True)
+ is_virtual=True)
## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::SetFrequency(uint32_t freq) [member function]
cls.add_method('SetFrequency',
'void',
[param('uint32_t', 'freq')],
- is_pure_virtual=True, is_virtual=True)
+ is_virtual=True)
## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::SetGreenfield(bool greenfield) [member function]
cls.add_method('SetGreenfield',
'void',
@@ -7551,6 +7566,31 @@ def register_Ns3WifiPhy_methods(root_module, cls):
'double',
[param('double', 'w')],
is_const=True)
+ ## wifi-phy.h (module 'wifi'): bool ns3::WifiPhy::DoChannelSwitch(uint16_t id) [member function]
+ cls.add_method('DoChannelSwitch',
+ 'bool',
+ [param('uint16_t', 'id')],
+ visibility='protected', is_virtual=True)
+ ## wifi-phy.h (module 'wifi'): bool ns3::WifiPhy::DoFrequencySwitch(uint32_t frequency) [member function]
+ cls.add_method('DoFrequencySwitch',
+ 'bool',
+ [param('uint32_t', 'frequency')],
+ visibility='protected', is_virtual=True)
+ ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::DoInitialize() [member function]
+ cls.add_method('DoInitialize',
+ 'void',
+ [],
+ visibility='protected', is_virtual=True)
+ ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::ConfigureChannelForStandard(ns3::WifiPhyStandard standard) [member function]
+ cls.add_method('ConfigureChannelForStandard',
+ 'void',
+ [param('ns3::WifiPhyStandard', 'standard')],
+ visibility='private', is_virtual=True)
+ ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::ConfigureDefaultsForStandard(ns3::WifiPhyStandard standard) [member function]
+ cls.add_method('ConfigureDefaultsForStandard',
+ 'void',
+ [param('ns3::WifiPhyStandard', 'standard')],
+ visibility='private', is_virtual=True)
return
def register_Ns3WifiRemoteStationManager_methods(root_module, cls):
@@ -10166,165 +10206,6 @@ def register_Ns3Ipv6AddressValue_methods(root_module, cls):
[param('ns3::Ipv6Address const &', 'value')])
return
-def register_Ns3Ipv6Interface_methods(root_module, cls):
- ## ipv6-interface.h (module 'internet'): ns3::Ipv6Interface::Ipv6Interface(ns3::Ipv6Interface const & arg0) [copy constructor]
- cls.add_constructor([param('ns3::Ipv6Interface const &', 'arg0')])
- ## ipv6-interface.h (module 'internet'): ns3::Ipv6Interface::Ipv6Interface() [constructor]
- cls.add_constructor([])
- ## ipv6-interface.h (module 'internet'): bool ns3::Ipv6Interface::AddAddress(ns3::Ipv6InterfaceAddress iface) [member function]
- cls.add_method('AddAddress',
- 'bool',
- [param('ns3::Ipv6InterfaceAddress', 'iface')])
- ## ipv6-interface.h (module 'internet'): ns3::Ipv6InterfaceAddress ns3::Ipv6Interface::GetAddress(uint32_t index) const [member function]
- cls.add_method('GetAddress',
- 'ns3::Ipv6InterfaceAddress',
- [param('uint32_t', 'index')],
- is_const=True)
- ## ipv6-interface.h (module 'internet'): ns3::Ipv6InterfaceAddress ns3::Ipv6Interface::GetAddressMatchingDestination(ns3::Ipv6Address dst) [member function]
- cls.add_method('GetAddressMatchingDestination',
- 'ns3::Ipv6InterfaceAddress',
- [param('ns3::Ipv6Address', 'dst')])
- ## ipv6-interface.h (module 'internet'): uint16_t ns3::Ipv6Interface::GetBaseReachableTime() const [member function]
- cls.add_method('GetBaseReachableTime',
- 'uint16_t',
- [],
- is_const=True)
- ## ipv6-interface.h (module 'internet'): uint8_t ns3::Ipv6Interface::GetCurHopLimit() const [member function]
- cls.add_method('GetCurHopLimit',
- 'uint8_t',
- [],
- is_const=True)
- ## ipv6-interface.h (module 'internet'): ns3::Ptr ns3::Ipv6Interface::GetDevice() const [member function]
- cls.add_method('GetDevice',
- 'ns3::Ptr< ns3::NetDevice >',
- [],
- is_const=True, is_virtual=True)
- ## ipv6-interface.h (module 'internet'): ns3::Ipv6InterfaceAddress ns3::Ipv6Interface::GetLinkLocalAddress() const [member function]
- cls.add_method('GetLinkLocalAddress',
- 'ns3::Ipv6InterfaceAddress',
- [],
- is_const=True)
- ## ipv6-interface.h (module 'internet'): uint16_t ns3::Ipv6Interface::GetMetric() const [member function]
- cls.add_method('GetMetric',
- 'uint16_t',
- [],
- is_const=True)
- ## ipv6-interface.h (module 'internet'): uint32_t ns3::Ipv6Interface::GetNAddresses() const [member function]
- cls.add_method('GetNAddresses',
- 'uint32_t',
- [],
- is_const=True)
- ## ipv6-interface.h (module 'internet'): ns3::Ptr ns3::Ipv6Interface::GetNdiscCache() const [member function]
- cls.add_method('GetNdiscCache',
- 'ns3::Ptr< ns3::NdiscCache >',
- [],
- is_const=True)
- ## ipv6-interface.h (module 'internet'): uint16_t ns3::Ipv6Interface::GetReachableTime() const [member function]
- cls.add_method('GetReachableTime',
- 'uint16_t',
- [],
- is_const=True)
- ## ipv6-interface.h (module 'internet'): uint16_t ns3::Ipv6Interface::GetRetransTimer() const [member function]
- cls.add_method('GetRetransTimer',
- 'uint16_t',
- [],
- is_const=True)
- ## ipv6-interface.h (module 'internet'): static ns3::TypeId ns3::Ipv6Interface::GetTypeId() [member function]
- cls.add_method('GetTypeId',
- 'ns3::TypeId',
- [],
- is_static=True)
- ## ipv6-interface.h (module 'internet'): bool ns3::Ipv6Interface::IsDown() const [member function]
- cls.add_method('IsDown',
- 'bool',
- [],
- is_const=True)
- ## ipv6-interface.h (module 'internet'): bool ns3::Ipv6Interface::IsForwarding() const [member function]
- cls.add_method('IsForwarding',
- 'bool',
- [],
- is_const=True)
- ## ipv6-interface.h (module 'internet'): bool ns3::Ipv6Interface::IsSolicitedMulticastAddress(ns3::Ipv6Address address) const [member function]
- cls.add_method('IsSolicitedMulticastAddress',
- 'bool',
- [param('ns3::Ipv6Address', 'address')],
- is_const=True)
- ## ipv6-interface.h (module 'internet'): bool ns3::Ipv6Interface::IsUp() const [member function]
- cls.add_method('IsUp',
- 'bool',
- [],
- is_const=True)
- ## ipv6-interface.h (module 'internet'): ns3::Ipv6InterfaceAddress ns3::Ipv6Interface::RemoveAddress(uint32_t index) [member function]
- cls.add_method('RemoveAddress',
- 'ns3::Ipv6InterfaceAddress',
- [param('uint32_t', 'index')])
- ## ipv6-interface.h (module 'internet'): ns3::Ipv6InterfaceAddress ns3::Ipv6Interface::RemoveAddress(ns3::Ipv6Address address) [member function]
- cls.add_method('RemoveAddress',
- 'ns3::Ipv6InterfaceAddress',
- [param('ns3::Ipv6Address', 'address')])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::Send(ns3::Ptr p, ns3::Ipv6Header const & hdr, ns3::Ipv6Address dest) [member function]
- cls.add_method('Send',
- 'void',
- [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv6Header const &', 'hdr'), param('ns3::Ipv6Address', 'dest')])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::SetBaseReachableTime(uint16_t baseReachableTime) [member function]
- cls.add_method('SetBaseReachableTime',
- 'void',
- [param('uint16_t', 'baseReachableTime')])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::SetCurHopLimit(uint8_t curHopLimit) [member function]
- cls.add_method('SetCurHopLimit',
- 'void',
- [param('uint8_t', 'curHopLimit')])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::SetDevice(ns3::Ptr device) [member function]
- cls.add_method('SetDevice',
- 'void',
- [param('ns3::Ptr< ns3::NetDevice >', 'device')])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::SetDown() [member function]
- cls.add_method('SetDown',
- 'void',
- [])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::SetForwarding(bool forward) [member function]
- cls.add_method('SetForwarding',
- 'void',
- [param('bool', 'forward')])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::SetMetric(uint16_t metric) [member function]
- cls.add_method('SetMetric',
- 'void',
- [param('uint16_t', 'metric')])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::SetNode(ns3::Ptr node) [member function]
- cls.add_method('SetNode',
- 'void',
- [param('ns3::Ptr< ns3::Node >', 'node')])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::SetNsDadUid(ns3::Ipv6Address address, uint32_t uid) [member function]
- cls.add_method('SetNsDadUid',
- 'void',
- [param('ns3::Ipv6Address', 'address'), param('uint32_t', 'uid')])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::SetReachableTime(uint16_t reachableTime) [member function]
- cls.add_method('SetReachableTime',
- 'void',
- [param('uint16_t', 'reachableTime')])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::SetRetransTimer(uint16_t retransTimer) [member function]
- cls.add_method('SetRetransTimer',
- 'void',
- [param('uint16_t', 'retransTimer')])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::SetState(ns3::Ipv6Address address, ns3::Ipv6InterfaceAddress::State_e state) [member function]
- cls.add_method('SetState',
- 'void',
- [param('ns3::Ipv6Address', 'address'), param('ns3::Ipv6InterfaceAddress::State_e', 'state')])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::SetTrafficControl(ns3::Ptr tc) [member function]
- cls.add_method('SetTrafficControl',
- 'void',
- [param('ns3::Ptr< ns3::TrafficControlLayer >', 'tc')])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::SetUp() [member function]
- cls.add_method('SetUp',
- 'void',
- [])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::DoDispose() [member function]
- cls.add_method('DoDispose',
- 'void',
- [],
- visibility='protected', is_virtual=True)
- return
-
def register_Ns3Ipv6PrefixChecker_methods(root_module, cls):
## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker::Ipv6PrefixChecker() [constructor]
cls.add_constructor([])
@@ -10580,11 +10461,6 @@ def register_Ns3NetDeviceQueue_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueue const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueue::NetDeviceQueue() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): bool ns3::NetDeviceQueue::HasWakeCallbackSet() const [member function]
- cls.add_method('HasWakeCallbackSet',
- 'bool',
- [],
- is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDeviceQueue::IsStopped() const [member function]
cls.add_method('IsStopped',
'bool',
@@ -10617,21 +10493,25 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueueInterface const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetSelectedQueue(ns3::Ptr item) const [member function]
- cls.add_method('GetSelectedQueue',
+ ## net-device.h (module 'network'): void ns3::NetDeviceQueueInterface::CreateTxQueues() [member function]
+ cls.add_method('CreateTxQueues',
+ 'void',
+ [])
+ ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetNTxQueues() const [member function]
+ cls.add_method('GetNTxQueues',
'uint8_t',
- [param('ns3::Ptr< ns3::QueueItem >', 'item')],
+ [],
+ is_const=True)
+ ## net-device.h (module 'network'): ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ns3::NetDeviceQueueInterface::GetSelectQueueCallback() const [member function]
+ cls.add_method('GetSelectQueueCallback',
+ 'ns3::Callback< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >',
+ [],
is_const=True)
## net-device.h (module 'network'): ns3::Ptr ns3::NetDeviceQueueInterface::GetTxQueue(uint8_t i) const [member function]
cls.add_method('GetTxQueue',
'ns3::Ptr< ns3::NetDeviceQueue >',
[param('uint8_t', 'i')],
is_const=True)
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetTxQueuesN() const [member function]
- cls.add_method('GetTxQueuesN',
- 'uint8_t',
- [],
- is_const=True)
## net-device.h (module 'network'): static ns3::TypeId ns3::NetDeviceQueueInterface::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
@@ -11124,6 +11004,11 @@ def register_Ns3QueueItem_methods(root_module, cls):
'uint32_t',
[],
is_const=True, is_virtual=True)
+ ## net-device.h (module 'network'): bool ns3::QueueItem::GetUint8Value(ns3::QueueItem::Uint8Values field, uint8_t & value) const [member function]
+ cls.add_method('GetUint8Value',
+ 'bool',
+ [param('ns3::QueueItem::Uint8Values', 'field'), param('uint8_t &', 'value')],
+ is_const=True, is_virtual=True)
## net-device.h (module 'network'): void ns3::QueueItem::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
diff --git a/src/dsr/bindings/modulegen__gcc_LP64.py b/src/dsr/bindings/modulegen__gcc_LP64.py
index 61a26dba86e..c9083943be9 100644
--- a/src/dsr/bindings/modulegen__gcc_LP64.py
+++ b/src/dsr/bindings/modulegen__gcc_LP64.py
@@ -29,7 +29,7 @@ def register_types(module):
## wifi-mode.h (module 'wifi'): ns3::WifiModulationClass [enumeration]
module.add_enum('WifiModulationClass', ['WIFI_MOD_CLASS_UNKNOWN', 'WIFI_MOD_CLASS_IR', 'WIFI_MOD_CLASS_FHSS', 'WIFI_MOD_CLASS_DSSS', 'WIFI_MOD_CLASS_HR_DSSS', 'WIFI_MOD_CLASS_ERP_PBCC', 'WIFI_MOD_CLASS_DSSS_OFDM', 'WIFI_MOD_CLASS_ERP_OFDM', 'WIFI_MOD_CLASS_OFDM', 'WIFI_MOD_CLASS_HT', 'WIFI_MOD_CLASS_VHT'], import_from_module='ns.wifi')
## wifi-phy-standard.h (module 'wifi'): ns3::WifiPhyStandard [enumeration]
- module.add_enum('WifiPhyStandard', ['WIFI_PHY_STANDARD_80211a', 'WIFI_PHY_STANDARD_80211b', 'WIFI_PHY_STANDARD_80211g', 'WIFI_PHY_STANDARD_80211_10MHZ', 'WIFI_PHY_STANDARD_80211_5MHZ', 'WIFI_PHY_STANDARD_holland', 'WIFI_PHY_STANDARD_80211n_2_4GHZ', 'WIFI_PHY_STANDARD_80211n_5GHZ', 'WIFI_PHY_STANDARD_80211ac'], import_from_module='ns.wifi')
+ module.add_enum('WifiPhyStandard', ['WIFI_PHY_STANDARD_80211a', 'WIFI_PHY_STANDARD_80211b', 'WIFI_PHY_STANDARD_80211g', 'WIFI_PHY_STANDARD_80211_10MHZ', 'WIFI_PHY_STANDARD_80211_5MHZ', 'WIFI_PHY_STANDARD_holland', 'WIFI_PHY_STANDARD_80211n_2_4GHZ', 'WIFI_PHY_STANDARD_80211n_5GHZ', 'WIFI_PHY_STANDARD_80211ac', 'WIFI_PHY_STANDARD_UNSPECIFIED'], import_from_module='ns.wifi')
## wifi-mode.h (module 'wifi'): ns3::WifiCodeRate [enumeration]
module.add_enum('WifiCodeRate', ['WIFI_CODE_RATE_UNDEFINED', 'WIFI_CODE_RATE_3_4', 'WIFI_CODE_RATE_2_3', 'WIFI_CODE_RATE_1_2', 'WIFI_CODE_RATE_5_6'], import_from_module='ns.wifi')
## qos-utils.h (module 'wifi'): ns3::AcIndex [enumeration]
@@ -118,12 +118,6 @@ def register_types(module):
module.add_class('Ipv6Address', import_from_module='ns.network')
## ipv6-address.h (module 'network'): ns3::Ipv6Address [class]
root_module['ns3::Ipv6Address'].implicitly_converts_to(root_module['ns3::Address'])
- ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress [class]
- module.add_class('Ipv6InterfaceAddress', import_from_module='ns.internet')
- ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::State_e [enumeration]
- module.add_enum('State_e', ['TENTATIVE', 'DEPRECATED', 'PREFERRED', 'PERMANENT', 'HOMEADDRESS', 'TENTATIVE_OPTIMISTIC', 'INVALID'], outer_class=root_module['ns3::Ipv6InterfaceAddress'], import_from_module='ns.internet')
- ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::Scope_e [enumeration]
- module.add_enum('Scope_e', ['HOST', 'LINKLOCAL', 'GLOBAL'], outer_class=root_module['ns3::Ipv6InterfaceAddress'], import_from_module='ns.internet')
## ipv6-address.h (module 'network'): ns3::Ipv6Prefix [class]
module.add_class('Ipv6Prefix', import_from_module='ns.network')
## mac48-address.h (module 'network'): ns3::Mac48Address [class]
@@ -302,6 +296,8 @@ def register_types(module):
module.add_enum('SocketErrno', ['ERROR_NOTERROR', 'ERROR_ISCONN', 'ERROR_NOTCONN', 'ERROR_MSGSIZE', 'ERROR_AGAIN', 'ERROR_SHUTDOWN', 'ERROR_OPNOTSUPP', 'ERROR_AFNOSUPPORT', 'ERROR_INVAL', 'ERROR_BADF', 'ERROR_NOROUTETOHOST', 'ERROR_NODEV', 'ERROR_ADDRNOTAVAIL', 'ERROR_ADDRINUSE', 'SOCKET_ERRNO_LAST'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::SocketType [enumeration]
module.add_enum('SocketType', ['NS3_SOCK_STREAM', 'NS3_SOCK_SEQPACKET', 'NS3_SOCK_DGRAM', 'NS3_SOCK_RAW'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
+ ## socket.h (module 'network'): ns3::Socket::SocketPriority [enumeration]
+ module.add_enum('SocketPriority', ['NS3_PRIO_BESTEFFORT', 'NS3_PRIO_FILLER', 'NS3_PRIO_BULK', 'NS3_PRIO_INTERACTIVE_BULK', 'NS3_PRIO_INTERACTIVE', 'NS3_PRIO_CONTROL'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::Ipv6MulticastFilterMode [enumeration]
module.add_enum('Ipv6MulticastFilterMode', ['INCLUDE', 'EXCLUDE'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::SocketIpTosTag [class]
@@ -312,6 +308,8 @@ def register_types(module):
module.add_class('SocketIpv6HopLimitTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketIpv6TclassTag [class]
module.add_class('SocketIpv6TclassTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
+ ## socket.h (module 'network'): ns3::SocketPriorityTag [class]
+ module.add_class('SocketPriorityTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketSetDontFragmentTag [class]
module.add_class('SocketSetDontFragmentTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## nstime.h (module 'core'): ns3::Time [class]
@@ -434,8 +432,6 @@ def register_types(module):
module.add_class('Ipv6AddressChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker'])
## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue [class]
module.add_class('Ipv6AddressValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue'])
- ## ipv6-interface.h (module 'internet'): ns3::Ipv6Interface [class]
- module.add_class('Ipv6Interface', import_from_module='ns.internet', parent=root_module['ns3::Object'])
## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker [class]
module.add_class('Ipv6PrefixChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker'])
## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue [class]
@@ -472,6 +468,8 @@ def register_types(module):
module.add_class('ParetoRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream'])
## net-device.h (module 'network'): ns3::QueueItem [class]
module.add_class('QueueItem', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >'])
+ ## net-device.h (module 'network'): ns3::QueueItem::Uint8Values [enumeration]
+ module.add_enum('Uint8Values', ['IP_DSFIELD'], outer_class=root_module['ns3::QueueItem'], import_from_module='ns.network')
## ssid.h (module 'wifi'): ns3::Ssid [class]
module.add_class('Ssid', import_from_module='ns.wifi', parent=root_module['ns3::WifiInformationElement'])
## ssid.h (module 'wifi'): ns3::SsidChecker [class]
@@ -786,7 +784,6 @@ def register_methods(root_module):
register_Ns3Ipv4InterfaceAddress_methods(root_module, root_module['ns3::Ipv4InterfaceAddress'])
register_Ns3Ipv4Mask_methods(root_module, root_module['ns3::Ipv4Mask'])
register_Ns3Ipv6Address_methods(root_module, root_module['ns3::Ipv6Address'])
- register_Ns3Ipv6InterfaceAddress_methods(root_module, root_module['ns3::Ipv6InterfaceAddress'])
register_Ns3Ipv6Prefix_methods(root_module, root_module['ns3::Ipv6Prefix'])
register_Ns3Mac48Address_methods(root_module, root_module['ns3::Mac48Address'])
register_Ns3NodeContainer_methods(root_module, root_module['ns3::NodeContainer'])
@@ -860,6 +857,7 @@ def register_methods(root_module):
register_Ns3SocketIpTtlTag_methods(root_module, root_module['ns3::SocketIpTtlTag'])
register_Ns3SocketIpv6HopLimitTag_methods(root_module, root_module['ns3::SocketIpv6HopLimitTag'])
register_Ns3SocketIpv6TclassTag_methods(root_module, root_module['ns3::SocketIpv6TclassTag'])
+ register_Ns3SocketPriorityTag_methods(root_module, root_module['ns3::SocketPriorityTag'])
register_Ns3SocketSetDontFragmentTag_methods(root_module, root_module['ns3::SocketSetDontFragmentTag'])
register_Ns3Time_methods(root_module, root_module['ns3::Time'])
register_Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::TraceSourceAccessor'])
@@ -913,7 +911,6 @@ def register_methods(root_module):
register_Ns3Ipv4RoutingProtocol_methods(root_module, root_module['ns3::Ipv4RoutingProtocol'])
register_Ns3Ipv6AddressChecker_methods(root_module, root_module['ns3::Ipv6AddressChecker'])
register_Ns3Ipv6AddressValue_methods(root_module, root_module['ns3::Ipv6AddressValue'])
- register_Ns3Ipv6Interface_methods(root_module, root_module['ns3::Ipv6Interface'])
register_Ns3Ipv6PrefixChecker_methods(root_module, root_module['ns3::Ipv6PrefixChecker'])
register_Ns3Ipv6PrefixValue_methods(root_module, root_module['ns3::Ipv6PrefixValue'])
register_Ns3LogNormalRandomVariable_methods(root_module, root_module['ns3::LogNormalRandomVariable'])
@@ -1668,6 +1665,11 @@ def register_Ns3InetSocketAddress_methods(root_module, cls):
'uint16_t',
[],
is_const=True)
+ ## inet-socket-address.h (module 'network'): uint8_t ns3::InetSocketAddress::GetTos() const [member function]
+ cls.add_method('GetTos',
+ 'uint8_t',
+ [],
+ is_const=True)
## inet-socket-address.h (module 'network'): static bool ns3::InetSocketAddress::IsMatchingType(ns3::Address const & address) [member function]
cls.add_method('IsMatchingType',
'bool',
@@ -1681,6 +1683,10 @@ def register_Ns3InetSocketAddress_methods(root_module, cls):
cls.add_method('SetPort',
'void',
[param('uint16_t', 'port')])
+ ## inet-socket-address.h (module 'network'): void ns3::InetSocketAddress::SetTos(uint8_t tos) [member function]
+ cls.add_method('SetTos',
+ 'void',
+ [param('uint8_t', 'tos')])
return
def register_Ns3IntToType__0_methods(root_module, cls):
@@ -2173,66 +2179,6 @@ def register_Ns3Ipv6Address_methods(root_module, cls):
[param('uint8_t *', 'address')])
return
-def register_Ns3Ipv6InterfaceAddress_methods(root_module, cls):
- cls.add_binary_comparison_operator('!=')
- cls.add_output_stream_operator()
- cls.add_binary_comparison_operator('==')
- ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::Ipv6InterfaceAddress() [constructor]
- cls.add_constructor([])
- ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::Ipv6InterfaceAddress(ns3::Ipv6Address address) [constructor]
- cls.add_constructor([param('ns3::Ipv6Address', 'address')])
- ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::Ipv6InterfaceAddress(ns3::Ipv6Address address, ns3::Ipv6Prefix prefix) [constructor]
- cls.add_constructor([param('ns3::Ipv6Address', 'address'), param('ns3::Ipv6Prefix', 'prefix')])
- ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::Ipv6InterfaceAddress(ns3::Ipv6InterfaceAddress const & o) [copy constructor]
- cls.add_constructor([param('ns3::Ipv6InterfaceAddress const &', 'o')])
- ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6Address ns3::Ipv6InterfaceAddress::GetAddress() const [member function]
- cls.add_method('GetAddress',
- 'ns3::Ipv6Address',
- [],
- is_const=True)
- ## ipv6-interface-address.h (module 'internet'): uint32_t ns3::Ipv6InterfaceAddress::GetNsDadUid() const [member function]
- cls.add_method('GetNsDadUid',
- 'uint32_t',
- [],
- is_const=True)
- ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6Prefix ns3::Ipv6InterfaceAddress::GetPrefix() const [member function]
- cls.add_method('GetPrefix',
- 'ns3::Ipv6Prefix',
- [],
- is_const=True)
- ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::Scope_e ns3::Ipv6InterfaceAddress::GetScope() const [member function]
- cls.add_method('GetScope',
- 'ns3::Ipv6InterfaceAddress::Scope_e',
- [],
- is_const=True)
- ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::State_e ns3::Ipv6InterfaceAddress::GetState() const [member function]
- cls.add_method('GetState',
- 'ns3::Ipv6InterfaceAddress::State_e',
- [],
- is_const=True)
- ## ipv6-interface-address.h (module 'internet'): bool ns3::Ipv6InterfaceAddress::IsInSameSubnet(ns3::Ipv6Address b) const [member function]
- cls.add_method('IsInSameSubnet',
- 'bool',
- [param('ns3::Ipv6Address', 'b')],
- is_const=True)
- ## ipv6-interface-address.h (module 'internet'): void ns3::Ipv6InterfaceAddress::SetAddress(ns3::Ipv6Address address) [member function]
- cls.add_method('SetAddress',
- 'void',
- [param('ns3::Ipv6Address', 'address')])
- ## ipv6-interface-address.h (module 'internet'): void ns3::Ipv6InterfaceAddress::SetNsDadUid(uint32_t uid) [member function]
- cls.add_method('SetNsDadUid',
- 'void',
- [param('uint32_t', 'uid')])
- ## ipv6-interface-address.h (module 'internet'): void ns3::Ipv6InterfaceAddress::SetScope(ns3::Ipv6InterfaceAddress::Scope_e scope) [member function]
- cls.add_method('SetScope',
- 'void',
- [param('ns3::Ipv6InterfaceAddress::Scope_e', 'scope')])
- ## ipv6-interface-address.h (module 'internet'): void ns3::Ipv6InterfaceAddress::SetState(ns3::Ipv6InterfaceAddress::State_e state) [member function]
- cls.add_method('SetState',
- 'void',
- [param('ns3::Ipv6InterfaceAddress::State_e', 'state')])
- return
-
def register_Ns3Ipv6Prefix_methods(root_module, cls):
cls.add_binary_comparison_operator('!=')
cls.add_output_stream_operator()
@@ -4301,6 +4247,11 @@ def register_Ns3Object_methods(root_module, cls):
cls.add_method('Initialize',
'void',
[])
+ ## object.h (module 'core'): bool ns3::Object::IsInitialized() const [member function]
+ cls.add_method('IsInitialized',
+ 'bool',
+ [],
+ is_const=True)
## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
cls.add_constructor([param('ns3::Object const &', 'o')],
visibility='protected')
@@ -5051,6 +5002,11 @@ def register_Ns3Socket_methods(root_module, cls):
'int',
[param('ns3::Address &', 'address')],
is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): uint8_t ns3::Socket::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
## socket.h (module 'network'): uint32_t ns3::Socket::GetRxAvailable() const [member function]
cls.add_method('GetRxAvailable',
'uint32_t',
@@ -5076,6 +5032,11 @@ def register_Ns3Socket_methods(root_module, cls):
'ns3::TypeId',
[],
is_static=True)
+ ## socket.h (module 'network'): static uint8_t ns3::Socket::IpTos2Priority(uint8_t ipTos) [member function]
+ cls.add_method('IpTos2Priority',
+ 'uint8_t',
+ [param('uint8_t', 'ipTos')],
+ is_static=True)
## socket.h (module 'network'): void ns3::Socket::Ipv6JoinGroup(ns3::Ipv6Address address, ns3::Socket::Ipv6MulticastFilterMode filterMode, std::vector > sourceAddresses) [member function]
cls.add_method('Ipv6JoinGroup',
'void',
@@ -5224,6 +5185,10 @@ def register_Ns3Socket_methods(root_module, cls):
cls.add_method('SetIpv6Tclass',
'void',
[param('int', 'ipTclass')])
+ ## socket.h (module 'network'): void ns3::Socket::SetPriority(uint8_t priority) [member function]
+ cls.add_method('SetPriority',
+ 'void',
+ [param('uint8_t', 'priority')])
## socket.h (module 'network'): void ns3::Socket::SetRecvCallback(ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> arg0) [member function]
cls.add_method('SetRecvCallback',
'void',
@@ -5251,11 +5216,6 @@ def register_Ns3Socket_methods(root_module, cls):
'void',
[],
visibility='protected', is_virtual=True)
- ## socket.h (module 'network'): bool ns3::Socket::IsManualIpTos() const [member function]
- cls.add_method('IsManualIpTos',
- 'bool',
- [],
- is_const=True, visibility='protected')
## socket.h (module 'network'): bool ns3::Socket::IsManualIpTtl() const [member function]
cls.add_method('IsManualIpTtl',
'bool',
@@ -5502,6 +5462,52 @@ def register_Ns3SocketIpv6TclassTag_methods(root_module, cls):
[param('uint8_t', 'tclass')])
return
+def register_Ns3SocketPriorityTag_methods(root_module, cls):
+ ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag(ns3::SocketPriorityTag const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::SocketPriorityTag const &', 'arg0')])
+ ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag() [constructor]
+ cls.add_constructor([])
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Deserialize(ns3::TagBuffer i) [member function]
+ cls.add_method('Deserialize',
+ 'void',
+ [param('ns3::TagBuffer', 'i')],
+ is_virtual=True)
+ ## socket.h (module 'network'): ns3::TypeId ns3::SocketPriorityTag::GetInstanceTypeId() const [member function]
+ cls.add_method('GetInstanceTypeId',
+ 'ns3::TypeId',
+ [],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): uint8_t ns3::SocketPriorityTag::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
+ ## socket.h (module 'network'): uint32_t ns3::SocketPriorityTag::GetSerializedSize() const [member function]
+ cls.add_method('GetSerializedSize',
+ 'uint32_t',
+ [],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): static ns3::TypeId ns3::SocketPriorityTag::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Print(std::ostream & os) const [member function]
+ cls.add_method('Print',
+ 'void',
+ [param('std::ostream &', 'os')],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Serialize(ns3::TagBuffer i) const [member function]
+ cls.add_method('Serialize',
+ 'void',
+ [param('ns3::TagBuffer', 'i')],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::SetPriority(uint8_t priority) [member function]
+ cls.add_method('SetPriority',
+ 'void',
+ [param('uint8_t', 'priority')])
+ return
+
def register_Ns3SocketSetDontFragmentTag_methods(root_module, cls):
## socket.h (module 'network'): ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag(ns3::SocketSetDontFragmentTag const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SocketSetDontFragmentTag const &', 'arg0')])
@@ -6287,10 +6293,10 @@ def register_Ns3WifiMac_methods(root_module, cls):
'bool',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
- ## wifi-mac.h (module 'wifi'): void ns3::WifiMac::ConfigureDcf(ns3::Ptr dcf, uint32_t cwmin, uint32_t cwmax, ns3::AcIndex ac) [member function]
+ ## wifi-mac.h (module 'wifi'): void ns3::WifiMac::ConfigureDcf(ns3::Ptr dcf, uint32_t cwmin, uint32_t cwmax, bool isDsss, ns3::AcIndex ac) [member function]
cls.add_method('ConfigureDcf',
'void',
- [param('ns3::Ptr< ns3::Dcf >', 'dcf'), param('uint32_t', 'cwmin'), param('uint32_t', 'cwmax'), param('ns3::AcIndex', 'ac')],
+ [param('ns3::Ptr< ns3::Dcf >', 'dcf'), param('uint32_t', 'cwmin'), param('uint32_t', 'cwmax'), param('bool', 'isDsss'), param('ns3::AcIndex', 'ac')],
visibility='protected')
## wifi-mac.h (module 'wifi'): void ns3::WifiMac::FinishConfigureStandard(ns3::WifiPhyStandard standard) [member function]
cls.add_method('FinishConfigureStandard',
@@ -6739,11 +6745,11 @@ def register_Ns3WifiPhy_methods(root_module, cls):
cls.add_constructor([param('ns3::WifiPhy const &', 'arg0')])
## wifi-phy.h (module 'wifi'): ns3::WifiPhy::WifiPhy() [constructor]
cls.add_constructor([])
- ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::AddSupportedChannelWidth(uint32_t width) [member function]
+ ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::AddSupportedChannelWidth(uint32_t channelwidth) [member function]
cls.add_method('AddSupportedChannelWidth',
'void',
- [param('uint32_t', 'width')],
- is_pure_virtual=True, is_virtual=True)
+ [param('uint32_t', 'channelwidth')],
+ is_virtual=True)
## wifi-phy.h (module 'wifi'): int64_t ns3::WifiPhy::AssignStreams(int64_t stream) [member function]
cls.add_method('AssignStreams',
'int64_t',
@@ -6770,7 +6776,7 @@ def register_Ns3WifiPhy_methods(root_module, cls):
cls.add_method('ConfigureStandard',
'void',
[param('ns3::WifiPhyStandard', 'standard')],
- is_pure_virtual=True, is_virtual=True)
+ is_virtual=True)
## wifi-phy.h (module 'wifi'): double ns3::WifiPhy::DbToRatio(double db) const [member function]
cls.add_method('DbToRatio',
'double',
@@ -6781,6 +6787,10 @@ def register_Ns3WifiPhy_methods(root_module, cls):
'double',
[param('double', 'dbm')],
is_const=True)
+ ## wifi-phy.h (module 'wifi'): bool ns3::WifiPhy::DefineChannelNumber(uint16_t channelNumber, ns3::WifiPhyStandard standard, uint32_t frequency, uint32_t channelWidth) [member function]
+ cls.add_method('DefineChannelNumber',
+ 'bool',
+ [param('uint16_t', 'channelNumber'), param('ns3::WifiPhyStandard', 'standard'), param('uint32_t', 'frequency'), param('uint32_t', 'channelWidth')])
## wifi-phy.h (module 'wifi'): uint32_t ns3::WifiPhy::GetBssMembershipSelector(uint32_t selector) const [member function]
cls.add_method('GetBssMembershipSelector',
'uint32_t',
@@ -6795,7 +6805,7 @@ def register_Ns3WifiPhy_methods(root_module, cls):
cls.add_method('GetChannelNumber',
'uint16_t',
[],
- is_pure_virtual=True, is_const=True, is_virtual=True)
+ is_const=True, is_virtual=True)
## wifi-phy.h (module 'wifi'): ns3::Time ns3::WifiPhy::GetChannelSwitchDelay() const [member function]
cls.add_method('GetChannelSwitchDelay',
'ns3::Time',
@@ -6805,7 +6815,7 @@ def register_Ns3WifiPhy_methods(root_module, cls):
cls.add_method('GetChannelWidth',
'uint32_t',
[],
- is_pure_virtual=True, is_const=True, is_virtual=True)
+ is_const=True, is_virtual=True)
## wifi-phy.h (module 'wifi'): ns3::Time ns3::WifiPhy::GetDelayUntilIdle() [member function]
cls.add_method('GetDelayUntilIdle',
'ns3::Time',
@@ -6875,7 +6885,7 @@ def register_Ns3WifiPhy_methods(root_module, cls):
cls.add_method('GetFrequency',
'uint32_t',
[],
- is_pure_virtual=True, is_const=True, is_virtual=True)
+ is_const=True, is_virtual=True)
## wifi-phy.h (module 'wifi'): bool ns3::WifiPhy::GetGreenfield() const [member function]
cls.add_method('GetGreenfield',
'bool',
@@ -7279,6 +7289,11 @@ def register_Ns3WifiPhy_methods(root_module, cls):
'bool',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## wifi-phy.h (module 'wifi'): ns3::WifiPhyStandard ns3::WifiPhy::GetStandard() const [member function]
+ cls.add_method('GetStandard',
+ 'ns3::WifiPhyStandard',
+ [],
+ is_const=True, is_virtual=True)
## wifi-phy.h (module 'wifi'): ns3::Time ns3::WifiPhy::GetStateDuration() [member function]
cls.add_method('GetStateDuration',
'ns3::Time',
@@ -7293,7 +7308,7 @@ def register_Ns3WifiPhy_methods(root_module, cls):
cls.add_method('GetSupportedChannelWidthSet',
'std::vector< unsigned int >',
[],
- is_pure_virtual=True, is_const=True, is_virtual=True)
+ is_const=True, is_virtual=True)
## wifi-phy.h (module 'wifi'): uint8_t ns3::WifiPhy::GetSupportedRxSpatialStreams() const [member function]
cls.add_method('GetSupportedRxSpatialStreams',
'uint8_t',
@@ -7480,17 +7495,17 @@ def register_Ns3WifiPhy_methods(root_module, cls):
cls.add_method('SetChannelNumber',
'void',
[param('uint16_t', 'id')],
- is_pure_virtual=True, is_virtual=True)
+ is_virtual=True)
## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::SetChannelWidth(uint32_t channelwidth) [member function]
cls.add_method('SetChannelWidth',
'void',
[param('uint32_t', 'channelwidth')],
- is_pure_virtual=True, is_virtual=True)
+ is_virtual=True)
## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::SetFrequency(uint32_t freq) [member function]
cls.add_method('SetFrequency',
'void',
[param('uint32_t', 'freq')],
- is_pure_virtual=True, is_virtual=True)
+ is_virtual=True)
## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::SetGreenfield(bool greenfield) [member function]
cls.add_method('SetGreenfield',
'void',
@@ -7551,6 +7566,31 @@ def register_Ns3WifiPhy_methods(root_module, cls):
'double',
[param('double', 'w')],
is_const=True)
+ ## wifi-phy.h (module 'wifi'): bool ns3::WifiPhy::DoChannelSwitch(uint16_t id) [member function]
+ cls.add_method('DoChannelSwitch',
+ 'bool',
+ [param('uint16_t', 'id')],
+ visibility='protected', is_virtual=True)
+ ## wifi-phy.h (module 'wifi'): bool ns3::WifiPhy::DoFrequencySwitch(uint32_t frequency) [member function]
+ cls.add_method('DoFrequencySwitch',
+ 'bool',
+ [param('uint32_t', 'frequency')],
+ visibility='protected', is_virtual=True)
+ ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::DoInitialize() [member function]
+ cls.add_method('DoInitialize',
+ 'void',
+ [],
+ visibility='protected', is_virtual=True)
+ ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::ConfigureChannelForStandard(ns3::WifiPhyStandard standard) [member function]
+ cls.add_method('ConfigureChannelForStandard',
+ 'void',
+ [param('ns3::WifiPhyStandard', 'standard')],
+ visibility='private', is_virtual=True)
+ ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::ConfigureDefaultsForStandard(ns3::WifiPhyStandard standard) [member function]
+ cls.add_method('ConfigureDefaultsForStandard',
+ 'void',
+ [param('ns3::WifiPhyStandard', 'standard')],
+ visibility='private', is_virtual=True)
return
def register_Ns3WifiRemoteStationManager_methods(root_module, cls):
@@ -10166,165 +10206,6 @@ def register_Ns3Ipv6AddressValue_methods(root_module, cls):
[param('ns3::Ipv6Address const &', 'value')])
return
-def register_Ns3Ipv6Interface_methods(root_module, cls):
- ## ipv6-interface.h (module 'internet'): ns3::Ipv6Interface::Ipv6Interface(ns3::Ipv6Interface const & arg0) [copy constructor]
- cls.add_constructor([param('ns3::Ipv6Interface const &', 'arg0')])
- ## ipv6-interface.h (module 'internet'): ns3::Ipv6Interface::Ipv6Interface() [constructor]
- cls.add_constructor([])
- ## ipv6-interface.h (module 'internet'): bool ns3::Ipv6Interface::AddAddress(ns3::Ipv6InterfaceAddress iface) [member function]
- cls.add_method('AddAddress',
- 'bool',
- [param('ns3::Ipv6InterfaceAddress', 'iface')])
- ## ipv6-interface.h (module 'internet'): ns3::Ipv6InterfaceAddress ns3::Ipv6Interface::GetAddress(uint32_t index) const [member function]
- cls.add_method('GetAddress',
- 'ns3::Ipv6InterfaceAddress',
- [param('uint32_t', 'index')],
- is_const=True)
- ## ipv6-interface.h (module 'internet'): ns3::Ipv6InterfaceAddress ns3::Ipv6Interface::GetAddressMatchingDestination(ns3::Ipv6Address dst) [member function]
- cls.add_method('GetAddressMatchingDestination',
- 'ns3::Ipv6InterfaceAddress',
- [param('ns3::Ipv6Address', 'dst')])
- ## ipv6-interface.h (module 'internet'): uint16_t ns3::Ipv6Interface::GetBaseReachableTime() const [member function]
- cls.add_method('GetBaseReachableTime',
- 'uint16_t',
- [],
- is_const=True)
- ## ipv6-interface.h (module 'internet'): uint8_t ns3::Ipv6Interface::GetCurHopLimit() const [member function]
- cls.add_method('GetCurHopLimit',
- 'uint8_t',
- [],
- is_const=True)
- ## ipv6-interface.h (module 'internet'): ns3::Ptr ns3::Ipv6Interface::GetDevice() const [member function]
- cls.add_method('GetDevice',
- 'ns3::Ptr< ns3::NetDevice >',
- [],
- is_const=True, is_virtual=True)
- ## ipv6-interface.h (module 'internet'): ns3::Ipv6InterfaceAddress ns3::Ipv6Interface::GetLinkLocalAddress() const [member function]
- cls.add_method('GetLinkLocalAddress',
- 'ns3::Ipv6InterfaceAddress',
- [],
- is_const=True)
- ## ipv6-interface.h (module 'internet'): uint16_t ns3::Ipv6Interface::GetMetric() const [member function]
- cls.add_method('GetMetric',
- 'uint16_t',
- [],
- is_const=True)
- ## ipv6-interface.h (module 'internet'): uint32_t ns3::Ipv6Interface::GetNAddresses() const [member function]
- cls.add_method('GetNAddresses',
- 'uint32_t',
- [],
- is_const=True)
- ## ipv6-interface.h (module 'internet'): ns3::Ptr ns3::Ipv6Interface::GetNdiscCache() const [member function]
- cls.add_method('GetNdiscCache',
- 'ns3::Ptr< ns3::NdiscCache >',
- [],
- is_const=True)
- ## ipv6-interface.h (module 'internet'): uint16_t ns3::Ipv6Interface::GetReachableTime() const [member function]
- cls.add_method('GetReachableTime',
- 'uint16_t',
- [],
- is_const=True)
- ## ipv6-interface.h (module 'internet'): uint16_t ns3::Ipv6Interface::GetRetransTimer() const [member function]
- cls.add_method('GetRetransTimer',
- 'uint16_t',
- [],
- is_const=True)
- ## ipv6-interface.h (module 'internet'): static ns3::TypeId ns3::Ipv6Interface::GetTypeId() [member function]
- cls.add_method('GetTypeId',
- 'ns3::TypeId',
- [],
- is_static=True)
- ## ipv6-interface.h (module 'internet'): bool ns3::Ipv6Interface::IsDown() const [member function]
- cls.add_method('IsDown',
- 'bool',
- [],
- is_const=True)
- ## ipv6-interface.h (module 'internet'): bool ns3::Ipv6Interface::IsForwarding() const [member function]
- cls.add_method('IsForwarding',
- 'bool',
- [],
- is_const=True)
- ## ipv6-interface.h (module 'internet'): bool ns3::Ipv6Interface::IsSolicitedMulticastAddress(ns3::Ipv6Address address) const [member function]
- cls.add_method('IsSolicitedMulticastAddress',
- 'bool',
- [param('ns3::Ipv6Address', 'address')],
- is_const=True)
- ## ipv6-interface.h (module 'internet'): bool ns3::Ipv6Interface::IsUp() const [member function]
- cls.add_method('IsUp',
- 'bool',
- [],
- is_const=True)
- ## ipv6-interface.h (module 'internet'): ns3::Ipv6InterfaceAddress ns3::Ipv6Interface::RemoveAddress(uint32_t index) [member function]
- cls.add_method('RemoveAddress',
- 'ns3::Ipv6InterfaceAddress',
- [param('uint32_t', 'index')])
- ## ipv6-interface.h (module 'internet'): ns3::Ipv6InterfaceAddress ns3::Ipv6Interface::RemoveAddress(ns3::Ipv6Address address) [member function]
- cls.add_method('RemoveAddress',
- 'ns3::Ipv6InterfaceAddress',
- [param('ns3::Ipv6Address', 'address')])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::Send(ns3::Ptr p, ns3::Ipv6Header const & hdr, ns3::Ipv6Address dest) [member function]
- cls.add_method('Send',
- 'void',
- [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv6Header const &', 'hdr'), param('ns3::Ipv6Address', 'dest')])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::SetBaseReachableTime(uint16_t baseReachableTime) [member function]
- cls.add_method('SetBaseReachableTime',
- 'void',
- [param('uint16_t', 'baseReachableTime')])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::SetCurHopLimit(uint8_t curHopLimit) [member function]
- cls.add_method('SetCurHopLimit',
- 'void',
- [param('uint8_t', 'curHopLimit')])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::SetDevice(ns3::Ptr device) [member function]
- cls.add_method('SetDevice',
- 'void',
- [param('ns3::Ptr< ns3::NetDevice >', 'device')])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::SetDown() [member function]
- cls.add_method('SetDown',
- 'void',
- [])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::SetForwarding(bool forward) [member function]
- cls.add_method('SetForwarding',
- 'void',
- [param('bool', 'forward')])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::SetMetric(uint16_t metric) [member function]
- cls.add_method('SetMetric',
- 'void',
- [param('uint16_t', 'metric')])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::SetNode(ns3::Ptr node) [member function]
- cls.add_method('SetNode',
- 'void',
- [param('ns3::Ptr< ns3::Node >', 'node')])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::SetNsDadUid(ns3::Ipv6Address address, uint32_t uid) [member function]
- cls.add_method('SetNsDadUid',
- 'void',
- [param('ns3::Ipv6Address', 'address'), param('uint32_t', 'uid')])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::SetReachableTime(uint16_t reachableTime) [member function]
- cls.add_method('SetReachableTime',
- 'void',
- [param('uint16_t', 'reachableTime')])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::SetRetransTimer(uint16_t retransTimer) [member function]
- cls.add_method('SetRetransTimer',
- 'void',
- [param('uint16_t', 'retransTimer')])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::SetState(ns3::Ipv6Address address, ns3::Ipv6InterfaceAddress::State_e state) [member function]
- cls.add_method('SetState',
- 'void',
- [param('ns3::Ipv6Address', 'address'), param('ns3::Ipv6InterfaceAddress::State_e', 'state')])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::SetTrafficControl(ns3::Ptr tc) [member function]
- cls.add_method('SetTrafficControl',
- 'void',
- [param('ns3::Ptr< ns3::TrafficControlLayer >', 'tc')])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::SetUp() [member function]
- cls.add_method('SetUp',
- 'void',
- [])
- ## ipv6-interface.h (module 'internet'): void ns3::Ipv6Interface::DoDispose() [member function]
- cls.add_method('DoDispose',
- 'void',
- [],
- visibility='protected', is_virtual=True)
- return
-
def register_Ns3Ipv6PrefixChecker_methods(root_module, cls):
## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker::Ipv6PrefixChecker() [constructor]
cls.add_constructor([])
@@ -10580,11 +10461,6 @@ def register_Ns3NetDeviceQueue_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueue const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueue::NetDeviceQueue() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): bool ns3::NetDeviceQueue::HasWakeCallbackSet() const [member function]
- cls.add_method('HasWakeCallbackSet',
- 'bool',
- [],
- is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDeviceQueue::IsStopped() const [member function]
cls.add_method('IsStopped',
'bool',
@@ -10617,21 +10493,25 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueueInterface const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetSelectedQueue(ns3::Ptr item) const [member function]
- cls.add_method('GetSelectedQueue',
+ ## net-device.h (module 'network'): void ns3::NetDeviceQueueInterface::CreateTxQueues() [member function]
+ cls.add_method('CreateTxQueues',
+ 'void',
+ [])
+ ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetNTxQueues() const [member function]
+ cls.add_method('GetNTxQueues',
'uint8_t',
- [param('ns3::Ptr< ns3::QueueItem >', 'item')],
+ [],
+ is_const=True)
+ ## net-device.h (module 'network'): ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ns3::NetDeviceQueueInterface::GetSelectQueueCallback() const [member function]
+ cls.add_method('GetSelectQueueCallback',
+ 'ns3::Callback< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >',
+ [],
is_const=True)
## net-device.h (module 'network'): ns3::Ptr ns3::NetDeviceQueueInterface::GetTxQueue(uint8_t i) const [member function]
cls.add_method('GetTxQueue',
'ns3::Ptr< ns3::NetDeviceQueue >',
[param('uint8_t', 'i')],
is_const=True)
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetTxQueuesN() const [member function]
- cls.add_method('GetTxQueuesN',
- 'uint8_t',
- [],
- is_const=True)
## net-device.h (module 'network'): static ns3::TypeId ns3::NetDeviceQueueInterface::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
@@ -11124,6 +11004,11 @@ def register_Ns3QueueItem_methods(root_module, cls):
'uint32_t',
[],
is_const=True, is_virtual=True)
+ ## net-device.h (module 'network'): bool ns3::QueueItem::GetUint8Value(ns3::QueueItem::Uint8Values field, uint8_t & value) const [member function]
+ cls.add_method('GetUint8Value',
+ 'bool',
+ [param('ns3::QueueItem::Uint8Values', 'field'), param('uint8_t &', 'value')],
+ is_const=True, is_virtual=True)
## net-device.h (module 'network'): void ns3::QueueItem::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
diff --git a/src/energy/bindings/modulegen__gcc_ILP32.py b/src/energy/bindings/modulegen__gcc_ILP32.py
index 1dc1d53fd61..47b58ba47d2 100644
--- a/src/energy/bindings/modulegen__gcc_ILP32.py
+++ b/src/energy/bindings/modulegen__gcc_ILP32.py
@@ -232,6 +232,8 @@ def register_types(module):
module.add_class('ParetoRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream'])
## net-device.h (module 'network'): ns3::QueueItem [class]
module.add_class('QueueItem', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >'])
+ ## net-device.h (module 'network'): ns3::QueueItem::Uint8Values [enumeration]
+ module.add_enum('Uint8Values', ['IP_DSFIELD'], outer_class=root_module['ns3::QueueItem'], import_from_module='ns.network')
## rv-battery-model.h (module 'energy'): ns3::RvBatteryModel [class]
module.add_class('RvBatteryModel', parent=root_module['ns3::EnergySource'])
## simple-device-energy-model.h (module 'energy'): ns3::SimpleDeviceEnergyModel [class]
@@ -320,12 +322,12 @@ def register_types_ns3_TracedValueCallback(module):
typehandlers.add_type_alias(u'void ( * ) ( double, double ) *', u'ns3::TracedValueCallback::Double')
typehandlers.add_type_alias(u'void ( * ) ( double, double ) **', u'ns3::TracedValueCallback::Double*')
typehandlers.add_type_alias(u'void ( * ) ( double, double ) *&', u'ns3::TracedValueCallback::Double&')
- typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) *', u'ns3::TracedValueCallback::Int8')
- typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) **', u'ns3::TracedValueCallback::Int8*')
- typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) *&', u'ns3::TracedValueCallback::Int8&')
typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) *', u'ns3::TracedValueCallback::Uint8')
typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) **', u'ns3::TracedValueCallback::Uint8*')
typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) *&', u'ns3::TracedValueCallback::Uint8&')
+ typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) *', u'ns3::TracedValueCallback::Int8')
+ typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) **', u'ns3::TracedValueCallback::Int8*')
+ typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) *&', u'ns3::TracedValueCallback::Int8&')
typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) *', u'ns3::TracedValueCallback::Uint32')
typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) **', u'ns3::TracedValueCallback::Uint32*')
typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) *&', u'ns3::TracedValueCallback::Uint32&')
@@ -1954,6 +1956,11 @@ def register_Ns3Object_methods(root_module, cls):
cls.add_method('Initialize',
'void',
[])
+ ## object.h (module 'core'): bool ns3::Object::IsInitialized() const [member function]
+ cls.add_method('IsInitialized',
+ 'bool',
+ [],
+ is_const=True)
## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
cls.add_constructor([param('ns3::Object const &', 'o')],
visibility='protected')
@@ -3939,11 +3946,6 @@ def register_Ns3NetDeviceQueue_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueue const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueue::NetDeviceQueue() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): bool ns3::NetDeviceQueue::HasWakeCallbackSet() const [member function]
- cls.add_method('HasWakeCallbackSet',
- 'bool',
- [],
- is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDeviceQueue::IsStopped() const [member function]
cls.add_method('IsStopped',
'bool',
@@ -3976,21 +3978,25 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueueInterface const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetSelectedQueue(ns3::Ptr item) const [member function]
- cls.add_method('GetSelectedQueue',
+ ## net-device.h (module 'network'): void ns3::NetDeviceQueueInterface::CreateTxQueues() [member function]
+ cls.add_method('CreateTxQueues',
+ 'void',
+ [])
+ ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetNTxQueues() const [member function]
+ cls.add_method('GetNTxQueues',
'uint8_t',
- [param('ns3::Ptr< ns3::QueueItem >', 'item')],
+ [],
+ is_const=True)
+ ## net-device.h (module 'network'): ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ns3::NetDeviceQueueInterface::GetSelectQueueCallback() const [member function]
+ cls.add_method('GetSelectQueueCallback',
+ 'ns3::Callback< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >',
+ [],
is_const=True)
## net-device.h (module 'network'): ns3::Ptr ns3::NetDeviceQueueInterface::GetTxQueue(uint8_t i) const [member function]
cls.add_method('GetTxQueue',
'ns3::Ptr< ns3::NetDeviceQueue >',
[param('uint8_t', 'i')],
is_const=True)
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetTxQueuesN() const [member function]
- cls.add_method('GetTxQueuesN',
- 'uint8_t',
- [],
- is_const=True)
## net-device.h (module 'network'): static ns3::TypeId ns3::NetDeviceQueueInterface::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
@@ -4241,6 +4247,11 @@ def register_Ns3QueueItem_methods(root_module, cls):
'uint32_t',
[],
is_const=True, is_virtual=True)
+ ## net-device.h (module 'network'): bool ns3::QueueItem::GetUint8Value(ns3::QueueItem::Uint8Values field, uint8_t & value) const [member function]
+ cls.add_method('GetUint8Value',
+ 'bool',
+ [param('ns3::QueueItem::Uint8Values', 'field'), param('uint8_t &', 'value')],
+ is_const=True, is_virtual=True)
## net-device.h (module 'network'): void ns3::QueueItem::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
diff --git a/src/energy/bindings/modulegen__gcc_LP64.py b/src/energy/bindings/modulegen__gcc_LP64.py
index 1dc1d53fd61..47b58ba47d2 100644
--- a/src/energy/bindings/modulegen__gcc_LP64.py
+++ b/src/energy/bindings/modulegen__gcc_LP64.py
@@ -232,6 +232,8 @@ def register_types(module):
module.add_class('ParetoRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream'])
## net-device.h (module 'network'): ns3::QueueItem [class]
module.add_class('QueueItem', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >'])
+ ## net-device.h (module 'network'): ns3::QueueItem::Uint8Values [enumeration]
+ module.add_enum('Uint8Values', ['IP_DSFIELD'], outer_class=root_module['ns3::QueueItem'], import_from_module='ns.network')
## rv-battery-model.h (module 'energy'): ns3::RvBatteryModel [class]
module.add_class('RvBatteryModel', parent=root_module['ns3::EnergySource'])
## simple-device-energy-model.h (module 'energy'): ns3::SimpleDeviceEnergyModel [class]
@@ -320,12 +322,12 @@ def register_types_ns3_TracedValueCallback(module):
typehandlers.add_type_alias(u'void ( * ) ( double, double ) *', u'ns3::TracedValueCallback::Double')
typehandlers.add_type_alias(u'void ( * ) ( double, double ) **', u'ns3::TracedValueCallback::Double*')
typehandlers.add_type_alias(u'void ( * ) ( double, double ) *&', u'ns3::TracedValueCallback::Double&')
- typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) *', u'ns3::TracedValueCallback::Int8')
- typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) **', u'ns3::TracedValueCallback::Int8*')
- typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) *&', u'ns3::TracedValueCallback::Int8&')
typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) *', u'ns3::TracedValueCallback::Uint8')
typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) **', u'ns3::TracedValueCallback::Uint8*')
typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) *&', u'ns3::TracedValueCallback::Uint8&')
+ typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) *', u'ns3::TracedValueCallback::Int8')
+ typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) **', u'ns3::TracedValueCallback::Int8*')
+ typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) *&', u'ns3::TracedValueCallback::Int8&')
typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) *', u'ns3::TracedValueCallback::Uint32')
typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) **', u'ns3::TracedValueCallback::Uint32*')
typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) *&', u'ns3::TracedValueCallback::Uint32&')
@@ -1954,6 +1956,11 @@ def register_Ns3Object_methods(root_module, cls):
cls.add_method('Initialize',
'void',
[])
+ ## object.h (module 'core'): bool ns3::Object::IsInitialized() const [member function]
+ cls.add_method('IsInitialized',
+ 'bool',
+ [],
+ is_const=True)
## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
cls.add_constructor([param('ns3::Object const &', 'o')],
visibility='protected')
@@ -3939,11 +3946,6 @@ def register_Ns3NetDeviceQueue_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueue const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueue::NetDeviceQueue() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): bool ns3::NetDeviceQueue::HasWakeCallbackSet() const [member function]
- cls.add_method('HasWakeCallbackSet',
- 'bool',
- [],
- is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDeviceQueue::IsStopped() const [member function]
cls.add_method('IsStopped',
'bool',
@@ -3976,21 +3978,25 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueueInterface const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetSelectedQueue(ns3::Ptr item) const [member function]
- cls.add_method('GetSelectedQueue',
+ ## net-device.h (module 'network'): void ns3::NetDeviceQueueInterface::CreateTxQueues() [member function]
+ cls.add_method('CreateTxQueues',
+ 'void',
+ [])
+ ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetNTxQueues() const [member function]
+ cls.add_method('GetNTxQueues',
'uint8_t',
- [param('ns3::Ptr< ns3::QueueItem >', 'item')],
+ [],
+ is_const=True)
+ ## net-device.h (module 'network'): ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ns3::NetDeviceQueueInterface::GetSelectQueueCallback() const [member function]
+ cls.add_method('GetSelectQueueCallback',
+ 'ns3::Callback< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >',
+ [],
is_const=True)
## net-device.h (module 'network'): ns3::Ptr ns3::NetDeviceQueueInterface::GetTxQueue(uint8_t i) const [member function]
cls.add_method('GetTxQueue',
'ns3::Ptr< ns3::NetDeviceQueue >',
[param('uint8_t', 'i')],
is_const=True)
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetTxQueuesN() const [member function]
- cls.add_method('GetTxQueuesN',
- 'uint8_t',
- [],
- is_const=True)
## net-device.h (module 'network'): static ns3::TypeId ns3::NetDeviceQueueInterface::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
@@ -4241,6 +4247,11 @@ def register_Ns3QueueItem_methods(root_module, cls):
'uint32_t',
[],
is_const=True, is_virtual=True)
+ ## net-device.h (module 'network'): bool ns3::QueueItem::GetUint8Value(ns3::QueueItem::Uint8Values field, uint8_t & value) const [member function]
+ cls.add_method('GetUint8Value',
+ 'bool',
+ [param('ns3::QueueItem::Uint8Values', 'field'), param('uint8_t &', 'value')],
+ is_const=True, is_virtual=True)
## net-device.h (module 'network'): void ns3::QueueItem::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
diff --git a/src/fd-net-device/bindings/modulegen__gcc_ILP32.py b/src/fd-net-device/bindings/modulegen__gcc_ILP32.py
index 09547079ee6..90859bbd979 100644
--- a/src/fd-net-device/bindings/modulegen__gcc_ILP32.py
+++ b/src/fd-net-device/bindings/modulegen__gcc_ILP32.py
@@ -256,6 +256,8 @@ def register_types(module):
module.add_class('Packet', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter >'])
## net-device.h (module 'network'): ns3::QueueItem [class]
module.add_class('QueueItem', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >'])
+ ## net-device.h (module 'network'): ns3::QueueItem::Uint8Values [enumeration]
+ module.add_enum('Uint8Values', ['IP_DSFIELD'], outer_class=root_module['ns3::QueueItem'], import_from_module='ns.network')
## tap-fd-net-device-helper.h (module 'fd-net-device'): ns3::TapFdNetDeviceHelper [class]
module.add_class('TapFdNetDeviceHelper', parent=root_module['ns3::EmuFdNetDeviceHelper'])
## nstime.h (module 'core'): ns3::TimeValue [class]
@@ -2875,6 +2877,11 @@ def register_Ns3Object_methods(root_module, cls):
cls.add_method('Initialize',
'void',
[])
+ ## object.h (module 'core'): bool ns3::Object::IsInitialized() const [member function]
+ cls.add_method('IsInitialized',
+ 'bool',
+ [],
+ is_const=True)
## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
cls.add_constructor([param('ns3::Object const &', 'o')],
visibility='protected')
@@ -4063,11 +4070,6 @@ def register_Ns3NetDeviceQueue_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueue const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueue::NetDeviceQueue() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): bool ns3::NetDeviceQueue::HasWakeCallbackSet() const [member function]
- cls.add_method('HasWakeCallbackSet',
- 'bool',
- [],
- is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDeviceQueue::IsStopped() const [member function]
cls.add_method('IsStopped',
'bool',
@@ -4100,21 +4102,25 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueueInterface const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetSelectedQueue(ns3::Ptr item) const [member function]
- cls.add_method('GetSelectedQueue',
+ ## net-device.h (module 'network'): void ns3::NetDeviceQueueInterface::CreateTxQueues() [member function]
+ cls.add_method('CreateTxQueues',
+ 'void',
+ [])
+ ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetNTxQueues() const [member function]
+ cls.add_method('GetNTxQueues',
'uint8_t',
- [param('ns3::Ptr< ns3::QueueItem >', 'item')],
+ [],
+ is_const=True)
+ ## net-device.h (module 'network'): ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ns3::NetDeviceQueueInterface::GetSelectQueueCallback() const [member function]
+ cls.add_method('GetSelectQueueCallback',
+ 'ns3::Callback< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >',
+ [],
is_const=True)
## net-device.h (module 'network'): ns3::Ptr ns3::NetDeviceQueueInterface::GetTxQueue(uint8_t i) const [member function]
cls.add_method('GetTxQueue',
'ns3::Ptr< ns3::NetDeviceQueue >',
[param('uint8_t', 'i')],
is_const=True)
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetTxQueuesN() const [member function]
- cls.add_method('GetTxQueuesN',
- 'uint8_t',
- [],
- is_const=True)
## net-device.h (module 'network'): static ns3::TypeId ns3::NetDeviceQueueInterface::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
@@ -4519,6 +4525,11 @@ def register_Ns3QueueItem_methods(root_module, cls):
'uint32_t',
[],
is_const=True, is_virtual=True)
+ ## net-device.h (module 'network'): bool ns3::QueueItem::GetUint8Value(ns3::QueueItem::Uint8Values field, uint8_t & value) const [member function]
+ cls.add_method('GetUint8Value',
+ 'bool',
+ [param('ns3::QueueItem::Uint8Values', 'field'), param('uint8_t &', 'value')],
+ is_const=True, is_virtual=True)
## net-device.h (module 'network'): void ns3::QueueItem::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
diff --git a/src/fd-net-device/bindings/modulegen__gcc_LP64.py b/src/fd-net-device/bindings/modulegen__gcc_LP64.py
index 1d795d91a42..f5e727f7b2e 100644
--- a/src/fd-net-device/bindings/modulegen__gcc_LP64.py
+++ b/src/fd-net-device/bindings/modulegen__gcc_LP64.py
@@ -256,6 +256,8 @@ def register_types(module):
module.add_class('Packet', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter >'])
## net-device.h (module 'network'): ns3::QueueItem [class]
module.add_class('QueueItem', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >'])
+ ## net-device.h (module 'network'): ns3::QueueItem::Uint8Values [enumeration]
+ module.add_enum('Uint8Values', ['IP_DSFIELD'], outer_class=root_module['ns3::QueueItem'], import_from_module='ns.network')
## tap-fd-net-device-helper.h (module 'fd-net-device'): ns3::TapFdNetDeviceHelper [class]
module.add_class('TapFdNetDeviceHelper', parent=root_module['ns3::EmuFdNetDeviceHelper'])
## nstime.h (module 'core'): ns3::TimeValue [class]
@@ -2875,6 +2877,11 @@ def register_Ns3Object_methods(root_module, cls):
cls.add_method('Initialize',
'void',
[])
+ ## object.h (module 'core'): bool ns3::Object::IsInitialized() const [member function]
+ cls.add_method('IsInitialized',
+ 'bool',
+ [],
+ is_const=True)
## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
cls.add_constructor([param('ns3::Object const &', 'o')],
visibility='protected')
@@ -4063,11 +4070,6 @@ def register_Ns3NetDeviceQueue_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueue const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueue::NetDeviceQueue() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): bool ns3::NetDeviceQueue::HasWakeCallbackSet() const [member function]
- cls.add_method('HasWakeCallbackSet',
- 'bool',
- [],
- is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDeviceQueue::IsStopped() const [member function]
cls.add_method('IsStopped',
'bool',
@@ -4100,21 +4102,25 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueueInterface const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetSelectedQueue(ns3::Ptr item) const [member function]
- cls.add_method('GetSelectedQueue',
+ ## net-device.h (module 'network'): void ns3::NetDeviceQueueInterface::CreateTxQueues() [member function]
+ cls.add_method('CreateTxQueues',
+ 'void',
+ [])
+ ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetNTxQueues() const [member function]
+ cls.add_method('GetNTxQueues',
'uint8_t',
- [param('ns3::Ptr< ns3::QueueItem >', 'item')],
+ [],
+ is_const=True)
+ ## net-device.h (module 'network'): ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ns3::NetDeviceQueueInterface::GetSelectQueueCallback() const [member function]
+ cls.add_method('GetSelectQueueCallback',
+ 'ns3::Callback< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >',
+ [],
is_const=True)
## net-device.h (module 'network'): ns3::Ptr ns3::NetDeviceQueueInterface::GetTxQueue(uint8_t i) const [member function]
cls.add_method('GetTxQueue',
'ns3::Ptr< ns3::NetDeviceQueue >',
[param('uint8_t', 'i')],
is_const=True)
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetTxQueuesN() const [member function]
- cls.add_method('GetTxQueuesN',
- 'uint8_t',
- [],
- is_const=True)
## net-device.h (module 'network'): static ns3::TypeId ns3::NetDeviceQueueInterface::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
@@ -4519,6 +4525,11 @@ def register_Ns3QueueItem_methods(root_module, cls):
'uint32_t',
[],
is_const=True, is_virtual=True)
+ ## net-device.h (module 'network'): bool ns3::QueueItem::GetUint8Value(ns3::QueueItem::Uint8Values field, uint8_t & value) const [member function]
+ cls.add_method('GetUint8Value',
+ 'bool',
+ [param('ns3::QueueItem::Uint8Values', 'field'), param('uint8_t &', 'value')],
+ is_const=True, is_virtual=True)
## net-device.h (module 'network'): void ns3::QueueItem::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
diff --git a/src/flow-monitor/bindings/modulegen__gcc_ILP32.py b/src/flow-monitor/bindings/modulegen__gcc_ILP32.py
index 96e5b5f2c4c..cdb29db43a5 100644
--- a/src/flow-monitor/bindings/modulegen__gcc_ILP32.py
+++ b/src/flow-monitor/bindings/modulegen__gcc_ILP32.py
@@ -194,6 +194,8 @@ def register_types(module):
module.add_enum('SocketErrno', ['ERROR_NOTERROR', 'ERROR_ISCONN', 'ERROR_NOTCONN', 'ERROR_MSGSIZE', 'ERROR_AGAIN', 'ERROR_SHUTDOWN', 'ERROR_OPNOTSUPP', 'ERROR_AFNOSUPPORT', 'ERROR_INVAL', 'ERROR_BADF', 'ERROR_NOROUTETOHOST', 'ERROR_NODEV', 'ERROR_ADDRNOTAVAIL', 'ERROR_ADDRINUSE', 'SOCKET_ERRNO_LAST'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::SocketType [enumeration]
module.add_enum('SocketType', ['NS3_SOCK_STREAM', 'NS3_SOCK_SEQPACKET', 'NS3_SOCK_DGRAM', 'NS3_SOCK_RAW'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
+ ## socket.h (module 'network'): ns3::Socket::SocketPriority [enumeration]
+ module.add_enum('SocketPriority', ['NS3_PRIO_BESTEFFORT', 'NS3_PRIO_FILLER', 'NS3_PRIO_BULK', 'NS3_PRIO_INTERACTIVE_BULK', 'NS3_PRIO_INTERACTIVE', 'NS3_PRIO_CONTROL'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::Ipv6MulticastFilterMode [enumeration]
module.add_enum('Ipv6MulticastFilterMode', ['INCLUDE', 'EXCLUDE'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::SocketIpTosTag [class]
@@ -204,6 +206,8 @@ def register_types(module):
module.add_class('SocketIpv6HopLimitTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketIpv6TclassTag [class]
module.add_class('SocketIpv6TclassTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
+ ## socket.h (module 'network'): ns3::SocketPriorityTag [class]
+ module.add_class('SocketPriorityTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketSetDontFragmentTag [class]
module.add_class('SocketSetDontFragmentTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## nstime.h (module 'core'): ns3::Time [class]
@@ -320,6 +324,8 @@ def register_types(module):
module.add_class('Packet', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter >'])
## net-device.h (module 'network'): ns3::QueueItem [class]
module.add_class('QueueItem', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >'])
+ ## net-device.h (module 'network'): ns3::QueueItem::Uint8Values [enumeration]
+ module.add_enum('Uint8Values', ['IP_DSFIELD'], outer_class=root_module['ns3::QueueItem'], import_from_module='ns.network')
## nstime.h (module 'core'): ns3::TimeValue [class]
module.add_class('TimeValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
## type-id.h (module 'core'): ns3::TypeIdChecker [class]
@@ -475,6 +481,7 @@ def register_methods(root_module):
register_Ns3SocketIpTtlTag_methods(root_module, root_module['ns3::SocketIpTtlTag'])
register_Ns3SocketIpv6HopLimitTag_methods(root_module, root_module['ns3::SocketIpv6HopLimitTag'])
register_Ns3SocketIpv6TclassTag_methods(root_module, root_module['ns3::SocketIpv6TclassTag'])
+ register_Ns3SocketPriorityTag_methods(root_module, root_module['ns3::SocketPriorityTag'])
register_Ns3SocketSetDontFragmentTag_methods(root_module, root_module['ns3::SocketSetDontFragmentTag'])
register_Ns3Time_methods(root_module, root_module['ns3::Time'])
register_Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::TraceSourceAccessor'])
@@ -1242,6 +1249,11 @@ def register_Ns3InetSocketAddress_methods(root_module, cls):
'uint16_t',
[],
is_const=True)
+ ## inet-socket-address.h (module 'network'): uint8_t ns3::InetSocketAddress::GetTos() const [member function]
+ cls.add_method('GetTos',
+ 'uint8_t',
+ [],
+ is_const=True)
## inet-socket-address.h (module 'network'): static bool ns3::InetSocketAddress::IsMatchingType(ns3::Address const & address) [member function]
cls.add_method('IsMatchingType',
'bool',
@@ -1255,6 +1267,10 @@ def register_Ns3InetSocketAddress_methods(root_module, cls):
cls.add_method('SetPort',
'void',
[param('uint16_t', 'port')])
+ ## inet-socket-address.h (module 'network'): void ns3::InetSocketAddress::SetTos(uint8_t tos) [member function]
+ cls.add_method('SetTos',
+ 'void',
+ [param('uint8_t', 'tos')])
return
def register_Ns3Ipv4Address_methods(root_module, cls):
@@ -3097,6 +3113,11 @@ def register_Ns3Object_methods(root_module, cls):
cls.add_method('Initialize',
'void',
[])
+ ## object.h (module 'core'): bool ns3::Object::IsInitialized() const [member function]
+ cls.add_method('IsInitialized',
+ 'bool',
+ [],
+ is_const=True)
## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
cls.add_constructor([param('ns3::Object const &', 'o')],
visibility='protected')
@@ -3397,6 +3418,11 @@ def register_Ns3Socket_methods(root_module, cls):
'int',
[param('ns3::Address &', 'address')],
is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): uint8_t ns3::Socket::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
## socket.h (module 'network'): uint32_t ns3::Socket::GetRxAvailable() const [member function]
cls.add_method('GetRxAvailable',
'uint32_t',
@@ -3422,6 +3448,11 @@ def register_Ns3Socket_methods(root_module, cls):
'ns3::TypeId',
[],
is_static=True)
+ ## socket.h (module 'network'): static uint8_t ns3::Socket::IpTos2Priority(uint8_t ipTos) [member function]
+ cls.add_method('IpTos2Priority',
+ 'uint8_t',
+ [param('uint8_t', 'ipTos')],
+ is_static=True)
## socket.h (module 'network'): void ns3::Socket::Ipv6JoinGroup(ns3::Ipv6Address address, ns3::Socket::Ipv6MulticastFilterMode filterMode, std::vector > sourceAddresses) [member function]
cls.add_method('Ipv6JoinGroup',
'void',
@@ -3570,6 +3601,10 @@ def register_Ns3Socket_methods(root_module, cls):
cls.add_method('SetIpv6Tclass',
'void',
[param('int', 'ipTclass')])
+ ## socket.h (module 'network'): void ns3::Socket::SetPriority(uint8_t priority) [member function]
+ cls.add_method('SetPriority',
+ 'void',
+ [param('uint8_t', 'priority')])
## socket.h (module 'network'): void ns3::Socket::SetRecvCallback(ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> arg0) [member function]
cls.add_method('SetRecvCallback',
'void',
@@ -3597,11 +3632,6 @@ def register_Ns3Socket_methods(root_module, cls):
'void',
[],
visibility='protected', is_virtual=True)
- ## socket.h (module 'network'): bool ns3::Socket::IsManualIpTos() const [member function]
- cls.add_method('IsManualIpTos',
- 'bool',
- [],
- is_const=True, visibility='protected')
## socket.h (module 'network'): bool ns3::Socket::IsManualIpTtl() const [member function]
cls.add_method('IsManualIpTtl',
'bool',
@@ -3848,6 +3878,52 @@ def register_Ns3SocketIpv6TclassTag_methods(root_module, cls):
[param('uint8_t', 'tclass')])
return
+def register_Ns3SocketPriorityTag_methods(root_module, cls):
+ ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag(ns3::SocketPriorityTag const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::SocketPriorityTag const &', 'arg0')])
+ ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag() [constructor]
+ cls.add_constructor([])
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Deserialize(ns3::TagBuffer i) [member function]
+ cls.add_method('Deserialize',
+ 'void',
+ [param('ns3::TagBuffer', 'i')],
+ is_virtual=True)
+ ## socket.h (module 'network'): ns3::TypeId ns3::SocketPriorityTag::GetInstanceTypeId() const [member function]
+ cls.add_method('GetInstanceTypeId',
+ 'ns3::TypeId',
+ [],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): uint8_t ns3::SocketPriorityTag::GetPriority() const [member function]
+ cls.add_method('GetPriority',
+ 'uint8_t',
+ [],
+ is_const=True)
+ ## socket.h (module 'network'): uint32_t ns3::SocketPriorityTag::GetSerializedSize() const [member function]
+ cls.add_method('GetSerializedSize',
+ 'uint32_t',
+ [],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): static ns3::TypeId ns3::SocketPriorityTag::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Print(std::ostream & os) const [member function]
+ cls.add_method('Print',
+ 'void',
+ [param('std::ostream &', 'os')],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::Serialize(ns3::TagBuffer i) const [member function]
+ cls.add_method('Serialize',
+ 'void',
+ [param('ns3::TagBuffer', 'i')],
+ is_const=True, is_virtual=True)
+ ## socket.h (module 'network'): void ns3::SocketPriorityTag::SetPriority(uint8_t priority) [member function]
+ cls.add_method('SetPriority',
+ 'void',
+ [param('uint8_t', 'priority')])
+ return
+
def register_Ns3SocketSetDontFragmentTag_methods(root_module, cls):
## socket.h (module 'network'): ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag(ns3::SocketSetDontFragmentTag const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SocketSetDontFragmentTag const &', 'arg0')])
@@ -6095,11 +6171,6 @@ def register_Ns3NetDeviceQueue_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueue const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueue::NetDeviceQueue() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): bool ns3::NetDeviceQueue::HasWakeCallbackSet() const [member function]
- cls.add_method('HasWakeCallbackSet',
- 'bool',
- [],
- is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDeviceQueue::IsStopped() const [member function]
cls.add_method('IsStopped',
'bool',
@@ -6132,21 +6203,25 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls):
cls.add_constructor([param('ns3::NetDeviceQueueInterface const &', 'arg0')])
## net-device.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface() [constructor]
cls.add_constructor([])
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetSelectedQueue(ns3::Ptr item) const [member function]
- cls.add_method('GetSelectedQueue',
+ ## net-device.h (module 'network'): void ns3::NetDeviceQueueInterface::CreateTxQueues() [member function]
+ cls.add_method('CreateTxQueues',
+ 'void',
+ [])
+ ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetNTxQueues() const [member function]
+ cls.add_method('GetNTxQueues',
'uint8_t',
- [param('ns3::Ptr< ns3::QueueItem >', 'item')],
+ [],
+ is_const=True)
+ ## net-device.h (module 'network'): ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ns3::NetDeviceQueueInterface::GetSelectQueueCallback() const [member function]
+ cls.add_method('GetSelectQueueCallback',
+ 'ns3::Callback< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >',
+ [],
is_const=True)
## net-device.h (module 'network'): ns3::Ptr ns3::NetDeviceQueueInterface::GetTxQueue(uint8_t i) const [member function]
cls.add_method('GetTxQueue',
'ns3::Ptr< ns3::NetDeviceQueue >',
[param('uint8_t', 'i')],
is_const=True)
- ## net-device.h (module 'network'): uint8_t ns3::NetDeviceQueueInterface::GetTxQueuesN() const [member function]
- cls.add_method('GetTxQueuesN',
- 'uint8_t',
- [],
- is_const=True)
## net-device.h (module 'network'): static ns3::TypeId ns3::NetDeviceQueueInterface::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
@@ -6551,6 +6626,11 @@ def register_Ns3QueueItem_methods(root_module, cls):
'uint32_t',
[],
is_const=True, is_virtual=True)
+ ## net-device.h (module 'network'): bool ns3::QueueItem::GetUint8Value(ns3::QueueItem::Uint8Values field, uint8_t & value) const [member function]
+ cls.add_method('GetUint8Value',
+ 'bool',
+ [param('ns3::QueueItem::Uint8Values', 'field'), param('uint8_t &', 'value')],
+ is_const=True, is_virtual=True)
## net-device.h (module 'network'): void ns3::QueueItem::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
diff --git a/src/flow-monitor/bindings/modulegen__gcc_LP64.py b/src/flow-monitor/bindings/modulegen__gcc_LP64.py
index ab2f251b304..146f689dcda 100644
--- a/src/flow-monitor/bindings/modulegen__gcc_LP64.py
+++ b/src/flow-monitor/bindings/modulegen__gcc_LP64.py
@@ -194,6 +194,8 @@ def register_types(module):
module.add_enum('SocketErrno', ['ERROR_NOTERROR', 'ERROR_ISCONN', 'ERROR_NOTCONN', 'ERROR_MSGSIZE', 'ERROR_AGAIN', 'ERROR_SHUTDOWN', 'ERROR_OPNOTSUPP', 'ERROR_AFNOSUPPORT', 'ERROR_INVAL', 'ERROR_BADF', 'ERROR_NOROUTETOHOST', 'ERROR_NODEV', 'ERROR_ADDRNOTAVAIL', 'ERROR_ADDRINUSE', 'SOCKET_ERRNO_LAST'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::SocketType [enumeration]
module.add_enum('SocketType', ['NS3_SOCK_STREAM', 'NS3_SOCK_SEQPACKET', 'NS3_SOCK_DGRAM', 'NS3_SOCK_RAW'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
+ ## socket.h (module 'network'): ns3::Socket::SocketPriority [enumeration]
+ module.add_enum('SocketPriority', ['NS3_PRIO_BESTEFFORT', 'NS3_PRIO_FILLER', 'NS3_PRIO_BULK', 'NS3_PRIO_INTERACTIVE_BULK', 'NS3_PRIO_INTERACTIVE', 'NS3_PRIO_CONTROL'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::Socket::Ipv6MulticastFilterMode [enumeration]
module.add_enum('Ipv6MulticastFilterMode', ['INCLUDE', 'EXCLUDE'], outer_class=root_module['ns3::Socket'], import_from_module='ns.network')
## socket.h (module 'network'): ns3::SocketIpTosTag [class]
@@ -204,6 +206,8 @@ def register_types(module):
module.add_class('SocketIpv6HopLimitTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketIpv6TclassTag [class]
module.add_class('SocketIpv6TclassTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
+ ## socket.h (module 'network'): ns3::SocketPriorityTag [class]
+ module.add_class('SocketPriorityTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## socket.h (module 'network'): ns3::SocketSetDontFragmentTag [class]
module.add_class('SocketSetDontFragmentTag', import_from_module='ns.network', parent=root_module['ns3::Tag'])
## nstime.h (module 'core'): ns3::Time [class]
@@ -320,6 +324,8 @@ def register_types(module):
module.add_class('Packet', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter >'])
## net-device.h (module 'network'): ns3::QueueItem [class]
module.add_class('QueueItem', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter