Merge revert

PbbAddressBlock would not set its flags correctly when there was only a single
address in the address block.

.hgtags

@@ -37,3 +37,7 @@ dfd0bc16dc991313896f351530a3dc5a25f62e15 ns-3.3-RC4
 a600c11ff8d40a40e88c2d692acad6512dde70c8 ns-3.5-rc3
 c975274c9707b1f07d94cc51f205c351122131a5 ns-3.5
 549243b47311211975b388cd64fcb9111caa2fc2 ns-3.6-RC1
+8996042990466b1eda718a848e1c02923c0add74 ns-3.6-RC2
+79ff6ad1adbb7b4677759ddf52028b68b0515168 ns-3.6-RC3
+39a82d7a0d661febe42e75f26ada79424258e330 ns-3.6-RC4
+d55c479666ac6be0575fac695ddf355c0530e0dd ns-3.6

AUTHORS

@@ -6,29 +6,41 @@ Mehdi Benamor (mehdi.benamor@telecom-bretagne.eu)
 Raj Bhattacharjea (raj.b@gatech.edu)
 Timo Bingmann (timo.bingmann@student.kit.edu)
 Pavel Boyko (boyko@iitp.ru)
+Elena Buchatskaia (borovkovaes@iitp.ru)
 Gustavo Carneiro (gjc@inescporto.pt, gjcarneiro@gmail.com)
 Angelos Chatzipapas (chatzipa@ceid.upatras.gr)
 Luis Cortes (cortes@gatech.edu)
 Craig Dowell (craigdo@ee.washington.edu)
 David Gross (gdavid.devel@gmail.com)
+Mohamed Amine Ismail (amine.ismail@sophia.inria.fr, iamine@udcast.com)
 Tom Henderson (tomhend@u.washington.edu)
-Andrey Mazo (mazo@iitp.ru)
 Sam Jansen (sam.jansen@gmail.com)
 Liu Jian (liujatp@gmail.com)
 Joe Kopena (tjkopena@cs.drexel.edu)
 Aleksey Kovalenko (kovalenko@iitp.ru)
 Mathieu Lacage (mathieu.lacage@sophia.inria.fr)
 Emmanuelle Laprise (emmmanuelle.laprise@bluekazoo.ca)
+Keith Ma (keith.nwsuaf@gmail.com)
 Federico Maguolo (maguolof@dei.unipd.it)
+Antti Makela (zarhan@cc.hut.fi)
 Francesco Malandrino (francesco.malandrino@gmail.com)
+Fabian Mauchle (f1mauchl@hsr.ch)
+Andrey Mazo (mazo@iitp.ru)
 Faker Moatamri (faker.moatamri@sophia.inria.fr)
 Duy Nguyen (duy@soe.ucsc.edu)
+Tommaso Pecorella (tommaso.pecorella@unifi.it)
+Yana Podkosova (yanapdk@rambler.ru)
 Guangyu Pei (guangyu.pei@boeing.com)
 George F. Riley (riley@ece.gatech.edu)
 Providence Salumu Munga (Providence.Salumu@gmail.com, Providence.Salumu_Munga@it-sudparis.eu)
+Guillaume Seguin (guillaume.seguin@sophia.inria.fr)
 Kulin Shah (m.kulin@gmail.com)
+Ewgenij Starostin (estar@cs.tu-berlin.de)
+Adrian S. W. Tam (adrian.sw.tam@gmail.com)
+Wilson Thong (wilsonwk@ee.cityu.edu.hk)
 Mauro Tortonesi (mauro.tortonesi@unife.it)
 Sebastien Vincent (vincent@clarinet.u-strasbg.fr)
 Guillaume Vu-Brugier (gvubrugier@gmail.com)
+Tom Wambold (tom5760@gmail.com)
 Florian Westphal (fw@strlen.de)
 Josh Pelkey (jpelkey@gatech.edu)

CHANGES.html

@@ -43,6 +43,166 @@ the cracks, unfortunately.  If you, as a user, can suggest improvements
 to this file based on your experience, please contribute a patch or drop
 us a note on ns-developers mailing list.  </p>
 
+<hr>
+<h1>Changes from ns-3.6 to ns-3.7</h1>
+
+
+<h2>Changes to build system:</h2>
+
+<h2>New API:</h2>
+
+<ul>
+<li><b>Equal-cost multipath for global routing:</b> Enables quagga's
+equal cost multipath for Ipv4GlobalRouting, and adds an attribute that
+can enable it with random packet distribution policy across equal cost routes.
+<li><b>Binding sockets to devices:</b> A method analogous to a SO_BINDTODEVICE
+socket option has been introduced to class Socket:  <pre>virtual void Socket::BindToNetDevice (Ptr&lt;NetDevice&gt; netdevice);</pre>
+<li><b>Simulator event contexts</b>: The Simulator API now keeps track of a per-event
+'context' (a 32bit integer which, by convention identifies a node by its id). Simulator::GetContext
+returns the context of the currently-executing event while Simulator::ScheduleWithContext creates an
+event with a context different from the execution context of the caller. This API is used
+by the ns-3 logging system to report the execution context of each log line.
+<li><b>Object::DoStart</b>: Users who need to complete their object setup at the start of a simulation
+can override this virtual method, perform their adhoc setup, and then, must chain up to their parent.
+<li><b>Aod hoc On-Demand Distance Vector (AODV)</b> routing model, 
+<a href=http://www.ietf.org/rfc/rfc3561.txt>RFC 3561</a> </li>
+<li><b>Ipv4::IsDestinationAddress (Ipv4Address address, uint32_t iif)</b> Method added to support checks of whether a destination address should be accepted 
+as one of the host's own addresses.  RFC 1122 Strong/Weak end system behavior can be changed with a new attribute (WeakEsModel) in class Ipv4.  </li>
+
+<li><b>Net-anim interface</b>: Provides an interface to net-anim, a network animator for point-to-point 
+links in ns-3.  The interface generates a custom trace file for use with the NetAnim program.</li>
+
+<li><b>Topology Helpers</b>: New topology helpers have been introduced including PointToPointStarHelper, 
+PointToPointDumbbellHelper, PointToPointGridHelper, and CsmaStarHelper.</li>
+
+<li><b>IPv6 extensions support</b>: Provides API to add IPv6 extensions and options. Two examples (fragmentation
+and loose routing) are available.</li>
+</ul>
+
+<h2>Changes to existing API:</h2>
+<ul>
+<li><b>Ipv4RoutingProtocol::RouteOutput</b> no longer takes an outgoing 
+interface index but instead takes an outgoing device pointer; this affects all
+subclasses of Ipv4RoutingProtocol.
+<pre>
+-  virtual Ptr&lt;Ipv4Route&gt; RouteOutput (Ptr&lt;Packet&gt; p, const Ipv4Header &header, uint32_t oif, Socket::SocketErrno &sockerr) = 0;
++  virtual Ptr&lt;Ipv4Route&gt; RouteOutput (Ptr&lt;Packet&gt; p, const Ipv4Header &header, Ptr&lt;NetDevice&gt; oif, Socket::SocketErrno &sockerr) = 0;
+</pre>
+<li><b>Ipv6RoutingProtocol::RouteOutput</b> no longer takes an outgoing 
+interface index but instead takes an outgoing device pointer; this affects all
+subclasses of Ipv6RoutingProtocol.
+<pre>
+-  virtual Ptr&lt;Ipv6Route&gt; RouteOutput (Ptr&lt;Packet&gt; p, const Ipv6Header &header, uint32_t oif, Socket::SocketErrno &sockerr) = 0;
++  virtual Ptr&lt;Ipv6Route&gt; RouteOutput (Ptr&lt;Packet&gt; p, const Ipv6Header &header, Ptr&lt;NetDevice&gt; oif, Socket::SocketErrno &sockerr) = 0;
+</pre>
+<li><b>Application::Start</b> and <b>Application::Stop</b> have been renamed to
+<b>Application::SetStartTime</b> and <b>Application::SetStopTime</b>.
+<li><b>Channel::Send</b>: this method does not really exist but each subclass of the Channel
+base class must implement a similar method which sends a packet from a node to another node.
+Users must now use Simulator::ScheduleWithContext instead of Simulator::Schedule to schedule
+the reception event on a remote node.<br>
+For example, before:
+<pre>
+void
+SimpleChannel::Send (Ptr&lt;Packet&gt; p, uint16_t protocol, 
+		     Mac48Address to, Mac48Address from,
+		     Ptr&lt;SimpleNetDevice&gt; sender)
+{
+  for (std::vector&lt;Ptr&lt;SimpleNetDevice&gt; &gt;::const_iterator i = m_devices.begin (); i != m_devices.end (); ++i)
+    {
+      Ptr&lt;SimpleNetDevice&gt; tmp = *i;
+      if (tmp == sender)
+	{
+	  continue;
+	}
+      Simulator::ScheduleNow (&SimpleNetDevice::Receive, tmp, p->Copy (), protocol, to, from);
+    }
+}
+</pre>
+After:
+<pre>
+void
+SimpleChannel::Send (Ptr&lt;Packet&gt; p, uint16_t protocol, 
+		     Mac48Address to, Mac48Address from,
+		     Ptr&lt;SimpleNetDevice&gt; sender)
+{
+  for (std::vector&lt;Ptr&lt;SimpleNetDevice&gt; &gt;::const_iterator i = m_devices.begin (); i != m_devices.end (); ++i)
+    {
+      Ptr&lt;SimpleNetDevice&gt; tmp = *i;
+      if (tmp == sender)
+	{
+	  continue;
+	}
+      Simulator::ScheduleWithContext (tmp->GetNode ()->GetId (), Seconds (0),
+                                      &SimpleNetDevice::Receive, tmp, p->Copy (), protocol, to, from);
+    }
+}
+</pre>
+
+<li><b>Simulator::SetScheduler</b>: this method now takes an ObjectFactory
+instead of an object pointer directly. Existing callers can trivially be
+updated to use this new method.<br>
+Before:
+<pre>
+Ptr&lt;Scheduler&gt; sched = CreateObject&lt;ListScheduler&gt; ();
+Simulator::SetScheduler (sched);
+</pre>
+After:
+<pre>
+ObjectFactory sched;
+sched.SetTypeId ("ns3::ListScheduler");
+Simulator::SetScheduler (sched);
+</pre>
+
+<li> Extensions to IPv4 <b>Ping</b> application: verbose output and the ability to configure different ping 
+sizes and time intervals (via new attributes)
+
+<li><b>Topology Helpers</b>: Previously, topology helpers such as a point-to-point star existed in the 
+PointToPointHelper class in the form of a method (ex: PointToPointHelper::InstallStar).  These topology 
+helpers have been pulled out of the specific helper classes and created as separate classes.  Several 
+different topology helper classes now exist including PointToPointStarHelper, PointToPointGridHelper, 
+PointToPointDumbbellHelper, and CsmaStarHelper.  For example, a user wishes to create a 
+point-to-point star network:<br>
+Before:
+<pre>
+NodeContainer hubNode;
+NodeContainer spokeNodes;
+hubNode.Create (1);
+Ptr&lt;Node&gt; hub = hubNode.Get (0);
+spokeNodes.Create (nNodes - 1);
+
+PointToPointHelper pointToPoint;
+pointToPoint.SetDeviceAttribute ("DataRate", StringValue ("5Mbps"));
+pointToPoint.SetChannelAttribute ("Delay", StringValue ("2ms"));
+NetDeviceContainer hubDevices, spokeDevices;
+pointToPoint.InstallStar (hubNode.Get (0), spokeNodes, hubDevices, spokeDevices);
+</pre>
+After:
+<pre>
+PointToPointHelper pointToPoint;
+pointToPoint.SetDeviceAttribute ("DataRate", StringValue ("5Mbps"));
+pointToPoint.SetChannelAttribute ("Delay", StringValue ("2ms"));
+PointToPointStarHelper star (nSpokes, pointToPoint);
+</pre>
+
+</li>
+
+</ul>
+
+<h2>Changed behavior:</h2>
+<ul>
+<li> Changed default value of YansWifiPhy::EnergyDetectionThreshold from
+-140.0 dBm to -96.0 dBm.  Changed default value of 
+YansWifiPhy::CcaModelThreshold from -140.0 dBm to -99.0 dBm.  Rationale
+can be found <a href="http://www.nsnam.org/bugzilla/show_bug.cgi?id=689"> 
+here</a>.
+</li>
+<li> Default TTL of IPv4 broadcast datagrams changed from 1 to 64.</li>
+<li> Changed DcfManager::UpdateBackoff (): using flooring instead of rounding in calculation of remaining slots. <a href="http://www.nsnam.org/bugzilla/show_bug.cgi?id=695">
+  See bug 695.</a></li>
+</ul>
+
+
 <hr>
 <h1>Changes from ns-3.5 to ns-3.6</h1>
 
@@ -267,8 +427,8 @@ GlobalValue::Bind ("ChecksumEnabled", BooleanValue (true));
 <pre>
 -  static void EnablePcap (std::string filename, uint32_t nodeid, uint32_t deviceid);
 +         void EnablePcap (std::string filename, uint32_t nodeid, uint32_t deviceid);
--  static void EnablePcap (std::string filename, Ptr<NetDevice> nd);
-+         void EnablePcap (std::string filename, Ptr<NetDevice> nd);
+-  static void EnablePcap (std::string filename, Ptr&lt;NetDevice&gt; nd);
++         void EnablePcap (std::string filename, Ptr&lt;NetDevice&gt; nd);
 -  static void EnablePcap (std::string filename, std::string ndName);
 +         void EnablePcap (std::string filename, std::string ndName);
 -  static void EnablePcap (std::string filename, NetDeviceContainer d);

RELEASE_NOTES

@@ -1,11 +1,65 @@
 
 		ns-3 RELEASE NOTES
 
-This file contains ns-3 release notes (most recent releases first).
+This file contains ns-3 release notes (most recent releases first).  
 
 All of the ns-3 documentation is accessible from the ns-3 website: 
 http://www.nsnam.org including tutorials: http://www.nsnam.org/tutorials.html
 
+Consult the file CHANGES.html for more detailed information about changed
+API and behavior across ns-3 releases.
+
+Release 3.7
+===========
+
+Availability
+------------
+This release is not yet available
+
+Supported platforms
+-------------------
+ns-3.7 has been tested on the following platforms:
+  - linux x86 gcc 4.4.1, 4.2, 4.1, and, 3.4.6.
+  - linux x86_64 gcc 4.4.0, 4.3.2, 4.2.3, 4.2.1, 4.1.3, 3.4.6
+  - MacOS X ppc and x86 (gcc 4.0.x and 4.2.x)
+  - cygwin gcc 3.4.4 (debug only), gcc 4.3.2 (debug and optimized)
+
+Not all ns-3 options are available on all platforms; consult the
+wiki for more information:
+http://www.nsnam.org/wiki/index.php/Installation
+
+New user-visible features
+-------------------------
+
+  a) The ns-3 logging macros (NS_LOG_*) now report automatically the node id
+     of the event which called the macro.
+
+  b) Ad hoc On-Demand Distance Vector (AODV) routing model according to RFC 3561. 
+
+  c) Net-anim:
+     - interface for animation of point-to-point links.
+     - dumbbell, grid, and star examples in examples/animation
+
+  d) Topology Helper classes:
+     - PointToPointDumbbellHelper
+     - PointToPointGridHelper
+     - PointToPointStarHelper
+     - CsmaStarHelper
+
+  e) IPv6 extensions support and two new examples for fragmentation and loose routing.
+
+API changes from ns-3.6
+-----------------------
+API changes for this release are documented in the file CHANGES.html. 
+
+Known issues
+------------
+ns-3.6 build is known to fail on the following platforms:
+  - gcc 3.3 and earlier
+  - optimized builds on gcc 3.4.4 and 3.4.5
+  - optimized builds on linux x86 gcc 4.0.x
+
+
 Release 3.6
 ===========
 
@@ -17,11 +71,10 @@ http://www.nsnam.org/releases/ns-allinone-3.6.tar.bz2
 Supported platforms
 -------------------
 ns-3.6 has been tested on the following platforms:
-  - linux x86 gcc 4.2, 4.1, and, 3.4.6.
+  - linux x86 gcc 4.4.1, 4.2, 4.1, and, 3.4.6.
   - linux x86_64 gcc 4.4.0, 4.3.2, 4.2.3, 4.2.1, 4.1.3, 3.4.6
   - MacOS X ppc and x86 (gcc 4.0.x and 4.2.x)
   - cygwin gcc 3.4.4 (debug only), gcc 4.3.2 (debug and optimized)
-  - mingw gcc 3.4.5 (debug only)
 
 Not all ns-3 options are available on all platforms; consult the
 wiki for more information:
@@ -68,22 +121,21 @@ New user-visible features
     - Previous unit tests have been ported to new framework.
     - Examples are tested for run-ability.
 
+  f) A new Flow Monitor module
+   - To very easily measure flow metrics in a simulation
+   - No need to use trace callbacks or parsing trace files
+
 API changes from ns-3.5
 -----------------------
 API changes for this release are documented in the file CHANGES.html. 
-XXX
 
 Known issues
 ------------
-ns-3 build is known to fail on the following platforms:
+ns-3.6 build is known to fail on the following platforms:
   - gcc 3.3 and earlier
   - optimized builds on gcc 3.4.4 and 3.4.5
   - optimized builds on linux x86 gcc 4.0.x
 
-Future releases
----------------
-XXX
-
 Release 3.5
 ===========
 

bindings/python/apidefs/gcc-ILP32/callbacks_list.py

@@ -4,18 +4,21 @@ callback_classes = [
     ['void', 'ns3::Ptr<ns3::Packet>', 'ns3::Mac48Address', 'ns3::Mac48Address', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['void', 'ns3::Mac48Address', 'ns3::Mac48Address', 'unsigned int', 'bool', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['void', 'unsigned int', 'ns3::Mac48Address', 'ns3::Mac48Address', 'ns3::dot11s::PeerLink::PeerState', 'ns3::dot11s::PeerLink::PeerState', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
-    ['void', 'ns3::WifiMacHeader const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['unsigned int', 'ns3::Mac48Address', 'ns3::Ptr<ns3::MeshWifiInterfaceMac>', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['void', 'ns3::Ptr<ns3::Packet>', 'ns3::WifiMacHeader const*', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
+    ['std::vector<ns3::Mac48Address, std::allocator<ns3::Mac48Address> >', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
+    ['void', 'bool', 'ns3::Ptr<ns3::Packet>', 'ns3::Mac48Address', 'ns3::Mac48Address', 'unsigned short', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
+    ['void', 'ns3::WifiMacHeader const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
+    ['bool', 'std::string', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
+    ['bool', 'ns3::Ptr<ns3::NetDevice>', 'ns3::Ptr<ns3::Packet const>', 'unsigned short', 'ns3::Address const&', 'ns3::Address const&', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
+    ['bool', 'ns3::Ptr<ns3::NetDevice>', 'ns3::Ptr<ns3::Packet const>', 'unsigned short', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
+    ['void', 'ns3::Ptr<ns3::Packet const>', 'ns3::Ipv4Header const&', 'ns3::Socket::SocketErrno', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
+    ['void', 'ns3::Ptr<ns3::Ipv4Route>', 'ns3::Ptr<ns3::Packet const>', 'ns3::Ipv4Header const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['void', 'ns3::Ptr<ns3::Socket>', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['void', 'ns3::Ptr<ns3::Socket>', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['void', 'ns3::Ptr<ns3::Socket>', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['bool', 'ns3::Ptr<ns3::Socket>', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
-    ['std::vector<ns3::Mac48Address, std::allocator<ns3::Mac48Address> >', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
-    ['void', 'bool', 'ns3::Ptr<ns3::Packet>', 'ns3::Mac48Address', 'ns3::Mac48Address', 'unsigned short', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
-    ['bool', 'std::string', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
-    ['bool', 'ns3::Ptr<ns3::NetDevice>', 'ns3::Ptr<ns3::Packet const>', 'unsigned short', 'ns3::Address const&', 'ns3::Address const&', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
-    ['bool', 'ns3::Ptr<ns3::NetDevice>', 'ns3::Ptr<ns3::Packet const>', 'unsigned short', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
+    ['void', 'ns3::Ipv4Address', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['void', 'ns3::Ptr<ns3::ArpCache const>', 'ns3::Ipv4Address', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['void', 'ns3::Ptr<ns3::NetDevice>', 'ns3::Ptr<ns3::Packet const>', 'unsigned short', 'ns3::Address const&', 'ns3::Address const&', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
 ]

bindings/python/apidefs/gcc-ILP32/ns3_module_bridge.py

@@ -26,6 +26,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -62,6 +68,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -290,6 +300,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -305,6 +316,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-ILP32/ns3_module_common.py

@@ -21,8 +21,6 @@ def register_types(module):
     module.add_class('Item', outer_class=root_module['ns3::ByteTagList::Iterator'])
     ## data-rate.h: ns3::DataRate [class]
     module.add_class('DataRate')
-    ## packet.h: ns3::Packet [class]
-    module.add_class('Packet', memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
     ## packet-metadata.h: ns3::PacketMetadata [class]
     module.add_class('PacketMetadata')
     ## packet-metadata.h: ns3::PacketMetadata::Item [struct]
@@ -45,28 +43,34 @@ def register_types(module):
     module.add_class('Tag', parent=root_module['ns3::ObjectBase'])
     ## tag-buffer.h: ns3::TagBuffer [class]
     module.add_class('TagBuffer')
-    ## ascii-writer.h: ns3::AsciiWriter [class]
-    module.add_class('AsciiWriter', parent=root_module['ns3::RefCountBase'])
-    ## ascii-writer.h: ns3::AsciiWriter::Type [enumeration]
-    module.add_enum('Type', ['ENQUEUE', 'DEQUEUE', 'DROP', 'TX', 'RX'], outer_class=root_module['ns3::AsciiWriter'])
     ## chunk.h: ns3::Chunk [class]
     module.add_class('Chunk', parent=root_module['ns3::ObjectBase'])
-    ## data-rate.h: ns3::DataRateChecker [class]
-    module.add_class('DataRateChecker', parent=root_module['ns3::AttributeChecker'])
-    ## data-rate.h: ns3::DataRateValue [class]
-    module.add_class('DataRateValue', parent=root_module['ns3::AttributeValue'])
     ## header.h: ns3::Header [class]
     module.add_class('Header', parent=root_module['ns3::Chunk'])
     ## pcap-writer.h: ns3::PcapWriter [class]
     module.add_class('PcapWriter', parent=root_module['ns3::Object'])
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::AsciiWriter, ns3::empty, ns3::DefaultDeleter<ns3::AsciiWriter> > [class]
+    module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::AsciiWriter', 'ns3::empty', 'ns3::DefaultDeleter<ns3::AsciiWriter>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> > [class]
+    module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::Packet', 'ns3::empty', 'ns3::DefaultDeleter<ns3::Packet>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
     ## trailer.h: ns3::Trailer [class]
     module.add_class('Trailer', parent=root_module['ns3::Chunk'])
+    ## ascii-writer.h: ns3::AsciiWriter [class]
+    module.add_class('AsciiWriter', parent=root_module['ns3::SimpleRefCount< ns3::AsciiWriter, ns3::empty, ns3::DefaultDeleter<ns3::AsciiWriter> >'])
+    ## ascii-writer.h: ns3::AsciiWriter::Type [enumeration]
+    module.add_enum('Type', ['ENQUEUE', 'DEQUEUE', 'DROP', 'TX', 'RX'], outer_class=root_module['ns3::AsciiWriter'])
+    ## data-rate.h: ns3::DataRateChecker [class]
+    module.add_class('DataRateChecker', parent=root_module['ns3::AttributeChecker'])
+    ## data-rate.h: ns3::DataRateValue [class]
+    module.add_class('DataRateValue', parent=root_module['ns3::AttributeValue'])
     ## error-model.h: ns3::ErrorModel [class]
     module.add_class('ErrorModel', parent=root_module['ns3::Object'])
     ## error-model.h: ns3::ListErrorModel [class]
     module.add_class('ListErrorModel', parent=root_module['ns3::ErrorModel'])
     ## nix-vector.h: ns3::NixVector [class]
     module.add_class('NixVector', parent=root_module['ns3::Object'])
+    ## packet.h: ns3::Packet [class]
+    module.add_class('Packet', parent=root_module['ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> >'])
     ## error-model.h: ns3::RateErrorModel [class]
     module.add_class('RateErrorModel', parent=root_module['ns3::ErrorModel'])
     
@@ -88,6 +92,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -124,6 +134,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -149,7 +163,6 @@ def register_methods(root_module):
     register_Ns3ByteTagListIterator_methods(root_module, root_module['ns3::ByteTagList::Iterator'])
     register_Ns3ByteTagListIteratorItem_methods(root_module, root_module['ns3::ByteTagList::Iterator::Item'])
     register_Ns3DataRate_methods(root_module, root_module['ns3::DataRate'])
-    register_Ns3Packet_methods(root_module, root_module['ns3::Packet'])
     register_Ns3PacketMetadata_methods(root_module, root_module['ns3::PacketMetadata'])
     register_Ns3PacketMetadataItem_methods(root_module, root_module['ns3::PacketMetadata::Item'])
     register_Ns3PacketMetadataItemIterator_methods(root_module, root_module['ns3::PacketMetadata::ItemIterator'])
@@ -160,16 +173,17 @@ def register_methods(root_module):
     register_Ns3PcapFile_methods(root_module, root_module['ns3::PcapFile'])
     register_Ns3Tag_methods(root_module, root_module['ns3::Tag'])
     register_Ns3TagBuffer_methods(root_module, root_module['ns3::TagBuffer'])
-    register_Ns3AsciiWriter_methods(root_module, root_module['ns3::AsciiWriter'])
     register_Ns3Chunk_methods(root_module, root_module['ns3::Chunk'])
-    register_Ns3DataRateChecker_methods(root_module, root_module['ns3::DataRateChecker'])
-    register_Ns3DataRateValue_methods(root_module, root_module['ns3::DataRateValue'])
     register_Ns3Header_methods(root_module, root_module['ns3::Header'])
     register_Ns3PcapWriter_methods(root_module, root_module['ns3::PcapWriter'])
     register_Ns3Trailer_methods(root_module, root_module['ns3::Trailer'])
+    register_Ns3AsciiWriter_methods(root_module, root_module['ns3::AsciiWriter'])
+    register_Ns3DataRateChecker_methods(root_module, root_module['ns3::DataRateChecker'])
+    register_Ns3DataRateValue_methods(root_module, root_module['ns3::DataRateValue'])
     register_Ns3ErrorModel_methods(root_module, root_module['ns3::ErrorModel'])
     register_Ns3ListErrorModel_methods(root_module, root_module['ns3::ListErrorModel'])
     register_Ns3NixVector_methods(root_module, root_module['ns3::NixVector'])
+    register_Ns3Packet_methods(root_module, root_module['ns3::Packet'])
     register_Ns3RateErrorModel_methods(root_module, root_module['ns3::RateErrorModel'])
     return
 
@@ -529,184 +543,6 @@ def register_Ns3DataRate_methods(root_module, cls):
                    is_const=True)
     return
 
-def register_Ns3Packet_methods(root_module, cls):
-    cls.add_output_stream_operator()
-    ## packet.h: ns3::Packet::Packet() [constructor]
-    cls.add_constructor([])
-    ## packet.h: ns3::Packet::Packet(ns3::Packet const & o) [copy constructor]
-    cls.add_constructor([param('ns3::Packet const &', 'o')])
-    ## packet.h: ns3::Packet::Packet(uint32_t size) [constructor]
-    cls.add_constructor([param('uint32_t', 'size')])
-    ## packet.h: ns3::Packet::Packet(uint8_t const * buffer, uint32_t size) [constructor]
-    cls.add_constructor([param('uint8_t const *', 'buffer'), param('uint32_t', 'size')])
-    ## packet.h: void ns3::Packet::AddAtEnd(ns3::Ptr<ns3::Packet const> packet) [member function]
-    cls.add_method('AddAtEnd', 
-                   'void', 
-                   [param('ns3::Ptr< ns3::Packet const >', 'packet')])
-    ## packet.h: void ns3::Packet::AddByteTag(ns3::Tag const & tag) const [member function]
-    cls.add_method('AddByteTag', 
-                   'void', 
-                   [param('ns3::Tag const &', 'tag')], 
-                   is_const=True)
-    ## packet.h: void ns3::Packet::AddHeader(ns3::Header const & header) [member function]
-    cls.add_method('AddHeader', 
-                   'void', 
-                   [param('ns3::Header const &', 'header')])
-    ## packet.h: void ns3::Packet::AddPacketTag(ns3::Tag const & tag) const [member function]
-    cls.add_method('AddPacketTag', 
-                   'void', 
-                   [param('ns3::Tag const &', 'tag')], 
-                   is_const=True)
-    ## packet.h: void ns3::Packet::AddPaddingAtEnd(uint32_t size) [member function]
-    cls.add_method('AddPaddingAtEnd', 
-                   'void', 
-                   [param('uint32_t', 'size')])
-    ## packet.h: void ns3::Packet::AddTrailer(ns3::Trailer const & trailer) [member function]
-    cls.add_method('AddTrailer', 
-                   'void', 
-                   [param('ns3::Trailer const &', 'trailer')])
-    ## packet.h: ns3::PacketMetadata::ItemIterator ns3::Packet::BeginItem() const [member function]
-    cls.add_method('BeginItem', 
-                   'ns3::PacketMetadata::ItemIterator', 
-                   [], 
-                   is_const=True)
-    ## packet.h: ns3::Ptr<ns3::Packet> ns3::Packet::Copy() const [member function]
-    cls.add_method('Copy', 
-                   'ns3::Ptr< ns3::Packet >', 
-                   [], 
-                   is_const=True)
-    ## packet.h: uint32_t ns3::Packet::CopyData(uint8_t * buffer, uint32_t size) const [member function]
-    cls.add_method('CopyData', 
-                   'uint32_t', 
-                   [param('uint8_t *', 'buffer'), param('uint32_t', 'size')], 
-                   is_const=True)
-    ## packet.h: void ns3::Packet::CopyData(std::ostream * os, uint32_t size) const [member function]
-    cls.add_method('CopyData', 
-                   'void', 
-                   [param('std::ostream *', 'os'), param('uint32_t', 'size')], 
-                   is_const=True)
-    ## packet.h: ns3::Ptr<ns3::Packet> ns3::Packet::CreateFragment(uint32_t start, uint32_t length) const [member function]
-    cls.add_method('CreateFragment', 
-                   'ns3::Ptr< ns3::Packet >', 
-                   [param('uint32_t', 'start'), param('uint32_t', 'length')], 
-                   is_const=True)
-    ## packet.h: void ns3::Packet::Deserialize(ns3::Buffer buffer) [member function]
-    cls.add_method('Deserialize', 
-                   'void', 
-                   [param('ns3::Buffer', 'buffer')])
-    ## packet.h: static void ns3::Packet::EnableChecking() [member function]
-    cls.add_method('EnableChecking', 
-                   'void', 
-                   [], 
-                   is_static=True)
-    ## packet.h: static void ns3::Packet::EnablePrinting() [member function]
-    cls.add_method('EnablePrinting', 
-                   'void', 
-                   [], 
-                   is_static=True)
-    ## packet.h: bool ns3::Packet::FindFirstMatchingByteTag(ns3::Tag & tag) const [member function]
-    cls.add_method('FindFirstMatchingByteTag', 
-                   'bool', 
-                   [param('ns3::Tag &', 'tag')], 
-                   is_const=True)
-    ## packet.h: ns3::ByteTagIterator ns3::Packet::GetByteTagIterator() const [member function]
-    cls.add_method('GetByteTagIterator', 
-                   'ns3::ByteTagIterator', 
-                   [], 
-                   is_const=True)
-    ## packet.h: ns3::Ptr<ns3::NixVector> ns3::Packet::GetNixVector() const [member function]
-    cls.add_method('GetNixVector', 
-                   'ns3::Ptr< ns3::NixVector >', 
-                   [], 
-                   is_const=True)
-    ## packet.h: ns3::PacketTagIterator ns3::Packet::GetPacketTagIterator() const [member function]
-    cls.add_method('GetPacketTagIterator', 
-                   'ns3::PacketTagIterator', 
-                   [], 
-                   is_const=True)
-    ## packet.h: uint32_t ns3::Packet::GetSize() const [member function]
-    cls.add_method('GetSize', 
-                   'uint32_t', 
-                   [], 
-                   is_const=True)
-    ## packet.h: uint32_t ns3::Packet::GetUid() const [member function]
-    cls.add_method('GetUid', 
-                   'uint32_t', 
-                   [], 
-                   is_const=True)
-    ## packet.h: uint8_t const * ns3::Packet::PeekData() const [member function]
-    cls.add_method('PeekData', 
-                   'uint8_t const *', 
-                   [], 
-                   is_const=True)
-    ## packet.h: uint32_t ns3::Packet::PeekHeader(ns3::Header & header) const [member function]
-    cls.add_method('PeekHeader', 
-                   'uint32_t', 
-                   [param('ns3::Header &', 'header')], 
-                   is_const=True)
-    ## packet.h: bool ns3::Packet::PeekPacketTag(ns3::Tag & tag) const [member function]
-    cls.add_method('PeekPacketTag', 
-                   'bool', 
-                   [param('ns3::Tag &', 'tag')], 
-                   is_const=True)
-    ## packet.h: uint32_t ns3::Packet::PeekTrailer(ns3::Trailer & trailer) [member function]
-    cls.add_method('PeekTrailer', 
-                   'uint32_t', 
-                   [param('ns3::Trailer &', 'trailer')])
-    ## packet.h: void ns3::Packet::Print(std::ostream & os) const [member function]
-    cls.add_method('Print', 
-                   'void', 
-                   [param('std::ostream &', 'os')], 
-                   is_const=True)
-    ## packet.h: void ns3::Packet::PrintByteTags(std::ostream & os) const [member function]
-    cls.add_method('PrintByteTags', 
-                   'void', 
-                   [param('std::ostream &', 'os')], 
-                   is_const=True)
-    ## packet.h: void ns3::Packet::PrintPacketTags(std::ostream & os) const [member function]
-    cls.add_method('PrintPacketTags', 
-                   'void', 
-                   [param('std::ostream &', 'os')], 
-                   is_const=True)
-    ## packet.h: void ns3::Packet::RemoveAllByteTags() [member function]
-    cls.add_method('RemoveAllByteTags', 
-                   'void', 
-                   [])
-    ## packet.h: void ns3::Packet::RemoveAllPacketTags() [member function]
-    cls.add_method('RemoveAllPacketTags', 
-                   'void', 
-                   [])
-    ## packet.h: void ns3::Packet::RemoveAtEnd(uint32_t size) [member function]
-    cls.add_method('RemoveAtEnd', 
-                   'void', 
-                   [param('uint32_t', 'size')])
-    ## packet.h: void ns3::Packet::RemoveAtStart(uint32_t size) [member function]
-    cls.add_method('RemoveAtStart', 
-                   'void', 
-                   [param('uint32_t', 'size')])
-    ## packet.h: uint32_t ns3::Packet::RemoveHeader(ns3::Header & header) [member function]
-    cls.add_method('RemoveHeader', 
-                   'uint32_t', 
-                   [param('ns3::Header &', 'header')])
-    ## packet.h: bool ns3::Packet::RemovePacketTag(ns3::Tag & tag) [member function]
-    cls.add_method('RemovePacketTag', 
-                   'bool', 
-                   [param('ns3::Tag &', 'tag')])
-    ## packet.h: uint32_t ns3::Packet::RemoveTrailer(ns3::Trailer & trailer) [member function]
-    cls.add_method('RemoveTrailer', 
-                   'uint32_t', 
-                   [param('ns3::Trailer &', 'trailer')])
-    ## packet.h: ns3::Buffer ns3::Packet::Serialize() const [member function]
-    cls.add_method('Serialize', 
-                   'ns3::Buffer', 
-                   [], 
-                   is_const=True)
-    ## packet.h: void ns3::Packet::SetNixVector(ns3::Ptr<ns3::NixVector> arg0) [member function]
-    cls.add_method('SetNixVector', 
-                   'void', 
-                   [param('ns3::Ptr< ns3::NixVector >', 'arg0')])
-    return
-
 def register_Ns3PacketMetadata_methods(root_module, cls):
     ## packet-metadata.h: ns3::PacketMetadata::PacketMetadata(uint32_t uid, uint32_t size) [constructor]
     cls.add_constructor([param('uint32_t', 'uid'), param('uint32_t', 'size')])
@@ -903,6 +739,11 @@ def register_Ns3PcapFile_methods(root_module, cls):
     cls.add_method('Close', 
                    'void', 
                    [])
+    ## pcap-file.h: static bool ns3::PcapFile::Diff(std::string const & f1, std::string const & f2, uint32_t & sec, uint32_t & usec, uint32_t snapLen=ns3::PcapFile::SNAPLEN_DEFAULT) [member function]
+    cls.add_method('Diff', 
+                   'bool', 
+                   [param('std::string const &', 'f1'), param('std::string const &', 'f2'), param('uint32_t &', 'sec'), param('uint32_t &', 'usec'), param('uint32_t', 'snapLen', default_value='ns3::PcapFile::SNAPLEN_DEFAULT')], 
+                   is_static=True)
     ## pcap-file.h: uint32_t ns3::PcapFile::GetDataLinkType() [member function]
     cls.add_method('GetDataLinkType', 
                    'uint32_t', 
@@ -1052,20 +893,6 @@ def register_Ns3TagBuffer_methods(root_module, cls):
                    [param('uint8_t', 'v')])
     return
 
-def register_Ns3AsciiWriter_methods(root_module, cls):
-    ## ascii-writer.h: ns3::AsciiWriter::AsciiWriter(ns3::AsciiWriter const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::AsciiWriter const &', 'arg0')])
-    ## ascii-writer.h: static ns3::Ptr<ns3::AsciiWriter> ns3::AsciiWriter::Get(std::ostream & os) [member function]
-    cls.add_method('Get', 
-                   'ns3::Ptr< ns3::AsciiWriter >', 
-                   [param('std::ostream &', 'os')], 
-                   is_static=True)
-    ## ascii-writer.h: void ns3::AsciiWriter::WritePacket(ns3::AsciiWriter::Type type, std::string message, ns3::Ptr<ns3::Packet const> p) [member function]
-    cls.add_method('WritePacket', 
-                   'void', 
-                   [param('ns3::AsciiWriter::Type', 'type'), param('std::string', 'message'), param('ns3::Ptr< ns3::Packet const >', 'p')])
-    return
-
 def register_Ns3Chunk_methods(root_module, cls):
     ## chunk.h: ns3::Chunk::Chunk() [constructor]
     cls.add_constructor([])
@@ -1088,46 +915,6 @@ def register_Ns3Chunk_methods(root_module, cls):
                    is_pure_virtual=True, is_const=True, is_virtual=True)
     return
 
-def register_Ns3DataRateChecker_methods(root_module, cls):
-    ## data-rate.h: ns3::DataRateChecker::DataRateChecker() [constructor]
-    cls.add_constructor([])
-    ## data-rate.h: ns3::DataRateChecker::DataRateChecker(ns3::DataRateChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::DataRateChecker const &', 'arg0')])
-    return
-
-def register_Ns3DataRateValue_methods(root_module, cls):
-    ## data-rate.h: ns3::DataRateValue::DataRateValue() [constructor]
-    cls.add_constructor([])
-    ## data-rate.h: ns3::DataRateValue::DataRateValue(ns3::DataRateValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::DataRateValue const &', 'arg0')])
-    ## data-rate.h: ns3::DataRateValue::DataRateValue(ns3::DataRate const & value) [constructor]
-    cls.add_constructor([param('ns3::DataRate const &', 'value')])
-    ## data-rate.h: ns3::Ptr<ns3::AttributeValue> ns3::DataRateValue::Copy() const [member function]
-    cls.add_method('Copy', 
-                   'ns3::Ptr< ns3::AttributeValue >', 
-                   [], 
-                   is_const=True, is_virtual=True)
-    ## data-rate.h: bool ns3::DataRateValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
-    cls.add_method('DeserializeFromString', 
-                   'bool', 
-                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
-                   is_virtual=True)
-    ## data-rate.h: ns3::DataRate ns3::DataRateValue::Get() const [member function]
-    cls.add_method('Get', 
-                   'ns3::DataRate', 
-                   [], 
-                   is_const=True)
-    ## data-rate.h: std::string ns3::DataRateValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
-    cls.add_method('SerializeToString', 
-                   'std::string', 
-                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
-                   is_const=True, is_virtual=True)
-    ## data-rate.h: void ns3::DataRateValue::Set(ns3::DataRate const & value) [member function]
-    cls.add_method('Set', 
-                   'void', 
-                   [param('ns3::DataRate const &', 'value')])
-    return
-
 def register_Ns3Header_methods(root_module, cls):
     cls.add_output_stream_operator()
     ## header.h: ns3::Header::Header() [constructor]
@@ -1246,6 +1033,60 @@ def register_Ns3Trailer_methods(root_module, cls):
                    is_pure_virtual=True, is_const=True, is_virtual=True)
     return
 
+def register_Ns3AsciiWriter_methods(root_module, cls):
+    ## ascii-writer.h: ns3::AsciiWriter::AsciiWriter(ns3::AsciiWriter const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::AsciiWriter const &', 'arg0')])
+    ## ascii-writer.h: static ns3::Ptr<ns3::AsciiWriter> ns3::AsciiWriter::Get(std::ostream & os) [member function]
+    cls.add_method('Get', 
+                   'ns3::Ptr< ns3::AsciiWriter >', 
+                   [param('std::ostream &', 'os')], 
+                   is_static=True)
+    ## ascii-writer.h: void ns3::AsciiWriter::WritePacket(ns3::AsciiWriter::Type type, std::string message, ns3::Ptr<ns3::Packet const> p) [member function]
+    cls.add_method('WritePacket', 
+                   'void', 
+                   [param('ns3::AsciiWriter::Type', 'type'), param('std::string', 'message'), param('ns3::Ptr< ns3::Packet const >', 'p')])
+    return
+
+def register_Ns3DataRateChecker_methods(root_module, cls):
+    ## data-rate.h: ns3::DataRateChecker::DataRateChecker() [constructor]
+    cls.add_constructor([])
+    ## data-rate.h: ns3::DataRateChecker::DataRateChecker(ns3::DataRateChecker const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::DataRateChecker const &', 'arg0')])
+    return
+
+def register_Ns3DataRateValue_methods(root_module, cls):
+    ## data-rate.h: ns3::DataRateValue::DataRateValue() [constructor]
+    cls.add_constructor([])
+    ## data-rate.h: ns3::DataRateValue::DataRateValue(ns3::DataRateValue const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::DataRateValue const &', 'arg0')])
+    ## data-rate.h: ns3::DataRateValue::DataRateValue(ns3::DataRate const & value) [constructor]
+    cls.add_constructor([param('ns3::DataRate const &', 'value')])
+    ## data-rate.h: ns3::Ptr<ns3::AttributeValue> ns3::DataRateValue::Copy() const [member function]
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## data-rate.h: bool ns3::DataRateValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_virtual=True)
+    ## data-rate.h: ns3::DataRate ns3::DataRateValue::Get() const [member function]
+    cls.add_method('Get', 
+                   'ns3::DataRate', 
+                   [], 
+                   is_const=True)
+    ## data-rate.h: std::string ns3::DataRateValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, is_virtual=True)
+    ## data-rate.h: void ns3::DataRateValue::Set(ns3::DataRate const & value) [member function]
+    cls.add_method('Set', 
+                   'void', 
+                   [param('ns3::DataRate const &', 'value')])
+    return
+
 def register_Ns3ErrorModel_methods(root_module, cls):
     ## error-model.h: ns3::ErrorModel::ErrorModel(ns3::ErrorModel const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::ErrorModel const &', 'arg0')])
@@ -1374,6 +1215,184 @@ def register_Ns3NixVector_methods(root_module, cls):
                    is_const=True)
     return
 
+def register_Ns3Packet_methods(root_module, cls):
+    cls.add_output_stream_operator()
+    ## packet.h: ns3::Packet::Packet() [constructor]
+    cls.add_constructor([])
+    ## packet.h: ns3::Packet::Packet(ns3::Packet const & o) [copy constructor]
+    cls.add_constructor([param('ns3::Packet const &', 'o')])
+    ## packet.h: ns3::Packet::Packet(uint32_t size) [constructor]
+    cls.add_constructor([param('uint32_t', 'size')])
+    ## packet.h: ns3::Packet::Packet(uint8_t const * buffer, uint32_t size) [constructor]
+    cls.add_constructor([param('uint8_t const *', 'buffer'), param('uint32_t', 'size')])
+    ## packet.h: void ns3::Packet::AddAtEnd(ns3::Ptr<ns3::Packet const> packet) [member function]
+    cls.add_method('AddAtEnd', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Packet const >', 'packet')])
+    ## packet.h: void ns3::Packet::AddByteTag(ns3::Tag const & tag) const [member function]
+    cls.add_method('AddByteTag', 
+                   'void', 
+                   [param('ns3::Tag const &', 'tag')], 
+                   is_const=True)
+    ## packet.h: void ns3::Packet::AddHeader(ns3::Header const & header) [member function]
+    cls.add_method('AddHeader', 
+                   'void', 
+                   [param('ns3::Header const &', 'header')])
+    ## packet.h: void ns3::Packet::AddPacketTag(ns3::Tag const & tag) const [member function]
+    cls.add_method('AddPacketTag', 
+                   'void', 
+                   [param('ns3::Tag const &', 'tag')], 
+                   is_const=True)
+    ## packet.h: void ns3::Packet::AddPaddingAtEnd(uint32_t size) [member function]
+    cls.add_method('AddPaddingAtEnd', 
+                   'void', 
+                   [param('uint32_t', 'size')])
+    ## packet.h: void ns3::Packet::AddTrailer(ns3::Trailer const & trailer) [member function]
+    cls.add_method('AddTrailer', 
+                   'void', 
+                   [param('ns3::Trailer const &', 'trailer')])
+    ## packet.h: ns3::PacketMetadata::ItemIterator ns3::Packet::BeginItem() const [member function]
+    cls.add_method('BeginItem', 
+                   'ns3::PacketMetadata::ItemIterator', 
+                   [], 
+                   is_const=True)
+    ## packet.h: ns3::Ptr<ns3::Packet> ns3::Packet::Copy() const [member function]
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::Packet >', 
+                   [], 
+                   is_const=True)
+    ## packet.h: uint32_t ns3::Packet::CopyData(uint8_t * buffer, uint32_t size) const [member function]
+    cls.add_method('CopyData', 
+                   'uint32_t', 
+                   [param('uint8_t *', 'buffer'), param('uint32_t', 'size')], 
+                   is_const=True)
+    ## packet.h: void ns3::Packet::CopyData(std::ostream * os, uint32_t size) const [member function]
+    cls.add_method('CopyData', 
+                   'void', 
+                   [param('std::ostream *', 'os'), param('uint32_t', 'size')], 
+                   is_const=True)
+    ## packet.h: ns3::Ptr<ns3::Packet> ns3::Packet::CreateFragment(uint32_t start, uint32_t length) const [member function]
+    cls.add_method('CreateFragment', 
+                   'ns3::Ptr< ns3::Packet >', 
+                   [param('uint32_t', 'start'), param('uint32_t', 'length')], 
+                   is_const=True)
+    ## packet.h: void ns3::Packet::Deserialize(ns3::Buffer buffer) [member function]
+    cls.add_method('Deserialize', 
+                   'void', 
+                   [param('ns3::Buffer', 'buffer')])
+    ## packet.h: static void ns3::Packet::EnableChecking() [member function]
+    cls.add_method('EnableChecking', 
+                   'void', 
+                   [], 
+                   is_static=True)
+    ## packet.h: static void ns3::Packet::EnablePrinting() [member function]
+    cls.add_method('EnablePrinting', 
+                   'void', 
+                   [], 
+                   is_static=True)
+    ## packet.h: bool ns3::Packet::FindFirstMatchingByteTag(ns3::Tag & tag) const [member function]
+    cls.add_method('FindFirstMatchingByteTag', 
+                   'bool', 
+                   [param('ns3::Tag &', 'tag')], 
+                   is_const=True)
+    ## packet.h: ns3::ByteTagIterator ns3::Packet::GetByteTagIterator() const [member function]
+    cls.add_method('GetByteTagIterator', 
+                   'ns3::ByteTagIterator', 
+                   [], 
+                   is_const=True)
+    ## packet.h: ns3::Ptr<ns3::NixVector> ns3::Packet::GetNixVector() const [member function]
+    cls.add_method('GetNixVector', 
+                   'ns3::Ptr< ns3::NixVector >', 
+                   [], 
+                   is_const=True)
+    ## packet.h: ns3::PacketTagIterator ns3::Packet::GetPacketTagIterator() const [member function]
+    cls.add_method('GetPacketTagIterator', 
+                   'ns3::PacketTagIterator', 
+                   [], 
+                   is_const=True)
+    ## packet.h: uint32_t ns3::Packet::GetSize() const [member function]
+    cls.add_method('GetSize', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
+    ## packet.h: uint32_t ns3::Packet::GetUid() const [member function]
+    cls.add_method('GetUid', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
+    ## packet.h: uint8_t const * ns3::Packet::PeekData() const [member function]
+    cls.add_method('PeekData', 
+                   'uint8_t const *', 
+                   [], 
+                   deprecated=True, is_const=True)
+    ## packet.h: uint32_t ns3::Packet::PeekHeader(ns3::Header & header) const [member function]
+    cls.add_method('PeekHeader', 
+                   'uint32_t', 
+                   [param('ns3::Header &', 'header')], 
+                   is_const=True)
+    ## packet.h: bool ns3::Packet::PeekPacketTag(ns3::Tag & tag) const [member function]
+    cls.add_method('PeekPacketTag', 
+                   'bool', 
+                   [param('ns3::Tag &', 'tag')], 
+                   is_const=True)
+    ## packet.h: uint32_t ns3::Packet::PeekTrailer(ns3::Trailer & trailer) [member function]
+    cls.add_method('PeekTrailer', 
+                   'uint32_t', 
+                   [param('ns3::Trailer &', 'trailer')])
+    ## packet.h: void ns3::Packet::Print(std::ostream & os) const [member function]
+    cls.add_method('Print', 
+                   'void', 
+                   [param('std::ostream &', 'os')], 
+                   is_const=True)
+    ## packet.h: void ns3::Packet::PrintByteTags(std::ostream & os) const [member function]
+    cls.add_method('PrintByteTags', 
+                   'void', 
+                   [param('std::ostream &', 'os')], 
+                   is_const=True)
+    ## packet.h: void ns3::Packet::PrintPacketTags(std::ostream & os) const [member function]
+    cls.add_method('PrintPacketTags', 
+                   'void', 
+                   [param('std::ostream &', 'os')], 
+                   is_const=True)
+    ## packet.h: void ns3::Packet::RemoveAllByteTags() [member function]
+    cls.add_method('RemoveAllByteTags', 
+                   'void', 
+                   [])
+    ## packet.h: void ns3::Packet::RemoveAllPacketTags() [member function]
+    cls.add_method('RemoveAllPacketTags', 
+                   'void', 
+                   [])
+    ## packet.h: void ns3::Packet::RemoveAtEnd(uint32_t size) [member function]
+    cls.add_method('RemoveAtEnd', 
+                   'void', 
+                   [param('uint32_t', 'size')])
+    ## packet.h: void ns3::Packet::RemoveAtStart(uint32_t size) [member function]
+    cls.add_method('RemoveAtStart', 
+                   'void', 
+                   [param('uint32_t', 'size')])
+    ## packet.h: uint32_t ns3::Packet::RemoveHeader(ns3::Header & header) [member function]
+    cls.add_method('RemoveHeader', 
+                   'uint32_t', 
+                   [param('ns3::Header &', 'header')])
+    ## packet.h: bool ns3::Packet::RemovePacketTag(ns3::Tag & tag) [member function]
+    cls.add_method('RemovePacketTag', 
+                   'bool', 
+                   [param('ns3::Tag &', 'tag')])
+    ## packet.h: uint32_t ns3::Packet::RemoveTrailer(ns3::Trailer & trailer) [member function]
+    cls.add_method('RemoveTrailer', 
+                   'uint32_t', 
+                   [param('ns3::Trailer &', 'trailer')])
+    ## packet.h: ns3::Buffer ns3::Packet::Serialize() const [member function]
+    cls.add_method('Serialize', 
+                   'ns3::Buffer', 
+                   [], 
+                   is_const=True)
+    ## packet.h: void ns3::Packet::SetNixVector(ns3::Ptr<ns3::NixVector> arg0) [member function]
+    cls.add_method('SetNixVector', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::NixVector >', 'arg0')])
+    return
+
 def register_Ns3RateErrorModel_methods(root_module, cls):
     ## error-model.h: ns3::RateErrorModel::RateErrorModel(ns3::RateErrorModel const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::RateErrorModel const &', 'arg0')])
@@ -1442,6 +1461,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -1457,6 +1477,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-ILP32/ns3_module_contrib.py

@@ -3,6 +3,8 @@ from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandler
 def register_types(module):
     root_module = module.get_root()
     
+    ## average.h: ns3::Average<double> [class]
+    module.add_class('Average', template_parameters=['double'])
     ## delay-jitter-estimation.h: ns3::DelayJitterEstimation [class]
     module.add_class('DelayJitterEstimation')
     ## event-garbage-collector.h: ns3::EventGarbageCollector [class]
@@ -58,6 +60,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -94,6 +102,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -111,6 +123,7 @@ def register_types_ns3_olsr(module):
     
 
 def register_methods(root_module):
+    register_Ns3Average__Double_methods(root_module, root_module['ns3::Average< double >'])
     register_Ns3DelayJitterEstimation_methods(root_module, root_module['ns3::DelayJitterEstimation'])
     register_Ns3EventGarbageCollector_methods(root_module, root_module['ns3::EventGarbageCollector'])
     register_Ns3FileConfig_methods(root_module, root_module['ns3::FileConfig'])
@@ -127,6 +140,71 @@ def register_methods(root_module):
     register_Ns3Gnuplot3dFunction_methods(root_module, root_module['ns3::Gnuplot3dFunction'])
     return
 
+def register_Ns3Average__Double_methods(root_module, cls):
+    ## average.h: ns3::Average<double>::Average(ns3::Average<double> const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::Average< double > const &', 'arg0')])
+    ## average.h: ns3::Average<double>::Average() [constructor]
+    cls.add_constructor([])
+    ## average.h: double ns3::Average<double>::Avg() const [member function]
+    cls.add_method('Avg', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## average.h: uint32_t ns3::Average<double>::Count() const [member function]
+    cls.add_method('Count', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
+    ## average.h: double ns3::Average<double>::Error90() const [member function]
+    cls.add_method('Error90', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## average.h: double ns3::Average<double>::Error95() const [member function]
+    cls.add_method('Error95', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## average.h: double ns3::Average<double>::Error99() const [member function]
+    cls.add_method('Error99', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## average.h: double ns3::Average<double>::Max() const [member function]
+    cls.add_method('Max', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## average.h: double ns3::Average<double>::Mean() const [member function]
+    cls.add_method('Mean', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## average.h: double ns3::Average<double>::Min() const [member function]
+    cls.add_method('Min', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## average.h: void ns3::Average<double>::Reset() [member function]
+    cls.add_method('Reset', 
+                   'void', 
+                   [])
+    ## average.h: double ns3::Average<double>::Stddev() const [member function]
+    cls.add_method('Stddev', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## average.h: void ns3::Average<double>::Update(double const & x) [member function]
+    cls.add_method('Update', 
+                   'void', 
+                   [param('double const &', 'x')])
+    ## average.h: double ns3::Average<double>::Var() const [member function]
+    cls.add_method('Var', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    return
+
 def register_Ns3DelayJitterEstimation_methods(root_module, cls):
     ## delay-jitter-estimation.h: ns3::DelayJitterEstimation::DelayJitterEstimation(ns3::DelayJitterEstimation const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::DelayJitterEstimation const &', 'arg0')])
@@ -501,6 +579,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -516,6 +595,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-ILP32/ns3_module_csma.py

@@ -34,6 +34,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -70,6 +76,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -432,11 +442,6 @@ def register_Ns3CsmaNetDevice_methods(root_module, cls):
                    'void', 
                    [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Mac48Address', 'source'), param('ns3::Mac48Address', 'dest'), param('uint16_t', 'protocolNumber')], 
                    visibility='protected')
-    ## csma-net-device.h: bool ns3::CsmaNetDevice::ProcessHeader(ns3::Ptr<ns3::Packet> p, uint16_t & param) [member function]
-    cls.add_method('ProcessHeader', 
-                   'bool', 
-                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint16_t &', 'param')], 
-                   visibility='protected')
     return
 
 def register_functions(root_module):
@@ -444,6 +449,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -459,6 +465,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-ILP32/ns3_module_dot11s.py

@@ -3,6 +3,8 @@ from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandler
 def register_types(module):
     root_module = module.get_root()
     
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::dot11s::IeBeaconTimingUnit, ns3::empty, ns3::DefaultDeleter<ns3::dot11s::IeBeaconTimingUnit> > [class]
+    module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::dot11s::IeBeaconTimingUnit', 'ns3::empty', 'ns3::DefaultDeleter<ns3::dot11s::IeBeaconTimingUnit>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
     
     ## Register a nested module for the namespace Config
     
@@ -22,6 +24,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -58,6 +66,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -67,12 +79,12 @@ def register_types_ns3_dot11s(module):
     module.add_enum('dot11sSynchronizationProtocolIdentifier', ['SYNC_NEIGHBOUR_OFFSET', 'SYNC_NULL'])
     ## ie-dot11s-configuration.h: ns3::dot11s::dot11sCongestionControlMode [enumeration]
     module.add_enum('dot11sCongestionControlMode', ['CONGESTION_SIGNALING', 'CONGESTION_NULL'])
-    ## ie-dot11s-configuration.h: ns3::dot11s::dot11sAuthenticationProtocol [enumeration]
-    module.add_enum('dot11sAuthenticationProtocol', ['AUTH_NULL', 'AUTH_SAE'])
-    ## ie-dot11s-peer-management.h: ns3::dot11s::PmpReasonCode [enumeration]
-    module.add_enum('PmpReasonCode', ['REASON11S_PEERING_CANCELLED', 'REASON11S_MESH_MAX_PEERS', 'REASON11S_MESH_CAPABILITY_POLICY_VIOLATION', 'REASON11S_MESH_CLOSE_RCVD', 'REASON11S_MESH_MAX_RETRIES', 'REASON11S_MESH_CONFIRM_TIMEOUT', 'REASON11S_MESH_INVALID_GTK', 'REASON11S_MESH_INCONSISTENT_PARAMETERS', 'REASON11S_MESH_INVALID_SECURITY_CAPABILITY', 'REASON11S_RESERVED'])
     ## ie-dot11s-configuration.h: ns3::dot11s::dot11sPathSelectionMetric [enumeration]
     module.add_enum('dot11sPathSelectionMetric', ['METRIC_AIRTIME'])
+    ## ie-dot11s-peer-management.h: ns3::dot11s::PmpReasonCode [enumeration]
+    module.add_enum('PmpReasonCode', ['REASON11S_PEERING_CANCELLED', 'REASON11S_MESH_MAX_PEERS', 'REASON11S_MESH_CAPABILITY_POLICY_VIOLATION', 'REASON11S_MESH_CLOSE_RCVD', 'REASON11S_MESH_MAX_RETRIES', 'REASON11S_MESH_CONFIRM_TIMEOUT', 'REASON11S_MESH_INVALID_GTK', 'REASON11S_MESH_INCONSISTENT_PARAMETERS', 'REASON11S_MESH_INVALID_SECURITY_CAPABILITY', 'REASON11S_RESERVED'])
+    ## ie-dot11s-configuration.h: ns3::dot11s::dot11sAuthenticationProtocol [enumeration]
+    module.add_enum('dot11sAuthenticationProtocol', ['AUTH_NULL', 'AUTH_SAE'])
     ## ie-dot11s-configuration.h: ns3::dot11s::Dot11sMeshCapability [class]
     module.add_class('Dot11sMeshCapability')
     ## hwmp-protocol.h: ns3::dot11s::HwmpProtocol [class]
@@ -82,7 +94,7 @@ def register_types_ns3_dot11s(module):
     ## ie-dot11s-beacon-timing.h: ns3::dot11s::IeBeaconTiming [class]
     module.add_class('IeBeaconTiming', parent=root_module['ns3::WifiInformationElement'])
     ## ie-dot11s-beacon-timing.h: ns3::dot11s::IeBeaconTimingUnit [class]
-    module.add_class('IeBeaconTimingUnit', parent=root_module['ns3::RefCountBase'])
+    module.add_class('IeBeaconTimingUnit', parent=root_module['ns3::SimpleRefCount< ns3::dot11s::IeBeaconTimingUnit, ns3::empty, ns3::DefaultDeleter<ns3::dot11s::IeBeaconTimingUnit> >'])
     ## ie-dot11s-configuration.h: ns3::dot11s::IeConfiguration [class]
     module.add_class('IeConfiguration', parent=root_module['ns3::WifiInformationElement'])
     ## ie-dot11s-id.h: ns3::dot11s::IeMeshId [class]
@@ -599,6 +611,11 @@ def register_Ns3Dot11sPeerLink_methods(root_module, cls):
     cls.add_method('SetLocalAid', 
                    'void', 
                    [param('uint16_t', 'aid')])
+    ## peer-link.h: uint16_t ns3::dot11s::PeerLink::GetPeerAid() const [member function]
+    cls.add_method('GetPeerAid', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
     ## peer-link.h: void ns3::dot11s::PeerLink::SetBeaconTimingElement(ns3::dot11s::IeBeaconTiming beaconTiming) [member function]
     cls.add_method('SetBeaconTimingElement', 
                    'void', 
@@ -675,14 +692,15 @@ def register_Ns3Dot11sPeerManagementProtocol_methods(root_module, cls):
     cls.add_method('FindPeerLink', 
                    'ns3::Ptr< ns3::dot11s::PeerLink >', 
                    [param('uint32_t', 'interface'), param('ns3::Mac48Address', 'peerAddress')])
-    ## peer-management-protocol.h: std::vector<ns3::Mac48Address,std::allocator<ns3::Mac48Address> > ns3::dot11s::PeerManagementProtocol::GetActiveLinks(uint32_t interface) [member function]
-    cls.add_method('GetActiveLinks', 
-                   'std::vector< ns3::Mac48Address >', 
-                   [param('uint32_t', 'interface')])
     ## peer-management-protocol.h: ns3::Mac48Address ns3::dot11s::PeerManagementProtocol::GetAddress() [member function]
     cls.add_method('GetAddress', 
                    'ns3::Mac48Address', 
                    [])
+    ## peer-management-protocol.h: bool ns3::dot11s::PeerManagementProtocol::GetBeaconCollisionAvoidance() const [member function]
+    cls.add_method('GetBeaconCollisionAvoidance', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## peer-management-protocol.h: ns3::Ptr<ns3::dot11s::IeBeaconTiming> ns3::dot11s::PeerManagementProtocol::GetBeaconTimingElement(uint32_t interface) [member function]
     cls.add_method('GetBeaconTimingElement', 
                    'ns3::Ptr< ns3::dot11s::IeBeaconTiming >', 
@@ -696,6 +714,16 @@ def register_Ns3Dot11sPeerManagementProtocol_methods(root_module, cls):
     cls.add_method('GetNumberOfLinks', 
                    'uint8_t', 
                    [])
+    ## peer-management-protocol.h: std::vector<ns3::Ptr<ns3::dot11s::PeerLink>,std::allocator<ns3::Ptr<ns3::dot11s::PeerLink> > > ns3::dot11s::PeerManagementProtocol::GetPeerLinks() const [member function]
+    cls.add_method('GetPeerLinks', 
+                   'std::vector< ns3::Ptr< ns3::dot11s::PeerLink > >', 
+                   [], 
+                   is_const=True)
+    ## peer-management-protocol.h: std::vector<ns3::Mac48Address,std::allocator<ns3::Mac48Address> > ns3::dot11s::PeerManagementProtocol::GetPeers(uint32_t interface) const [member function]
+    cls.add_method('GetPeers', 
+                   'std::vector< ns3::Mac48Address >', 
+                   [param('uint32_t', 'interface')], 
+                   is_const=True)
     ## peer-management-protocol.h: static ns3::TypeId ns3::dot11s::PeerManagementProtocol::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -709,6 +737,14 @@ def register_Ns3Dot11sPeerManagementProtocol_methods(root_module, cls):
     cls.add_method('IsActiveLink', 
                    'bool', 
                    [param('uint32_t', 'interface'), param('ns3::Mac48Address', 'peerAddress')])
+    ## peer-management-protocol.h: void ns3::dot11s::PeerManagementProtocol::NotifyBeaconSent(uint32_t interface, ns3::Time beaconInterval) [member function]
+    cls.add_method('NotifyBeaconSent', 
+                   'void', 
+                   [param('uint32_t', 'interface'), param('ns3::Time', 'beaconInterval')])
+    ## peer-management-protocol.h: void ns3::dot11s::PeerManagementProtocol::ReceiveBeacon(uint32_t interface, ns3::Mac48Address peerAddress, ns3::Time beaconInterval, ns3::Ptr<ns3::dot11s::IeBeaconTiming> beaconTiming) [member function]
+    cls.add_method('ReceiveBeacon', 
+                   'void', 
+                   [param('uint32_t', 'interface'), param('ns3::Mac48Address', 'peerAddress'), param('ns3::Time', 'beaconInterval'), param('ns3::Ptr< ns3::dot11s::IeBeaconTiming >', 'beaconTiming')])
     ## peer-management-protocol.h: void ns3::dot11s::PeerManagementProtocol::ReceivePeerLinkFrame(uint32_t interface, ns3::Mac48Address peerAddress, ns3::Mac48Address peerMeshPointAddress, uint16_t aid, ns3::dot11s::IePeerManagement peerManagementElement, ns3::dot11s::IeConfiguration meshConfig) [member function]
     cls.add_method('ReceivePeerLinkFrame', 
                    'void', 
@@ -722,6 +758,10 @@ def register_Ns3Dot11sPeerManagementProtocol_methods(root_module, cls):
     cls.add_method('ResetStats', 
                    'void', 
                    [])
+    ## peer-management-protocol.h: void ns3::dot11s::PeerManagementProtocol::SetBeaconCollisionAvoidance(bool enable) [member function]
+    cls.add_method('SetBeaconCollisionAvoidance', 
+                   'void', 
+                   [param('bool', 'enable')])
     ## peer-management-protocol.h: void ns3::dot11s::PeerManagementProtocol::SetMeshId(std::string s) [member function]
     cls.add_method('SetMeshId', 
                    'void', 
@@ -738,10 +778,6 @@ def register_Ns3Dot11sPeerManagementProtocol_methods(root_module, cls):
     cls.add_method('TransmissionSuccess', 
                    'void', 
                    [param('uint32_t', 'interface'), param('ns3::Mac48Address const', 'peerAddress')])
-    ## peer-management-protocol.h: void ns3::dot11s::PeerManagementProtocol::UpdatePeerBeaconTiming(uint32_t interface, bool meshBeacon, ns3::dot11s::IeBeaconTiming timingElement, ns3::Mac48Address peerAddress, ns3::Time receivingTime, ns3::Time beaconInterval) [member function]
-    cls.add_method('UpdatePeerBeaconTiming', 
-                   'void', 
-                   [param('uint32_t', 'interface'), param('bool', 'meshBeacon'), param('ns3::dot11s::IeBeaconTiming', 'timingElement'), param('ns3::Mac48Address', 'peerAddress'), param('ns3::Time', 'receivingTime'), param('ns3::Time', 'beaconInterval')])
     return
 
 def register_functions(root_module):
@@ -749,6 +785,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -764,6 +801,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     ## ie-dot11s-id.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::dot11s::MakeIeMeshIdChecker() [free function]
     module.add_function('MakeIeMeshIdChecker', 

bindings/python/apidefs/gcc-ILP32/ns3_module_emu.py

@@ -5,6 +5,8 @@ def register_types(module):
     
     ## emu-net-device.h: ns3::EmuNetDevice [class]
     module.add_class('EmuNetDevice', parent=root_module['ns3::NetDevice'])
+    ## emu-net-device.h: ns3::EmuNetDevice::EncapsulationMode [enumeration]
+    module.add_enum('EncapsulationMode', ['ILLEGAL', 'DIX', 'LLC'], outer_class=root_module['ns3::EmuNetDevice'])
     
     ## Register a nested module for the namespace Config
     
@@ -24,6 +26,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -60,6 +68,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -105,6 +117,11 @@ def register_Ns3EmuNetDevice_methods(root_module, cls):
                    'ns3::Ptr< ns3::Channel >', 
                    [], 
                    is_const=True, is_virtual=True)
+    ## emu-net-device.h: ns3::EmuNetDevice::EncapsulationMode ns3::EmuNetDevice::GetEncapsulationMode() const [member function]
+    cls.add_method('GetEncapsulationMode', 
+                   'ns3::EmuNetDevice::EncapsulationMode', 
+                   [], 
+                   is_const=True)
     ## emu-net-device.h: uint32_t ns3::EmuNetDevice::GetIfIndex() const [member function]
     cls.add_method('GetIfIndex', 
                    'uint32_t', 
@@ -184,6 +201,10 @@ def register_Ns3EmuNetDevice_methods(root_module, cls):
     cls.add_method('SetDataRate', 
                    'void', 
                    [param('ns3::DataRate', 'bps')])
+    ## emu-net-device.h: void ns3::EmuNetDevice::SetEncapsulationMode(ns3::EmuNetDevice::EncapsulationMode mode) [member function]
+    cls.add_method('SetEncapsulationMode', 
+                   'void', 
+                   [param('ns3::EmuNetDevice::EncapsulationMode', 'mode')])
     ## emu-net-device.h: void ns3::EmuNetDevice::SetIfIndex(uint32_t const index) [member function]
     cls.add_method('SetIfIndex', 
                    'void', 
@@ -238,6 +259,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -253,6 +275,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-ILP32/ns3_module_flame.py

@@ -22,6 +22,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -58,6 +64,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -171,6 +181,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -186,6 +197,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-ILP32/ns3_module_flow_monitor.py

@@ -5,10 +5,18 @@ def register_types(module):
     
     ## histogram.h: ns3::Histogram [class]
     module.add_class('Histogram')
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::FlowClassifier, ns3::empty, ns3::DefaultDeleter<ns3::FlowClassifier> > [class]
+    module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::FlowClassifier', 'ns3::empty', 'ns3::DefaultDeleter<ns3::FlowClassifier>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::FlowProbe, ns3::empty, ns3::DefaultDeleter<ns3::FlowProbe> > [class]
+    module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::FlowProbe', 'ns3::empty', 'ns3::DefaultDeleter<ns3::FlowProbe>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
     ## flow-classifier.h: ns3::FlowClassifier [class]
-    module.add_class('FlowClassifier', parent=root_module['ns3::RefCountBase'])
+    module.add_class('FlowClassifier', parent=root_module['ns3::SimpleRefCount< ns3::FlowClassifier, ns3::empty, ns3::DefaultDeleter<ns3::FlowClassifier> >'])
+    ## flow-monitor.h: ns3::FlowMonitor [class]
+    module.add_class('FlowMonitor', parent=root_module['ns3::Object'])
+    ## flow-monitor.h: ns3::FlowMonitor::FlowStats [struct]
+    module.add_class('FlowStats', outer_class=root_module['ns3::FlowMonitor'])
     ## flow-probe.h: ns3::FlowProbe [class]
-    module.add_class('FlowProbe', parent=root_module['ns3::RefCountBase'])
+    module.add_class('FlowProbe', parent=root_module['ns3::SimpleRefCount< ns3::FlowProbe, ns3::empty, ns3::DefaultDeleter<ns3::FlowProbe> >'])
     ## flow-probe.h: ns3::FlowProbe::FlowStats [struct]
     module.add_class('FlowStats', outer_class=root_module['ns3::FlowProbe'])
     ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier [class]
@@ -19,12 +27,8 @@ def register_types(module):
     module.add_class('Ipv4FlowProbe', parent=root_module['ns3::FlowProbe'])
     ## ipv4-flow-probe.h: ns3::Ipv4FlowProbe::DropReason [enumeration]
     module.add_enum('DropReason', ['DROP_NO_ROUTE', 'DROP_TTL_EXPIRE', 'DROP_BAD_CHECKSUM', 'DROP_INVALID_REASON'], outer_class=root_module['ns3::Ipv4FlowProbe'])
-    ## flow-monitor.h: ns3::FlowMonitor [class]
-    module.add_class('FlowMonitor', parent=root_module['ns3::Object'])
-    ## flow-monitor.h: ns3::FlowMonitor::FlowStats [struct]
-    module.add_class('FlowStats', outer_class=root_module['ns3::FlowMonitor'])
-    module.add_container('std::map< unsigned int, ns3::FlowProbe::FlowStats >', ('unsigned int', 'ns3::FlowProbe::FlowStats'), container_type='map')
     module.add_container('std::map< unsigned int, ns3::FlowMonitor::FlowStats >', ('unsigned int', 'ns3::FlowMonitor::FlowStats'), container_type='map')
+    module.add_container('std::map< unsigned int, ns3::FlowProbe::FlowStats >', ('unsigned int', 'ns3::FlowProbe::FlowStats'), container_type='map')
     typehandlers.add_type_alias('uint32_t', 'ns3::FlowPacketId')
     typehandlers.add_type_alias('uint32_t*', 'ns3::FlowPacketId*')
     typehandlers.add_type_alias('uint32_t&', 'ns3::FlowPacketId&')
@@ -50,6 +54,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -86,6 +96,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -105,13 +119,13 @@ def register_types_ns3_olsr(module):
 def register_methods(root_module):
     register_Ns3Histogram_methods(root_module, root_module['ns3::Histogram'])
     register_Ns3FlowClassifier_methods(root_module, root_module['ns3::FlowClassifier'])
+    register_Ns3FlowMonitor_methods(root_module, root_module['ns3::FlowMonitor'])
+    register_Ns3FlowMonitorFlowStats_methods(root_module, root_module['ns3::FlowMonitor::FlowStats'])
     register_Ns3FlowProbe_methods(root_module, root_module['ns3::FlowProbe'])
     register_Ns3FlowProbeFlowStats_methods(root_module, root_module['ns3::FlowProbe::FlowStats'])
     register_Ns3Ipv4FlowClassifier_methods(root_module, root_module['ns3::Ipv4FlowClassifier'])
     register_Ns3Ipv4FlowClassifierFiveTuple_methods(root_module, root_module['ns3::Ipv4FlowClassifier::FiveTuple'])
     register_Ns3Ipv4FlowProbe_methods(root_module, root_module['ns3::Ipv4FlowProbe'])
-    register_Ns3FlowMonitor_methods(root_module, root_module['ns3::FlowMonitor'])
-    register_Ns3FlowMonitorFlowStats_methods(root_module, root_module['ns3::FlowMonitor::FlowStats'])
     return
 
 def register_Ns3Histogram_methods(root_module, cls):
@@ -159,8 +173,6 @@ def register_Ns3Histogram_methods(root_module, cls):
     return
 
 def register_Ns3FlowClassifier_methods(root_module, cls):
-    ## flow-classifier.h: ns3::FlowClassifier::FlowClassifier(ns3::FlowClassifier const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::FlowClassifier const &', 'arg0')])
     ## flow-classifier.h: ns3::FlowClassifier::FlowClassifier() [constructor]
     cls.add_constructor([])
     ## flow-classifier.h: void ns3::FlowClassifier::SerializeToXmlStream(std::ostream & os, int indent) const [member function]
@@ -175,96 +187,6 @@ def register_Ns3FlowClassifier_methods(root_module, cls):
                    visibility='protected')
     return
 
-def register_Ns3FlowProbe_methods(root_module, cls):
-    ## flow-probe.h: ns3::FlowProbe::FlowProbe(ns3::FlowProbe const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::FlowProbe const &', 'arg0')])
-    ## flow-probe.h: void ns3::FlowProbe::AddPacketDropStats(ns3::FlowId flowId, uint32_t packetSize, uint32_t reasonCode) [member function]
-    cls.add_method('AddPacketDropStats', 
-                   'void', 
-                   [param('ns3::FlowId', 'flowId'), param('uint32_t', 'packetSize'), param('uint32_t', 'reasonCode')])
-    ## flow-probe.h: void ns3::FlowProbe::AddPacketStats(ns3::FlowId flowId, uint32_t packetSize, ns3::Time delayFromFirstProbe) [member function]
-    cls.add_method('AddPacketStats', 
-                   'void', 
-                   [param('ns3::FlowId', 'flowId'), param('uint32_t', 'packetSize'), param('ns3::Time', 'delayFromFirstProbe')])
-    ## flow-probe.h: std::map<unsigned int, ns3::FlowProbe::FlowStats, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, ns3::FlowProbe::FlowStats> > > ns3::FlowProbe::GetStats() const [member function]
-    cls.add_method('GetStats', 
-                   'std::map< unsigned int, ns3::FlowProbe::FlowStats >', 
-                   [], 
-                   is_const=True)
-    ## flow-probe.h: void ns3::FlowProbe::SerializeToXmlStream(std::ostream & os, int indent, uint32_t index) const [member function]
-    cls.add_method('SerializeToXmlStream', 
-                   'void', 
-                   [param('std::ostream &', 'os'), param('int', 'indent'), param('uint32_t', 'index')], 
-                   is_const=True)
-    ## flow-probe.h: ns3::FlowProbe::FlowProbe(ns3::Ptr<ns3::FlowMonitor> flowMonitor) [constructor]
-    cls.add_constructor([param('ns3::Ptr< ns3::FlowMonitor >', 'flowMonitor')], 
-                        visibility='protected')
-    return
-
-def register_Ns3FlowProbeFlowStats_methods(root_module, cls):
-    ## flow-probe.h: ns3::FlowProbe::FlowStats::FlowStats(ns3::FlowProbe::FlowStats const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::FlowProbe::FlowStats const &', 'arg0')])
-    ## flow-probe.h: ns3::FlowProbe::FlowStats::FlowStats() [constructor]
-    cls.add_constructor([])
-    ## flow-probe.h: ns3::FlowProbe::FlowStats::bytes [variable]
-    cls.add_instance_attribute('bytes', 'uint64_t', is_const=False)
-    ## flow-probe.h: ns3::FlowProbe::FlowStats::bytesDropped [variable]
-    cls.add_instance_attribute('bytesDropped', 'std::vector< unsigned long long >', is_const=False)
-    ## flow-probe.h: ns3::FlowProbe::FlowStats::delayFromFirstProbeSum [variable]
-    cls.add_instance_attribute('delayFromFirstProbeSum', 'ns3::Time', is_const=False)
-    ## flow-probe.h: ns3::FlowProbe::FlowStats::packets [variable]
-    cls.add_instance_attribute('packets', 'uint32_t', is_const=False)
-    ## flow-probe.h: ns3::FlowProbe::FlowStats::packetsDropped [variable]
-    cls.add_instance_attribute('packetsDropped', 'std::vector< unsigned int >', is_const=False)
-    return
-
-def register_Ns3Ipv4FlowClassifier_methods(root_module, cls):
-    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::Ipv4FlowClassifier(ns3::Ipv4FlowClassifier const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Ipv4FlowClassifier const &', 'arg0')])
-    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::Ipv4FlowClassifier() [constructor]
-    cls.add_constructor([])
-    ## ipv4-flow-classifier.h: bool ns3::Ipv4FlowClassifier::Classify(ns3::Ipv4Header const & ipHeader, ns3::Ptr<ns3::Packet const> ipPayload, uint32_t * out_flowId, uint32_t * out_packetId) [member function]
-    cls.add_method('Classify', 
-                   'bool', 
-                   [param('ns3::Ipv4Header const &', 'ipHeader'), param('ns3::Ptr< ns3::Packet const >', 'ipPayload'), param('uint32_t *', 'out_flowId'), param('uint32_t *', 'out_packetId')])
-    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple ns3::Ipv4FlowClassifier::FindFlow(ns3::FlowId flowId) const [member function]
-    cls.add_method('FindFlow', 
-                   'ns3::Ipv4FlowClassifier::FiveTuple', 
-                   [param('ns3::FlowId', 'flowId')], 
-                   is_const=True)
-    ## ipv4-flow-classifier.h: void ns3::Ipv4FlowClassifier::SerializeToXmlStream(std::ostream & os, int indent) const [member function]
-    cls.add_method('SerializeToXmlStream', 
-                   'void', 
-                   [param('std::ostream &', 'os'), param('int', 'indent')], 
-                   is_const=True, is_virtual=True)
-    return
-
-def register_Ns3Ipv4FlowClassifierFiveTuple_methods(root_module, cls):
-    cls.add_binary_comparison_operator('<')
-    cls.add_binary_comparison_operator('==')
-    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::FiveTuple() [constructor]
-    cls.add_constructor([])
-    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::FiveTuple(ns3::Ipv4FlowClassifier::FiveTuple const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Ipv4FlowClassifier::FiveTuple const &', 'arg0')])
-    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::destinationAddress [variable]
-    cls.add_instance_attribute('destinationAddress', 'ns3::Ipv4Address', is_const=False)
-    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::destinationPort [variable]
-    cls.add_instance_attribute('destinationPort', 'uint16_t', is_const=False)
-    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::protocol [variable]
-    cls.add_instance_attribute('protocol', 'uint8_t', is_const=False)
-    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::sourceAddress [variable]
-    cls.add_instance_attribute('sourceAddress', 'ns3::Ipv4Address', is_const=False)
-    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::sourcePort [variable]
-    cls.add_instance_attribute('sourcePort', 'uint16_t', is_const=False)
-    return
-
-def register_Ns3Ipv4FlowProbe_methods(root_module, cls):
-    ## ipv4-flow-probe.h: ns3::Ipv4FlowProbe::Ipv4FlowProbe(ns3::Ipv4FlowProbe const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Ipv4FlowProbe const &', 'arg0')])
-    ## ipv4-flow-probe.h: ns3::Ipv4FlowProbe::Ipv4FlowProbe(ns3::Ptr<ns3::FlowMonitor> monitor, ns3::Ptr<ns3::Ipv4FlowClassifier> classifier, ns3::Ptr<ns3::Node> node) [constructor]
-    cls.add_constructor([param('ns3::Ptr< ns3::FlowMonitor >', 'monitor'), param('ns3::Ptr< ns3::Ipv4FlowClassifier >', 'classifier'), param('ns3::Ptr< ns3::Node >', 'node')])
-    return
-
 def register_Ns3FlowMonitor_methods(root_module, cls):
     ## flow-monitor.h: ns3::FlowMonitor::FlowMonitor(ns3::FlowMonitor const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::FlowMonitor const &', 'arg0')])
@@ -400,11 +322,96 @@ def register_Ns3FlowMonitorFlowStats_methods(root_module, cls):
     cls.add_instance_attribute('txPackets', 'uint32_t', is_const=False)
     return
 
+def register_Ns3FlowProbe_methods(root_module, cls):
+    ## flow-probe.h: void ns3::FlowProbe::AddPacketDropStats(ns3::FlowId flowId, uint32_t packetSize, uint32_t reasonCode) [member function]
+    cls.add_method('AddPacketDropStats', 
+                   'void', 
+                   [param('ns3::FlowId', 'flowId'), param('uint32_t', 'packetSize'), param('uint32_t', 'reasonCode')])
+    ## flow-probe.h: void ns3::FlowProbe::AddPacketStats(ns3::FlowId flowId, uint32_t packetSize, ns3::Time delayFromFirstProbe) [member function]
+    cls.add_method('AddPacketStats', 
+                   'void', 
+                   [param('ns3::FlowId', 'flowId'), param('uint32_t', 'packetSize'), param('ns3::Time', 'delayFromFirstProbe')])
+    ## flow-probe.h: std::map<unsigned int, ns3::FlowProbe::FlowStats, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, ns3::FlowProbe::FlowStats> > > ns3::FlowProbe::GetStats() const [member function]
+    cls.add_method('GetStats', 
+                   'std::map< unsigned int, ns3::FlowProbe::FlowStats >', 
+                   [], 
+                   is_const=True)
+    ## flow-probe.h: void ns3::FlowProbe::SerializeToXmlStream(std::ostream & os, int indent, uint32_t index) const [member function]
+    cls.add_method('SerializeToXmlStream', 
+                   'void', 
+                   [param('std::ostream &', 'os'), param('int', 'indent'), param('uint32_t', 'index')], 
+                   is_const=True)
+    ## flow-probe.h: ns3::FlowProbe::FlowProbe(ns3::Ptr<ns3::FlowMonitor> flowMonitor) [constructor]
+    cls.add_constructor([param('ns3::Ptr< ns3::FlowMonitor >', 'flowMonitor')], 
+                        visibility='protected')
+    return
+
+def register_Ns3FlowProbeFlowStats_methods(root_module, cls):
+    ## flow-probe.h: ns3::FlowProbe::FlowStats::FlowStats(ns3::FlowProbe::FlowStats const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::FlowProbe::FlowStats const &', 'arg0')])
+    ## flow-probe.h: ns3::FlowProbe::FlowStats::FlowStats() [constructor]
+    cls.add_constructor([])
+    ## flow-probe.h: ns3::FlowProbe::FlowStats::bytes [variable]
+    cls.add_instance_attribute('bytes', 'uint64_t', is_const=False)
+    ## flow-probe.h: ns3::FlowProbe::FlowStats::bytesDropped [variable]
+    cls.add_instance_attribute('bytesDropped', 'std::vector< unsigned long long >', is_const=False)
+    ## flow-probe.h: ns3::FlowProbe::FlowStats::delayFromFirstProbeSum [variable]
+    cls.add_instance_attribute('delayFromFirstProbeSum', 'ns3::Time', is_const=False)
+    ## flow-probe.h: ns3::FlowProbe::FlowStats::packets [variable]
+    cls.add_instance_attribute('packets', 'uint32_t', is_const=False)
+    ## flow-probe.h: ns3::FlowProbe::FlowStats::packetsDropped [variable]
+    cls.add_instance_attribute('packetsDropped', 'std::vector< unsigned int >', is_const=False)
+    return
+
+def register_Ns3Ipv4FlowClassifier_methods(root_module, cls):
+    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::Ipv4FlowClassifier() [constructor]
+    cls.add_constructor([])
+    ## ipv4-flow-classifier.h: bool ns3::Ipv4FlowClassifier::Classify(ns3::Ipv4Header const & ipHeader, ns3::Ptr<ns3::Packet const> ipPayload, uint32_t * out_flowId, uint32_t * out_packetId) [member function]
+    cls.add_method('Classify', 
+                   'bool', 
+                   [param('ns3::Ipv4Header const &', 'ipHeader'), param('ns3::Ptr< ns3::Packet const >', 'ipPayload'), param('uint32_t *', 'out_flowId'), param('uint32_t *', 'out_packetId')])
+    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple ns3::Ipv4FlowClassifier::FindFlow(ns3::FlowId flowId) const [member function]
+    cls.add_method('FindFlow', 
+                   'ns3::Ipv4FlowClassifier::FiveTuple', 
+                   [param('ns3::FlowId', 'flowId')], 
+                   is_const=True)
+    ## ipv4-flow-classifier.h: void ns3::Ipv4FlowClassifier::SerializeToXmlStream(std::ostream & os, int indent) const [member function]
+    cls.add_method('SerializeToXmlStream', 
+                   'void', 
+                   [param('std::ostream &', 'os'), param('int', 'indent')], 
+                   is_const=True, is_virtual=True)
+    return
+
+def register_Ns3Ipv4FlowClassifierFiveTuple_methods(root_module, cls):
+    cls.add_binary_comparison_operator('<')
+    cls.add_binary_comparison_operator('==')
+    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::FiveTuple() [constructor]
+    cls.add_constructor([])
+    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::FiveTuple(ns3::Ipv4FlowClassifier::FiveTuple const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::Ipv4FlowClassifier::FiveTuple const &', 'arg0')])
+    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::destinationAddress [variable]
+    cls.add_instance_attribute('destinationAddress', 'ns3::Ipv4Address', is_const=False)
+    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::destinationPort [variable]
+    cls.add_instance_attribute('destinationPort', 'uint16_t', is_const=False)
+    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::protocol [variable]
+    cls.add_instance_attribute('protocol', 'uint8_t', is_const=False)
+    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::sourceAddress [variable]
+    cls.add_instance_attribute('sourceAddress', 'ns3::Ipv4Address', is_const=False)
+    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::sourcePort [variable]
+    cls.add_instance_attribute('sourcePort', 'uint16_t', is_const=False)
+    return
+
+def register_Ns3Ipv4FlowProbe_methods(root_module, cls):
+    ## ipv4-flow-probe.h: ns3::Ipv4FlowProbe::Ipv4FlowProbe(ns3::Ptr<ns3::FlowMonitor> monitor, ns3::Ptr<ns3::Ipv4FlowClassifier> classifier, ns3::Ptr<ns3::Node> node) [constructor]
+    cls.add_constructor([param('ns3::Ptr< ns3::FlowMonitor >', 'monitor'), param('ns3::Ptr< ns3::Ipv4FlowClassifier >', 'classifier'), param('ns3::Ptr< ns3::Node >', 'node')])
+    return
+
 def register_functions(root_module):
     module = root_module
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -420,6 +427,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-ILP32/ns3_module_global_routing.py

@@ -38,6 +38,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -74,6 +80,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -99,16 +109,6 @@ def register_methods(root_module):
     return
 
 def register_Ns3GlobalRouteManager_methods(root_module, cls):
-    ## global-route-manager.h: static void ns3::GlobalRouteManager::PopulateRoutingTables() [member function]
-    cls.add_method('PopulateRoutingTables', 
-                   'void', 
-                   [], 
-                   is_static=True, deprecated=True)
-    ## global-route-manager.h: static void ns3::GlobalRouteManager::RecomputeRoutingTables() [member function]
-    cls.add_method('RecomputeRoutingTables', 
-                   'void', 
-                   [], 
-                   is_static=True, deprecated=True)
     ## global-route-manager.h: static uint32_t ns3::GlobalRouteManager::AllocateRouterId() [member function]
     cls.add_method('AllocateRouterId', 
                    'uint32_t', 
@@ -410,15 +410,15 @@ def register_Ns3Ipv4GlobalRouting_methods(root_module, cls):
     cls.add_method('RemoveRoute', 
                    'void', 
                    [param('uint32_t', 'i')])
-    ## ipv4-global-routing.h: bool ns3::Ipv4GlobalRouting::RouteInput(ns3::Ptr<ns3::Packet const> p, ns3::Ipv4Header const & header, ns3::Ptr<const ns3::NetDevice> idev, ns3::Callback<void,ns3::Ptr<ns3::Ipv4Route>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ucb, ns3::Callback<void,ns3::Ptr<ns3::Ipv4MulticastRoute>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> mcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,unsigned int,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> lcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::Socket::SocketErrno,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ecb) [member function]
+    ## ipv4-global-routing.h: bool ns3::Ipv4GlobalRouting::RouteInput(ns3::Ptr<ns3::Packet const> p, ns3::Ipv4Header const & header, ns3::Ptr<const ns3::NetDevice> idev, ns3::Callback<void, ns3::Ptr<ns3::Ipv4Route>, ns3::Ptr<ns3::Packet const>, ns3::Ipv4Header const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ucb, ns3::Callback<void,ns3::Ptr<ns3::Ipv4MulticastRoute>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> mcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,unsigned int,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> lcb, ns3::Callback<void, ns3::Ptr<ns3::Packet const>, ns3::Ipv4Header const&, ns3::Socket::SocketErrno, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ecb) [member function]
     cls.add_method('RouteInput', 
                    'bool', 
                    [param('ns3::Ptr< ns3::Packet const >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice const >', 'idev'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv4Route >, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ucb'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv4MulticastRoute >, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'mcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'lcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::Socket::SocketErrno, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ecb')], 
                    is_virtual=True)
-    ## ipv4-global-routing.h: ns3::Ptr<ns3::Ipv4Route> ns3::Ipv4GlobalRouting::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Header const & header, uint32_t oif, ns3::Socket::SocketErrno & sockerr) [member function]
+    ## ipv4-global-routing.h: ns3::Ptr<ns3::Ipv4Route> ns3::Ipv4GlobalRouting::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Header const & header, ns3::Ptr<ns3::NetDevice> oif, ns3::Socket::SocketErrno & sockerr) [member function]
     cls.add_method('RouteOutput', 
                    'ns3::Ptr< ns3::Ipv4Route >', 
-                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('uint32_t', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice >', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
                    is_virtual=True)
     ## ipv4-global-routing.h: void ns3::Ipv4GlobalRouting::SetIpv4(ns3::Ptr<ns3::Ipv4> ipv4) [member function]
     cls.add_method('SetIpv4', 
@@ -437,6 +437,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -452,6 +453,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-ILP32/ns3_module_helper.py

@@ -3,6 +3,8 @@ from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandler
 def register_types(module):
     root_module = module.get_root()
     
+    ## animation-interface.h: ns3::AnimationInterface [class]
+    module.add_class('AnimationInterface')
     ## application-container.h: ns3::ApplicationContainer [class]
     module.add_class('ApplicationContainer')
     ## athstats-helper.h: ns3::AthstatsHelper [class]
@@ -11,6 +13,8 @@ def register_types(module):
     module.add_class('BridgeHelper', allow_subclassing=False)
     ## csma-helper.h: ns3::CsmaHelper [class]
     module.add_class('CsmaHelper', allow_subclassing=False)
+    ## csma-star-helper.h: ns3::CsmaStarHelper [class]
+    module.add_class('CsmaStarHelper', allow_subclassing=False)
     ## emu-helper.h: ns3::EmuHelper [class]
     module.add_class('EmuHelper', allow_subclassing=False)
     ## flow-monitor-helper.h: ns3::FlowMonitorHelper [class]
@@ -55,14 +59,26 @@ def register_types(module):
     module.add_class('PacketSocketHelper', allow_subclassing=False)
     ## ping6-helper.h: ns3::Ping6Helper [class]
     module.add_class('Ping6Helper', allow_subclassing=False)
+    ## point-to-point-dumbbell-helper.h: ns3::PointToPointDumbbellHelper [class]
+    module.add_class('PointToPointDumbbellHelper', allow_subclassing=False)
+    ## point-to-point-grid-helper.h: ns3::PointToPointGridHelper [class]
+    module.add_class('PointToPointGridHelper', allow_subclassing=False)
     ## point-to-point-helper.h: ns3::PointToPointHelper [class]
     module.add_class('PointToPointHelper', allow_subclassing=False)
+    ## point-to-point-star-helper.h: ns3::PointToPointStarHelper [class]
+    module.add_class('PointToPointStarHelper', allow_subclassing=False)
     ## tap-bridge-helper.h: ns3::TapBridgeHelper [class]
     module.add_class('TapBridgeHelper', allow_subclassing=False)
+    ## udp-client-server-helper.h: ns3::UdpClientHelper [class]
+    module.add_class('UdpClientHelper', allow_subclassing=False)
     ## udp-echo-helper.h: ns3::UdpEchoClientHelper [class]
     module.add_class('UdpEchoClientHelper', allow_subclassing=False)
     ## udp-echo-helper.h: ns3::UdpEchoServerHelper [class]
     module.add_class('UdpEchoServerHelper', allow_subclassing=False)
+    ## udp-client-server-helper.h: ns3::UdpServerHelper [class]
+    module.add_class('UdpServerHelper', allow_subclassing=False)
+    ## udp-client-server-helper.h: ns3::UdpTraceClientHelper [class]
+    module.add_class('UdpTraceClientHelper', allow_subclassing=False)
     ## v4ping-helper.h: ns3::V4PingHelper [class]
     module.add_class('V4PingHelper', allow_subclassing=False)
     ## wifi-helper.h: ns3::WifiHelper [class]
@@ -77,6 +93,8 @@ def register_types(module):
     module.add_class('YansWifiPhyHelper', allow_subclassing=False, parent=root_module['ns3::WifiPhyHelper'])
     ## yans-wifi-helper.h: ns3::YansWifiPhyHelper::PcapFormat [enumeration]
     module.add_enum('PcapFormat', ['PCAP_FORMAT_80211', 'PCAP_FORMAT_80211_PRISM', 'PCAP_FORMAT_80211_RADIOTAP'], outer_class=root_module['ns3::YansWifiPhyHelper'])
+    ## aodv-helper.h: ns3::AodvHelper [class]
+    module.add_class('AodvHelper', allow_subclassing=False, parent=root_module['ns3::Ipv4RoutingHelper'])
     ## ipv4-global-routing-helper.h: ns3::Ipv4GlobalRoutingHelper [class]
     module.add_class('Ipv4GlobalRoutingHelper', allow_subclassing=False, parent=root_module['ns3::Ipv4RoutingHelper'])
     ## ipv4-list-routing-helper.h: ns3::Ipv4ListRoutingHelper [class]
@@ -91,6 +109,8 @@ def register_types(module):
     module.add_class('QosWifiMacHelper', allow_subclassing=False, parent=root_module['ns3::WifiMacHelper'])
     ## athstats-helper.h: ns3::AthstatsWifiTraceSink [class]
     module.add_class('AthstatsWifiTraceSink', parent=root_module['ns3::Object'])
+    ## canvas-location.h: ns3::CanvasLocation [class]
+    module.add_class('CanvasLocation', parent=root_module['ns3::Object'])
     ## mesh-stack-installer.h: ns3::MeshStack [class]
     module.add_class('MeshStack', parent=root_module['ns3::Object'])
     ## dot11s-installer.h: ns3::Dot11sStack [class]
@@ -116,6 +136,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -152,6 +178,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -169,10 +199,12 @@ def register_types_ns3_olsr(module):
     
 
 def register_methods(root_module):
+    register_Ns3AnimationInterface_methods(root_module, root_module['ns3::AnimationInterface'])
     register_Ns3ApplicationContainer_methods(root_module, root_module['ns3::ApplicationContainer'])
     register_Ns3AthstatsHelper_methods(root_module, root_module['ns3::AthstatsHelper'])
     register_Ns3BridgeHelper_methods(root_module, root_module['ns3::BridgeHelper'])
     register_Ns3CsmaHelper_methods(root_module, root_module['ns3::CsmaHelper'])
+    register_Ns3CsmaStarHelper_methods(root_module, root_module['ns3::CsmaStarHelper'])
     register_Ns3EmuHelper_methods(root_module, root_module['ns3::EmuHelper'])
     register_Ns3FlowMonitorHelper_methods(root_module, root_module['ns3::FlowMonitorHelper'])
     register_Ns3InternetStackHelper_methods(root_module, root_module['ns3::InternetStackHelper'])
@@ -194,16 +226,23 @@ def register_methods(root_module):
     register_Ns3PacketSinkHelper_methods(root_module, root_module['ns3::PacketSinkHelper'])
     register_Ns3PacketSocketHelper_methods(root_module, root_module['ns3::PacketSocketHelper'])
     register_Ns3Ping6Helper_methods(root_module, root_module['ns3::Ping6Helper'])
+    register_Ns3PointToPointDumbbellHelper_methods(root_module, root_module['ns3::PointToPointDumbbellHelper'])
+    register_Ns3PointToPointGridHelper_methods(root_module, root_module['ns3::PointToPointGridHelper'])
     register_Ns3PointToPointHelper_methods(root_module, root_module['ns3::PointToPointHelper'])
+    register_Ns3PointToPointStarHelper_methods(root_module, root_module['ns3::PointToPointStarHelper'])
     register_Ns3TapBridgeHelper_methods(root_module, root_module['ns3::TapBridgeHelper'])
+    register_Ns3UdpClientHelper_methods(root_module, root_module['ns3::UdpClientHelper'])
     register_Ns3UdpEchoClientHelper_methods(root_module, root_module['ns3::UdpEchoClientHelper'])
     register_Ns3UdpEchoServerHelper_methods(root_module, root_module['ns3::UdpEchoServerHelper'])
+    register_Ns3UdpServerHelper_methods(root_module, root_module['ns3::UdpServerHelper'])
+    register_Ns3UdpTraceClientHelper_methods(root_module, root_module['ns3::UdpTraceClientHelper'])
     register_Ns3V4PingHelper_methods(root_module, root_module['ns3::V4PingHelper'])
     register_Ns3WifiHelper_methods(root_module, root_module['ns3::WifiHelper'])
     register_Ns3WifiMacHelper_methods(root_module, root_module['ns3::WifiMacHelper'])
     register_Ns3WifiPhyHelper_methods(root_module, root_module['ns3::WifiPhyHelper'])
     register_Ns3YansWifiChannelHelper_methods(root_module, root_module['ns3::YansWifiChannelHelper'])
     register_Ns3YansWifiPhyHelper_methods(root_module, root_module['ns3::YansWifiPhyHelper'])
+    register_Ns3AodvHelper_methods(root_module, root_module['ns3::AodvHelper'])
     register_Ns3Ipv4GlobalRoutingHelper_methods(root_module, root_module['ns3::Ipv4GlobalRoutingHelper'])
     register_Ns3Ipv4ListRoutingHelper_methods(root_module, root_module['ns3::Ipv4ListRoutingHelper'])
     register_Ns3Ipv4NixVectorHelper_methods(root_module, root_module['ns3::Ipv4NixVectorHelper'])
@@ -211,11 +250,35 @@ def register_methods(root_module):
     register_Ns3NqosWifiMacHelper_methods(root_module, root_module['ns3::NqosWifiMacHelper'])
     register_Ns3QosWifiMacHelper_methods(root_module, root_module['ns3::QosWifiMacHelper'])
     register_Ns3AthstatsWifiTraceSink_methods(root_module, root_module['ns3::AthstatsWifiTraceSink'])
+    register_Ns3CanvasLocation_methods(root_module, root_module['ns3::CanvasLocation'])
     register_Ns3MeshStack_methods(root_module, root_module['ns3::MeshStack'])
     register_Ns3Dot11sStack_methods(root_module, root_module['ns3::Dot11sStack'])
     register_Ns3FlameStack_methods(root_module, root_module['ns3::FlameStack'])
     return
 
+def register_Ns3AnimationInterface_methods(root_module, cls):
+    ## animation-interface.h: ns3::AnimationInterface::AnimationInterface(ns3::AnimationInterface const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::AnimationInterface const &', 'arg0')])
+    ## animation-interface.h: ns3::AnimationInterface::AnimationInterface() [constructor]
+    cls.add_constructor([])
+    ## animation-interface.h: bool ns3::AnimationInterface::SetOutputFile(std::string const & fn) [member function]
+    cls.add_method('SetOutputFile', 
+                   'bool', 
+                   [param('std::string const &', 'fn')])
+    ## animation-interface.h: bool ns3::AnimationInterface::SetServerPort(uint16_t port) [member function]
+    cls.add_method('SetServerPort', 
+                   'bool', 
+                   [param('uint16_t', 'port')])
+    ## animation-interface.h: void ns3::AnimationInterface::StartAnimation() [member function]
+    cls.add_method('StartAnimation', 
+                   'void', 
+                   [])
+    ## animation-interface.h: void ns3::AnimationInterface::StopAnimation() [member function]
+    cls.add_method('StopAnimation', 
+                   'void', 
+                   [])
+    return
+
 def register_Ns3ApplicationContainer_methods(root_module, cls):
     ## application-container.h: ns3::ApplicationContainer::ApplicationContainer(ns3::ApplicationContainer const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::ApplicationContainer const &', 'arg0')])
@@ -409,14 +472,6 @@ def register_Ns3CsmaHelper_methods(root_module, cls):
                    'ns3::NetDeviceContainer', 
                    [param('ns3::NodeContainer const &', 'c'), param('std::string', 'channelName')], 
                    is_const=True)
-    ## csma-helper.h: void ns3::CsmaHelper::InstallStar(ns3::Ptr<ns3::Node> hub, ns3::NodeContainer spokes, ns3::NetDeviceContainer & hubDevices, ns3::NetDeviceContainer & spokeDevices) [member function]
-    cls.add_method('InstallStar', 
-                   'void', 
-                   [param('ns3::Ptr< ns3::Node >', 'hub'), param('ns3::NodeContainer', 'spokes'), param('ns3::NetDeviceContainer &', 'hubDevices'), param('ns3::NetDeviceContainer &', 'spokeDevices')])
-    ## csma-helper.h: void ns3::CsmaHelper::InstallStar(std::string hubName, ns3::NodeContainer spokes, ns3::NetDeviceContainer & hubDevices, ns3::NetDeviceContainer & spokeDevices) [member function]
-    cls.add_method('InstallStar', 
-                   'void', 
-                   [param('std::string', 'hubName'), param('ns3::NodeContainer', 'spokes'), param('ns3::NetDeviceContainer &', 'hubDevices'), param('ns3::NetDeviceContainer &', 'spokeDevices')])
     ## csma-helper.h: void ns3::CsmaHelper::SetChannelAttribute(std::string n1, ns3::AttributeValue const & v1) [member function]
     cls.add_method('SetChannelAttribute', 
                    'void', 
@@ -431,6 +486,56 @@ def register_Ns3CsmaHelper_methods(root_module, cls):
                    [param('std::string', 'type'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue const &', 'v1', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue const &', 'v2', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue const &', 'v3', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue const &', 'v4', default_value='ns3::EmptyAttributeValue()')])
     return
 
+def register_Ns3CsmaStarHelper_methods(root_module, cls):
+    ## csma-star-helper.h: ns3::CsmaStarHelper::CsmaStarHelper(ns3::CsmaStarHelper const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::CsmaStarHelper const &', 'arg0')])
+    ## csma-star-helper.h: ns3::CsmaStarHelper::CsmaStarHelper(uint32_t numSpokes, ns3::CsmaHelper csmaHelper) [constructor]
+    cls.add_constructor([param('uint32_t', 'numSpokes'), param('ns3::CsmaHelper', 'csmaHelper')])
+    ## csma-star-helper.h: void ns3::CsmaStarHelper::AssignIpv4Addresses(ns3::Ipv4AddressHelper address) [member function]
+    cls.add_method('AssignIpv4Addresses', 
+                   'void', 
+                   [param('ns3::Ipv4AddressHelper', 'address')])
+    ## csma-star-helper.h: ns3::Ptr<ns3::Node> ns3::CsmaStarHelper::GetHub() const [member function]
+    cls.add_method('GetHub', 
+                   'ns3::Ptr< ns3::Node >', 
+                   [], 
+                   is_const=True)
+    ## csma-star-helper.h: ns3::NetDeviceContainer ns3::CsmaStarHelper::GetHubDevices() const [member function]
+    cls.add_method('GetHubDevices', 
+                   'ns3::NetDeviceContainer', 
+                   [], 
+                   is_const=True)
+    ## csma-star-helper.h: ns3::Ipv4Address ns3::CsmaStarHelper::GetHubIpv4Address(uint32_t i) const [member function]
+    cls.add_method('GetHubIpv4Address', 
+                   'ns3::Ipv4Address', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
+    ## csma-star-helper.h: ns3::NetDeviceContainer ns3::CsmaStarHelper::GetSpokeDevices() const [member function]
+    cls.add_method('GetSpokeDevices', 
+                   'ns3::NetDeviceContainer', 
+                   [], 
+                   is_const=True)
+    ## csma-star-helper.h: ns3::Ipv4Address ns3::CsmaStarHelper::GetSpokeIpv4Address(uint32_t i) const [member function]
+    cls.add_method('GetSpokeIpv4Address', 
+                   'ns3::Ipv4Address', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
+    ## csma-star-helper.h: ns3::Ptr<ns3::Node> ns3::CsmaStarHelper::GetSpokeNode(uint32_t i) const [member function]
+    cls.add_method('GetSpokeNode', 
+                   'ns3::Ptr< ns3::Node >', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
+    ## csma-star-helper.h: void ns3::CsmaStarHelper::InstallStack(ns3::InternetStackHelper stack) [member function]
+    cls.add_method('InstallStack', 
+                   'void', 
+                   [param('ns3::InternetStackHelper', 'stack')])
+    ## csma-star-helper.h: uint32_t ns3::CsmaStarHelper::SpokeCount() const [member function]
+    cls.add_method('SpokeCount', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
+    return
+
 def register_Ns3EmuHelper_methods(root_module, cls):
     ## emu-helper.h: ns3::EmuHelper::EmuHelper(ns3::EmuHelper const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::EmuHelper const &', 'arg0')])
@@ -650,10 +755,10 @@ def register_Ns3Ipv4InterfaceContainer_methods(root_module, cls):
     cls.add_method('Add', 
                    'void', 
                    [param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')])
-    ## ipv4-interface-container.h: void ns3::Ipv4InterfaceContainer::Add(std::pair<ns3::Ptr<ns3::Ipv4>,unsigned int> arg0) [member function]
+    ## ipv4-interface-container.h: void ns3::Ipv4InterfaceContainer::Add(std::pair<ns3::Ptr<ns3::Ipv4>,unsigned int> ipInterfacePair) [member function]
     cls.add_method('Add', 
                    'void', 
-                   [param('std::pair< ns3::Ptr< ns3::Ipv4 >, unsigned int >', 'arg0')])
+                   [param('std::pair< ns3::Ptr< ns3::Ipv4 >, unsigned int >', 'ipInterfacePair')])
     ## ipv4-interface-container.h: void ns3::Ipv4InterfaceContainer::Add(std::string ipv4Name, uint32_t interface) [member function]
     cls.add_method('Add', 
                    'void', 
@@ -1230,6 +1335,96 @@ def register_Ns3Ping6Helper_methods(root_module, cls):
     cls.add_method('SetRemote', 
                    'void', 
                    [param('ns3::Ipv6Address', 'ip')])
+    ## ping6-helper.h: void ns3::Ping6Helper::SetRoutersAddress(std::vector<ns3::Ipv6Address, std::allocator<ns3::Ipv6Address> > routers) [member function]
+    cls.add_method('SetRoutersAddress', 
+                   'void', 
+                   [param('std::vector< ns3::Ipv6Address >', 'routers')])
+    return
+
+def register_Ns3PointToPointDumbbellHelper_methods(root_module, cls):
+    ## point-to-point-dumbbell-helper.h: ns3::PointToPointDumbbellHelper::PointToPointDumbbellHelper(ns3::PointToPointDumbbellHelper const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::PointToPointDumbbellHelper const &', 'arg0')])
+    ## point-to-point-dumbbell-helper.h: ns3::PointToPointDumbbellHelper::PointToPointDumbbellHelper(uint32_t nLeftLeaf, ns3::PointToPointHelper leftHelper, uint32_t nRightLeaf, ns3::PointToPointHelper rightHelper, ns3::PointToPointHelper bottleneckHelper) [constructor]
+    cls.add_constructor([param('uint32_t', 'nLeftLeaf'), param('ns3::PointToPointHelper', 'leftHelper'), param('uint32_t', 'nRightLeaf'), param('ns3::PointToPointHelper', 'rightHelper'), param('ns3::PointToPointHelper', 'bottleneckHelper')])
+    ## point-to-point-dumbbell-helper.h: void ns3::PointToPointDumbbellHelper::AssignIpv4Addresses(ns3::Ipv4AddressHelper leftIp, ns3::Ipv4AddressHelper rightIp, ns3::Ipv4AddressHelper routerIp) [member function]
+    cls.add_method('AssignIpv4Addresses', 
+                   'void', 
+                   [param('ns3::Ipv4AddressHelper', 'leftIp'), param('ns3::Ipv4AddressHelper', 'rightIp'), param('ns3::Ipv4AddressHelper', 'routerIp')])
+    ## point-to-point-dumbbell-helper.h: void ns3::PointToPointDumbbellHelper::BoundingBox(double arg0, double arg1, double arg2, double arg3) [member function]
+    cls.add_method('BoundingBox', 
+                   'void', 
+                   [param('double', 'arg0'), param('double', 'arg1'), param('double', 'arg2'), param('double', 'arg3')])
+    ## point-to-point-dumbbell-helper.h: ns3::Ptr<ns3::Node> ns3::PointToPointDumbbellHelper::GetLeft() const [member function]
+    cls.add_method('GetLeft', 
+                   'ns3::Ptr< ns3::Node >', 
+                   [], 
+                   is_const=True)
+    ## point-to-point-dumbbell-helper.h: ns3::Ptr<ns3::Node> ns3::PointToPointDumbbellHelper::GetLeft(uint32_t i) const [member function]
+    cls.add_method('GetLeft', 
+                   'ns3::Ptr< ns3::Node >', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
+    ## point-to-point-dumbbell-helper.h: ns3::Ipv4Address ns3::PointToPointDumbbellHelper::GetLeftIpv4Address(uint32_t i) const [member function]
+    cls.add_method('GetLeftIpv4Address', 
+                   'ns3::Ipv4Address', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
+    ## point-to-point-dumbbell-helper.h: ns3::Ptr<ns3::Node> ns3::PointToPointDumbbellHelper::GetRight() const [member function]
+    cls.add_method('GetRight', 
+                   'ns3::Ptr< ns3::Node >', 
+                   [], 
+                   is_const=True)
+    ## point-to-point-dumbbell-helper.h: ns3::Ptr<ns3::Node> ns3::PointToPointDumbbellHelper::GetRight(uint32_t i) const [member function]
+    cls.add_method('GetRight', 
+                   'ns3::Ptr< ns3::Node >', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
+    ## point-to-point-dumbbell-helper.h: ns3::Ipv4Address ns3::PointToPointDumbbellHelper::GetRightIpv4Address(uint32_t i) const [member function]
+    cls.add_method('GetRightIpv4Address', 
+                   'ns3::Ipv4Address', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
+    ## point-to-point-dumbbell-helper.h: void ns3::PointToPointDumbbellHelper::InstallStack(ns3::InternetStackHelper stack) [member function]
+    cls.add_method('InstallStack', 
+                   'void', 
+                   [param('ns3::InternetStackHelper', 'stack')])
+    ## point-to-point-dumbbell-helper.h: uint32_t ns3::PointToPointDumbbellHelper::LeftCount() const [member function]
+    cls.add_method('LeftCount', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
+    ## point-to-point-dumbbell-helper.h: uint32_t ns3::PointToPointDumbbellHelper::RightCount() const [member function]
+    cls.add_method('RightCount', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
+    return
+
+def register_Ns3PointToPointGridHelper_methods(root_module, cls):
+    ## point-to-point-grid-helper.h: ns3::PointToPointGridHelper::PointToPointGridHelper(ns3::PointToPointGridHelper const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::PointToPointGridHelper const &', 'arg0')])
+    ## point-to-point-grid-helper.h: ns3::PointToPointGridHelper::PointToPointGridHelper(uint32_t nRows, uint32_t nCols, ns3::PointToPointHelper pointToPoint) [constructor]
+    cls.add_constructor([param('uint32_t', 'nRows'), param('uint32_t', 'nCols'), param('ns3::PointToPointHelper', 'pointToPoint')])
+    ## point-to-point-grid-helper.h: void ns3::PointToPointGridHelper::AssignIpv4Addresses(ns3::Ipv4AddressHelper rowIp, ns3::Ipv4AddressHelper colIp) [member function]
+    cls.add_method('AssignIpv4Addresses', 
+                   'void', 
+                   [param('ns3::Ipv4AddressHelper', 'rowIp'), param('ns3::Ipv4AddressHelper', 'colIp')])
+    ## point-to-point-grid-helper.h: void ns3::PointToPointGridHelper::BoundingBox(double ulx, double uly, double lrx, double lry) [member function]
+    cls.add_method('BoundingBox', 
+                   'void', 
+                   [param('double', 'ulx'), param('double', 'uly'), param('double', 'lrx'), param('double', 'lry')])
+    ## point-to-point-grid-helper.h: ns3::Ipv4Address ns3::PointToPointGridHelper::GetIpv4Address(uint32_t row, uint32_t col) [member function]
+    cls.add_method('GetIpv4Address', 
+                   'ns3::Ipv4Address', 
+                   [param('uint32_t', 'row'), param('uint32_t', 'col')])
+    ## point-to-point-grid-helper.h: ns3::Ptr<ns3::Node> ns3::PointToPointGridHelper::GetNode(uint32_t row, uint32_t col) [member function]
+    cls.add_method('GetNode', 
+                   'ns3::Ptr< ns3::Node >', 
+                   [param('uint32_t', 'row'), param('uint32_t', 'col')])
+    ## point-to-point-grid-helper.h: void ns3::PointToPointGridHelper::InstallStack(ns3::InternetStackHelper stack) [member function]
+    cls.add_method('InstallStack', 
+                   'void', 
+                   [param('ns3::InternetStackHelper', 'stack')])
     return
 
 def register_Ns3PointToPointHelper_methods(root_module, cls):
@@ -1307,14 +1502,6 @@ def register_Ns3PointToPointHelper_methods(root_module, cls):
     cls.add_method('Install', 
                    'ns3::NetDeviceContainer', 
                    [param('std::string', 'aNode'), param('std::string', 'bNode')])
-    ## point-to-point-helper.h: void ns3::PointToPointHelper::InstallStar(ns3::Ptr<ns3::Node> hub, ns3::NodeContainer spokes, ns3::NetDeviceContainer & hubDevices, ns3::NetDeviceContainer & spokeDevices) [member function]
-    cls.add_method('InstallStar', 
-                   'void', 
-                   [param('ns3::Ptr< ns3::Node >', 'hub'), param('ns3::NodeContainer', 'spokes'), param('ns3::NetDeviceContainer &', 'hubDevices'), param('ns3::NetDeviceContainer &', 'spokeDevices')])
-    ## point-to-point-helper.h: void ns3::PointToPointHelper::InstallStar(std::string hubName, ns3::NodeContainer spokes, ns3::NetDeviceContainer & hubDevices, ns3::NetDeviceContainer & spokeDevices) [member function]
-    cls.add_method('InstallStar', 
-                   'void', 
-                   [param('std::string', 'hubName'), param('ns3::NodeContainer', 'spokes'), param('ns3::NetDeviceContainer &', 'hubDevices'), param('ns3::NetDeviceContainer &', 'spokeDevices')])
     ## point-to-point-helper.h: void ns3::PointToPointHelper::SetChannelAttribute(std::string name, ns3::AttributeValue const & value) [member function]
     cls.add_method('SetChannelAttribute', 
                    'void', 
@@ -1329,6 +1516,50 @@ def register_Ns3PointToPointHelper_methods(root_module, cls):
                    [param('std::string', 'type'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue const &', 'v1', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue const &', 'v2', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue const &', 'v3', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue const &', 'v4', default_value='ns3::EmptyAttributeValue()')])
     return
 
+def register_Ns3PointToPointStarHelper_methods(root_module, cls):
+    ## point-to-point-star-helper.h: ns3::PointToPointStarHelper::PointToPointStarHelper(ns3::PointToPointStarHelper const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::PointToPointStarHelper const &', 'arg0')])
+    ## point-to-point-star-helper.h: ns3::PointToPointStarHelper::PointToPointStarHelper(uint32_t numSpokes, ns3::PointToPointHelper p2pHelper) [constructor]
+    cls.add_constructor([param('uint32_t', 'numSpokes'), param('ns3::PointToPointHelper', 'p2pHelper')])
+    ## point-to-point-star-helper.h: void ns3::PointToPointStarHelper::AssignIpv4Addresses(ns3::Ipv4AddressHelper address) [member function]
+    cls.add_method('AssignIpv4Addresses', 
+                   'void', 
+                   [param('ns3::Ipv4AddressHelper', 'address')])
+    ## point-to-point-star-helper.h: void ns3::PointToPointStarHelper::BoundingBox(double ulx, double uly, double lrx, double lry) [member function]
+    cls.add_method('BoundingBox', 
+                   'void', 
+                   [param('double', 'ulx'), param('double', 'uly'), param('double', 'lrx'), param('double', 'lry')])
+    ## point-to-point-star-helper.h: ns3::Ptr<ns3::Node> ns3::PointToPointStarHelper::GetHub() const [member function]
+    cls.add_method('GetHub', 
+                   'ns3::Ptr< ns3::Node >', 
+                   [], 
+                   is_const=True)
+    ## point-to-point-star-helper.h: ns3::Ipv4Address ns3::PointToPointStarHelper::GetHubIpv4Address(uint32_t i) const [member function]
+    cls.add_method('GetHubIpv4Address', 
+                   'ns3::Ipv4Address', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
+    ## point-to-point-star-helper.h: ns3::Ipv4Address ns3::PointToPointStarHelper::GetSpokeIpv4Address(uint32_t i) const [member function]
+    cls.add_method('GetSpokeIpv4Address', 
+                   'ns3::Ipv4Address', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
+    ## point-to-point-star-helper.h: ns3::Ptr<ns3::Node> ns3::PointToPointStarHelper::GetSpokeNode(uint32_t i) const [member function]
+    cls.add_method('GetSpokeNode', 
+                   'ns3::Ptr< ns3::Node >', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
+    ## point-to-point-star-helper.h: void ns3::PointToPointStarHelper::InstallStack(ns3::InternetStackHelper stack) [member function]
+    cls.add_method('InstallStack', 
+                   'void', 
+                   [param('ns3::InternetStackHelper', 'stack')])
+    ## point-to-point-star-helper.h: uint32_t ns3::PointToPointStarHelper::SpokeCount() const [member function]
+    cls.add_method('SpokeCount', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
+    return
+
 def register_Ns3TapBridgeHelper_methods(root_module, cls):
     ## tap-bridge-helper.h: ns3::TapBridgeHelper::TapBridgeHelper(ns3::TapBridgeHelper const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::TapBridgeHelper const &', 'arg0')])
@@ -1362,6 +1593,23 @@ def register_Ns3TapBridgeHelper_methods(root_module, cls):
                    [param('std::string', 'n1'), param('ns3::AttributeValue const &', 'v1')])
     return
 
+def register_Ns3UdpClientHelper_methods(root_module, cls):
+    ## udp-client-server-helper.h: ns3::UdpClientHelper::UdpClientHelper(ns3::UdpClientHelper const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::UdpClientHelper const &', 'arg0')])
+    ## udp-client-server-helper.h: ns3::UdpClientHelper::UdpClientHelper() [constructor]
+    cls.add_constructor([])
+    ## udp-client-server-helper.h: ns3::UdpClientHelper::UdpClientHelper(ns3::Ipv4Address ip, uint16_t port) [constructor]
+    cls.add_constructor([param('ns3::Ipv4Address', 'ip'), param('uint16_t', 'port')])
+    ## udp-client-server-helper.h: ns3::ApplicationContainer ns3::UdpClientHelper::Install(ns3::NodeContainer c) [member function]
+    cls.add_method('Install', 
+                   'ns3::ApplicationContainer', 
+                   [param('ns3::NodeContainer', 'c')])
+    ## udp-client-server-helper.h: void ns3::UdpClientHelper::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function]
+    cls.add_method('SetAttribute', 
+                   'void', 
+                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
+    return
+
 def register_Ns3UdpEchoClientHelper_methods(root_module, cls):
     ## udp-echo-helper.h: ns3::UdpEchoClientHelper::UdpEchoClientHelper(ns3::UdpEchoClientHelper const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::UdpEchoClientHelper const &', 'arg0')])
@@ -1426,6 +1674,44 @@ def register_Ns3UdpEchoServerHelper_methods(root_module, cls):
                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
     return
 
+def register_Ns3UdpServerHelper_methods(root_module, cls):
+    ## udp-client-server-helper.h: ns3::UdpServerHelper::UdpServerHelper(ns3::UdpServerHelper const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::UdpServerHelper const &', 'arg0')])
+    ## udp-client-server-helper.h: ns3::UdpServerHelper::UdpServerHelper() [constructor]
+    cls.add_constructor([])
+    ## udp-client-server-helper.h: ns3::UdpServerHelper::UdpServerHelper(uint16_t port) [constructor]
+    cls.add_constructor([param('uint16_t', 'port')])
+    ## udp-client-server-helper.h: ns3::Ptr<ns3::UdpServer> ns3::UdpServerHelper::GetServer() [member function]
+    cls.add_method('GetServer', 
+                   'ns3::Ptr< ns3::UdpServer >', 
+                   [])
+    ## udp-client-server-helper.h: ns3::ApplicationContainer ns3::UdpServerHelper::Install(ns3::NodeContainer c) [member function]
+    cls.add_method('Install', 
+                   'ns3::ApplicationContainer', 
+                   [param('ns3::NodeContainer', 'c')])
+    ## udp-client-server-helper.h: void ns3::UdpServerHelper::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function]
+    cls.add_method('SetAttribute', 
+                   'void', 
+                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
+    return
+
+def register_Ns3UdpTraceClientHelper_methods(root_module, cls):
+    ## udp-client-server-helper.h: ns3::UdpTraceClientHelper::UdpTraceClientHelper(ns3::UdpTraceClientHelper const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::UdpTraceClientHelper const &', 'arg0')])
+    ## udp-client-server-helper.h: ns3::UdpTraceClientHelper::UdpTraceClientHelper() [constructor]
+    cls.add_constructor([])
+    ## udp-client-server-helper.h: ns3::UdpTraceClientHelper::UdpTraceClientHelper(ns3::Ipv4Address ip, uint16_t port, std::string filename) [constructor]
+    cls.add_constructor([param('ns3::Ipv4Address', 'ip'), param('uint16_t', 'port'), param('std::string', 'filename')])
+    ## udp-client-server-helper.h: ns3::ApplicationContainer ns3::UdpTraceClientHelper::Install(ns3::NodeContainer c) [member function]
+    cls.add_method('Install', 
+                   'ns3::ApplicationContainer', 
+                   [param('ns3::NodeContainer', 'c')])
+    ## udp-client-server-helper.h: void ns3::UdpTraceClientHelper::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function]
+    cls.add_method('SetAttribute', 
+                   'void', 
+                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
+    return
+
 def register_Ns3V4PingHelper_methods(root_module, cls):
     ## v4ping-helper.h: ns3::V4PingHelper::V4PingHelper(ns3::V4PingHelper const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::V4PingHelper const &', 'arg0')])
@@ -1446,6 +1732,10 @@ def register_Ns3V4PingHelper_methods(root_module, cls):
                    'ns3::ApplicationContainer', 
                    [param('std::string', 'nodeName')], 
                    is_const=True)
+    ## v4ping-helper.h: void ns3::V4PingHelper::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function]
+    cls.add_method('SetAttribute', 
+                   'void', 
+                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
     return
 
 def register_Ns3WifiHelper_methods(root_module, cls):
@@ -1618,6 +1908,27 @@ def register_Ns3YansWifiPhyHelper_methods(root_module, cls):
                    is_const=True, visibility='private', is_virtual=True)
     return
 
+def register_Ns3AodvHelper_methods(root_module, cls):
+    ## aodv-helper.h: ns3::AodvHelper::AodvHelper(ns3::AodvHelper const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::AodvHelper const &', 'arg0')])
+    ## aodv-helper.h: ns3::AodvHelper::AodvHelper() [constructor]
+    cls.add_constructor([])
+    ## aodv-helper.h: ns3::AodvHelper * ns3::AodvHelper::Copy() const [member function]
+    cls.add_method('Copy', 
+                   'ns3::AodvHelper *', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## aodv-helper.h: ns3::Ptr<ns3::Ipv4RoutingProtocol> ns3::AodvHelper::Create(ns3::Ptr<ns3::Node> node) const [member function]
+    cls.add_method('Create', 
+                   'ns3::Ptr< ns3::Ipv4RoutingProtocol >', 
+                   [param('ns3::Ptr< ns3::Node >', 'node')], 
+                   is_const=True, is_virtual=True)
+    ## aodv-helper.h: void ns3::AodvHelper::Set(std::string name, ns3::AttributeValue const & value) [member function]
+    cls.add_method('Set', 
+                   'void', 
+                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
+    return
+
 def register_Ns3Ipv4GlobalRoutingHelper_methods(root_module, cls):
     ## ipv4-global-routing-helper.h: ns3::Ipv4GlobalRoutingHelper::Ipv4GlobalRoutingHelper() [constructor]
     cls.add_constructor([])
@@ -1806,6 +2117,27 @@ def register_Ns3AthstatsWifiTraceSink_methods(root_module, cls):
                    [param('std::string', 'context'), param('ns3::Mac48Address', 'address')])
     return
 
+def register_Ns3CanvasLocation_methods(root_module, cls):
+    ## canvas-location.h: ns3::CanvasLocation::CanvasLocation(ns3::CanvasLocation const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::CanvasLocation const &', 'arg0')])
+    ## canvas-location.h: ns3::CanvasLocation::CanvasLocation() [constructor]
+    cls.add_constructor([])
+    ## canvas-location.h: ns3::Vector ns3::CanvasLocation::GetLocation() const [member function]
+    cls.add_method('GetLocation', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True)
+    ## canvas-location.h: static ns3::TypeId ns3::CanvasLocation::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## canvas-location.h: void ns3::CanvasLocation::SetLocation(ns3::Vector const & location) [member function]
+    cls.add_method('SetLocation', 
+                   'void', 
+                   [param('ns3::Vector const &', 'location')])
+    return
+
 def register_Ns3MeshStack_methods(root_module, cls):
     ## mesh-stack-installer.h: ns3::MeshStack::MeshStack() [constructor]
     cls.add_constructor([])
@@ -1897,6 +2229,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -1912,6 +2245,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-ILP32/ns3_module_list_routing.py

@@ -26,6 +26,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -62,6 +68,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -128,15 +138,15 @@ def register_Ns3Ipv4ListRouting_methods(root_module, cls):
                    'void', 
                    [param('uint32_t', 'interface'), param('ns3::Ipv4InterfaceAddress', 'address')], 
                    is_virtual=True)
-    ## ipv4-list-routing.h: bool ns3::Ipv4ListRouting::RouteInput(ns3::Ptr<ns3::Packet const> p, ns3::Ipv4Header const & header, ns3::Ptr<const ns3::NetDevice> idev, ns3::Callback<void,ns3::Ptr<ns3::Ipv4Route>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ucb, ns3::Callback<void,ns3::Ptr<ns3::Ipv4MulticastRoute>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> mcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,unsigned int,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> lcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::Socket::SocketErrno,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ecb) [member function]
+    ## ipv4-list-routing.h: bool ns3::Ipv4ListRouting::RouteInput(ns3::Ptr<ns3::Packet const> p, ns3::Ipv4Header const & header, ns3::Ptr<const ns3::NetDevice> idev, ns3::Callback<void, ns3::Ptr<ns3::Ipv4Route>, ns3::Ptr<ns3::Packet const>, ns3::Ipv4Header const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ucb, ns3::Callback<void,ns3::Ptr<ns3::Ipv4MulticastRoute>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> mcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,unsigned int,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> lcb, ns3::Callback<void, ns3::Ptr<ns3::Packet const>, ns3::Ipv4Header const&, ns3::Socket::SocketErrno, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ecb) [member function]
     cls.add_method('RouteInput', 
                    'bool', 
                    [param('ns3::Ptr< ns3::Packet const >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice const >', 'idev'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv4Route >, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ucb'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv4MulticastRoute >, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'mcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'lcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::Socket::SocketErrno, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ecb')], 
                    is_virtual=True)
-    ## ipv4-list-routing.h: ns3::Ptr<ns3::Ipv4Route> ns3::Ipv4ListRouting::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Header const & header, uint32_t oif, ns3::Socket::SocketErrno & sockerr) [member function]
+    ## ipv4-list-routing.h: ns3::Ptr<ns3::Ipv4Route> ns3::Ipv4ListRouting::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Header const & header, ns3::Ptr<ns3::NetDevice> oif, ns3::Socket::SocketErrno & sockerr) [member function]
     cls.add_method('RouteOutput', 
                    'ns3::Ptr< ns3::Ipv4Route >', 
-                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('uint32_t', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice >', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
                    is_virtual=True)
     ## ipv4-list-routing.h: void ns3::Ipv4ListRouting::SetIpv4(ns3::Ptr<ns3::Ipv4> ipv4) [member function]
     cls.add_method('SetIpv4', 
@@ -148,6 +158,11 @@ def register_Ns3Ipv4ListRouting_methods(root_module, cls):
                    'void', 
                    [], 
                    visibility='protected', is_virtual=True)
+    ## ipv4-list-routing.h: void ns3::Ipv4ListRouting::DoStart() [member function]
+    cls.add_method('DoStart', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
     return
 
 def register_Ns3Ipv6ListRouting_methods(root_module, cls):
@@ -210,10 +225,10 @@ def register_Ns3Ipv6ListRouting_methods(root_module, cls):
                    'bool', 
                    [param('ns3::Ptr< ns3::Packet const >', 'p'), param('ns3::Ipv6Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice const >', 'idev'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv6Route >, ns3::Ptr< ns3::Packet const >, ns3::Ipv6Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ucb'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv6MulticastRoute >, ns3::Ptr< ns3::Packet const >, ns3::Ipv6Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'mcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv6Header const &, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'lcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv6Header const &, ns3::Socket::SocketErrno, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ecb')], 
                    is_virtual=True)
-    ## ipv6-list-routing.h: ns3::Ptr<ns3::Ipv6Route> ns3::Ipv6ListRouting::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv6Header const & header, uint32_t oif, ns3::Socket::SocketErrno & sockerr) [member function]
+    ## ipv6-list-routing.h: ns3::Ptr<ns3::Ipv6Route> ns3::Ipv6ListRouting::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv6Header const & header, ns3::Ptr<ns3::NetDevice> oif, ns3::Socket::SocketErrno & sockerr) [member function]
     cls.add_method('RouteOutput', 
                    'ns3::Ptr< ns3::Ipv6Route >', 
-                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv6Header const &', 'header'), param('uint32_t', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv6Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice >', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
                    is_virtual=True)
     ## ipv6-list-routing.h: void ns3::Ipv6ListRouting::SetIpv6(ns3::Ptr<ns3::Ipv6> ipv6) [member function]
     cls.add_method('SetIpv6', 
@@ -232,6 +247,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -247,6 +263,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-ILP32/ns3_module_mesh.py

@@ -7,16 +7,20 @@ def register_types(module):
     module.add_enum('WifiElementId', ['IE11S_MESH_CONFIGURATION', 'IE11S_MESH_ID', 'IE11S_LINK_METRIC_REPORT', 'IE11S_CONGESTION_NOTIFICATION', 'IE11S_PEERING_MANAGEMENT', 'IE11S_SUPP_MBSS_REG_CLASSES_CHANNELS', 'IE11S_MESH_CHANNEL_SWITCH_ANNOUNCEMENT', 'IE11S_MESH_TIM', 'IE11S_AWAKE_WINDOW', 'IE11S_BEACON_TIMING', 'IE11S_MCCAOP_SETUP_REQUEST', 'IE11S_MCCAOP_SETUP_REPLY', 'IE11S_MCCAOP_ADVERTISEMENT', 'IE11S_MCCAOP_RESERVATION_TEARDOWN', 'IE11S_PORTAL_ANNOUNCEMENT', 'IE11S_RANN', 'IE11S_PREQ', 'IE11S_PREP', 'IE11S_PERR', 'IE11S_PROXY_UPDATE', 'IE11S_PROXY_UPDATE_CONFIRMATION', 'IE11S_ABBREVIATED_HANDSHAKE', 'IE11S_MESH_PEERING_PROTOCOL_VERSION'])
     ## mesh-wifi-beacon.h: ns3::MeshWifiBeacon [class]
     module.add_class('MeshWifiBeacon')
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::MeshWifiInterfaceMacPlugin, ns3::empty, ns3::DefaultDeleter<ns3::MeshWifiInterfaceMacPlugin> > [class]
+    module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::MeshWifiInterfaceMacPlugin', 'ns3::empty', 'ns3::DefaultDeleter<ns3::MeshWifiInterfaceMacPlugin>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::WifiInformationElement, ns3::empty, ns3::DefaultDeleter<ns3::WifiInformationElement> > [class]
+    module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::WifiInformationElement', 'ns3::empty', 'ns3::DefaultDeleter<ns3::WifiInformationElement>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
     ## wifi-information-element-vector.h: ns3::WifiInformationElement [class]
-    module.add_class('WifiInformationElement', parent=root_module['ns3::RefCountBase'])
-    ## mesh-wifi-interface-mac-plugin.h: ns3::MeshWifiInterfaceMacPlugin [class]
-    module.add_class('MeshWifiInterfaceMacPlugin', parent=root_module['ns3::RefCountBase'])
+    module.add_class('WifiInformationElement', parent=root_module['ns3::SimpleRefCount< ns3::WifiInformationElement, ns3::empty, ns3::DefaultDeleter<ns3::WifiInformationElement> >'])
     ## wifi-information-element-vector.h: ns3::WifiInformationElementVector [class]
     module.add_class('WifiInformationElementVector', parent=root_module['ns3::Header'])
     ## mesh-l2-routing-protocol.h: ns3::MeshL2RoutingProtocol [class]
     module.add_class('MeshL2RoutingProtocol', parent=root_module['ns3::Object'])
     ## mesh-wifi-interface-mac.h: ns3::MeshWifiInterfaceMac [class]
     module.add_class('MeshWifiInterfaceMac', parent=root_module['ns3::WifiMac'])
+    ## mesh-wifi-interface-mac-plugin.h: ns3::MeshWifiInterfaceMacPlugin [class]
+    module.add_class('MeshWifiInterfaceMacPlugin', parent=root_module['ns3::SimpleRefCount< ns3::MeshWifiInterfaceMacPlugin, ns3::empty, ns3::DefaultDeleter<ns3::MeshWifiInterfaceMacPlugin> >'])
     ## mesh-point-device.h: ns3::MeshPointDevice [class]
     module.add_class('MeshPointDevice', parent=root_module['ns3::NetDevice'])
     
@@ -38,6 +42,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -74,6 +84,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -93,10 +107,10 @@ def register_types_ns3_olsr(module):
 def register_methods(root_module):
     register_Ns3MeshWifiBeacon_methods(root_module, root_module['ns3::MeshWifiBeacon'])
     register_Ns3WifiInformationElement_methods(root_module, root_module['ns3::WifiInformationElement'])
-    register_Ns3MeshWifiInterfaceMacPlugin_methods(root_module, root_module['ns3::MeshWifiInterfaceMacPlugin'])
     register_Ns3WifiInformationElementVector_methods(root_module, root_module['ns3::WifiInformationElementVector'])
     register_Ns3MeshL2RoutingProtocol_methods(root_module, root_module['ns3::MeshL2RoutingProtocol'])
     register_Ns3MeshWifiInterfaceMac_methods(root_module, root_module['ns3::MeshWifiInterfaceMac'])
+    register_Ns3MeshWifiInterfaceMacPlugin_methods(root_module, root_module['ns3::MeshWifiInterfaceMacPlugin'])
     register_Ns3MeshPointDevice_methods(root_module, root_module['ns3::MeshPointDevice'])
     return
 
@@ -122,6 +136,11 @@ def register_Ns3MeshWifiBeacon_methods(root_module, cls):
     cls.add_method('CreatePacket', 
                    'ns3::Ptr< ns3::Packet >', 
                    [])
+    ## mesh-wifi-beacon.h: ns3::Time ns3::MeshWifiBeacon::GetBeaconInterval() const [member function]
+    cls.add_method('GetBeaconInterval', 
+                   'ns3::Time', 
+                   [], 
+                   is_const=True)
     return
 
 def register_Ns3WifiInformationElement_methods(root_module, cls):
@@ -158,33 +177,6 @@ def register_Ns3WifiInformationElement_methods(root_module, cls):
                    is_pure_virtual=True, is_const=True, is_virtual=True)
     return
 
-def register_Ns3MeshWifiInterfaceMacPlugin_methods(root_module, cls):
-    ## mesh-wifi-interface-mac-plugin.h: ns3::MeshWifiInterfaceMacPlugin::MeshWifiInterfaceMacPlugin() [constructor]
-    cls.add_constructor([])
-    ## mesh-wifi-interface-mac-plugin.h: ns3::MeshWifiInterfaceMacPlugin::MeshWifiInterfaceMacPlugin(ns3::MeshWifiInterfaceMacPlugin const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::MeshWifiInterfaceMacPlugin const &', 'arg0')])
-    ## mesh-wifi-interface-mac-plugin.h: bool ns3::MeshWifiInterfaceMacPlugin::Receive(ns3::Ptr<ns3::Packet> packet, ns3::WifiMacHeader const & header) [member function]
-    cls.add_method('Receive', 
-                   'bool', 
-                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::WifiMacHeader const &', 'header')], 
-                   is_pure_virtual=True, is_virtual=True)
-    ## mesh-wifi-interface-mac-plugin.h: void ns3::MeshWifiInterfaceMacPlugin::SetParent(ns3::Ptr<ns3::MeshWifiInterfaceMac> parent) [member function]
-    cls.add_method('SetParent', 
-                   'void', 
-                   [param('ns3::Ptr< ns3::MeshWifiInterfaceMac >', 'parent')], 
-                   is_pure_virtual=True, is_virtual=True)
-    ## mesh-wifi-interface-mac-plugin.h: void ns3::MeshWifiInterfaceMacPlugin::UpdateBeacon(ns3::MeshWifiBeacon & beacon) const [member function]
-    cls.add_method('UpdateBeacon', 
-                   'void', 
-                   [param('ns3::MeshWifiBeacon &', 'beacon')], 
-                   is_pure_virtual=True, is_const=True, is_virtual=True)
-    ## mesh-wifi-interface-mac-plugin.h: bool ns3::MeshWifiInterfaceMacPlugin::UpdateOutcomingFrame(ns3::Ptr<ns3::Packet> packet, ns3::WifiMacHeader & header, ns3::Mac48Address from, ns3::Mac48Address to) [member function]
-    cls.add_method('UpdateOutcomingFrame', 
-                   'bool', 
-                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::WifiMacHeader &', 'header'), param('ns3::Mac48Address', 'from'), param('ns3::Mac48Address', 'to')], 
-                   is_pure_virtual=True, is_virtual=True)
-    return
-
 def register_Ns3WifiInformationElementVector_methods(root_module, cls):
     cls.add_binary_comparison_operator('==')
     ## wifi-information-element-vector.h: ns3::WifiInformationElementVector::WifiInformationElementVector(ns3::WifiInformationElementVector const & arg0) [copy constructor]
@@ -349,6 +341,11 @@ def register_Ns3MeshWifiInterfaceMac_methods(root_module, cls):
                    'ns3::Mac48Address', 
                    [], 
                    is_const=True)
+    ## mesh-wifi-interface-mac.h: ns3::WifiPhyStandard ns3::MeshWifiInterfaceMac::GetPhyStandard() const [member function]
+    cls.add_method('GetPhyStandard', 
+                   'ns3::WifiPhyStandard', 
+                   [], 
+                   is_const=True)
     ## mesh-wifi-interface-mac.h: ns3::Time ns3::MeshWifiInterfaceMac::GetPifs() const [member function]
     cls.add_method('GetPifs', 
                    'ns3::Time', 
@@ -519,6 +516,33 @@ def register_Ns3MeshWifiInterfaceMac_methods(root_module, cls):
                    visibility='private', is_virtual=True)
     return
 
+def register_Ns3MeshWifiInterfaceMacPlugin_methods(root_module, cls):
+    ## mesh-wifi-interface-mac-plugin.h: ns3::MeshWifiInterfaceMacPlugin::MeshWifiInterfaceMacPlugin() [constructor]
+    cls.add_constructor([])
+    ## mesh-wifi-interface-mac-plugin.h: ns3::MeshWifiInterfaceMacPlugin::MeshWifiInterfaceMacPlugin(ns3::MeshWifiInterfaceMacPlugin const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::MeshWifiInterfaceMacPlugin const &', 'arg0')])
+    ## mesh-wifi-interface-mac-plugin.h: bool ns3::MeshWifiInterfaceMacPlugin::Receive(ns3::Ptr<ns3::Packet> packet, ns3::WifiMacHeader const & header) [member function]
+    cls.add_method('Receive', 
+                   'bool', 
+                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::WifiMacHeader const &', 'header')], 
+                   is_pure_virtual=True, is_virtual=True)
+    ## mesh-wifi-interface-mac-plugin.h: void ns3::MeshWifiInterfaceMacPlugin::SetParent(ns3::Ptr<ns3::MeshWifiInterfaceMac> parent) [member function]
+    cls.add_method('SetParent', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::MeshWifiInterfaceMac >', 'parent')], 
+                   is_pure_virtual=True, is_virtual=True)
+    ## mesh-wifi-interface-mac-plugin.h: void ns3::MeshWifiInterfaceMacPlugin::UpdateBeacon(ns3::MeshWifiBeacon & beacon) const [member function]
+    cls.add_method('UpdateBeacon', 
+                   'void', 
+                   [param('ns3::MeshWifiBeacon &', 'beacon')], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
+    ## mesh-wifi-interface-mac-plugin.h: bool ns3::MeshWifiInterfaceMacPlugin::UpdateOutcomingFrame(ns3::Ptr<ns3::Packet> packet, ns3::WifiMacHeader & header, ns3::Mac48Address from, ns3::Mac48Address to) [member function]
+    cls.add_method('UpdateOutcomingFrame', 
+                   'bool', 
+                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::WifiMacHeader &', 'header'), param('ns3::Mac48Address', 'from'), param('ns3::Mac48Address', 'to')], 
+                   is_pure_virtual=True, is_virtual=True)
+    return
+
 def register_Ns3MeshPointDevice_methods(root_module, cls):
     ## mesh-point-device.h: ns3::MeshPointDevice::MeshPointDevice(ns3::MeshPointDevice const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::MeshPointDevice const &', 'arg0')])
@@ -698,6 +722,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -713,6 +738,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-ILP32/ns3_module_mobility.py

@@ -9,16 +9,16 @@ def register_types(module):
     module.add_class('Rectangle')
     ## rectangle.h: ns3::Rectangle::Side [enumeration]
     module.add_enum('Side', ['RIGHT', 'LEFT', 'TOP', 'BOTTOM'], outer_class=root_module['ns3::Rectangle'])
+    ## waypoint.h: ns3::Waypoint [class]
+    module.add_class('Waypoint')
     ## position-allocator.h: ns3::PositionAllocator [class]
     module.add_class('PositionAllocator', parent=root_module['ns3::Object'])
     ## position-allocator.h: ns3::RandomDiscPositionAllocator [class]
     module.add_class('RandomDiscPositionAllocator', parent=root_module['ns3::PositionAllocator'])
     ## position-allocator.h: ns3::RandomRectanglePositionAllocator [class]
     module.add_class('RandomRectanglePositionAllocator', parent=root_module['ns3::PositionAllocator'])
-    ## rectangle.h: ns3::RectangleChecker [class]
-    module.add_class('RectangleChecker', parent=root_module['ns3::AttributeChecker'])
-    ## rectangle.h: ns3::RectangleValue [class]
-    module.add_class('RectangleValue', parent=root_module['ns3::AttributeValue'])
+    ## position-allocator.h: ns3::UniformDiscPositionAllocator [class]
+    module.add_class('UniformDiscPositionAllocator', parent=root_module['ns3::PositionAllocator'])
     ## position-allocator.h: ns3::GridPositionAllocator [class]
     module.add_class('GridPositionAllocator', parent=root_module['ns3::PositionAllocator'])
     ## position-allocator.h: ns3::GridPositionAllocator::LayoutType [enumeration]
@@ -35,6 +35,16 @@ def register_types(module):
     module.add_enum('Mode', ['MODE_DISTANCE', 'MODE_TIME'], outer_class=root_module['ns3::RandomWalk2dMobilityModel'])
     ## random-waypoint-mobility-model.h: ns3::RandomWaypointMobilityModel [class]
     module.add_class('RandomWaypointMobilityModel', parent=root_module['ns3::MobilityModel'])
+    ## rectangle.h: ns3::RectangleChecker [class]
+    module.add_class('RectangleChecker', parent=root_module['ns3::AttributeChecker'])
+    ## rectangle.h: ns3::RectangleValue [class]
+    module.add_class('RectangleValue', parent=root_module['ns3::AttributeValue'])
+    ## waypoint.h: ns3::WaypointChecker [class]
+    module.add_class('WaypointChecker', parent=root_module['ns3::AttributeChecker'])
+    ## waypoint-mobility-model.h: ns3::WaypointMobilityModel [class]
+    module.add_class('WaypointMobilityModel', parent=root_module['ns3::MobilityModel'])
+    ## waypoint.h: ns3::WaypointValue [class]
+    module.add_class('WaypointValue', parent=root_module['ns3::AttributeValue'])
     ## constant-acceleration-mobility-model.h: ns3::ConstantAccelerationMobilityModel [class]
     module.add_class('ConstantAccelerationMobilityModel', parent=root_module['ns3::MobilityModel'])
     ## constant-position-mobility-model.h: ns3::ConstantPositionMobilityModel [class]
@@ -62,6 +72,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -98,6 +114,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -117,17 +137,22 @@ def register_types_ns3_olsr(module):
 def register_methods(root_module):
     register_Ns3ConstantVelocityHelper_methods(root_module, root_module['ns3::ConstantVelocityHelper'])
     register_Ns3Rectangle_methods(root_module, root_module['ns3::Rectangle'])
+    register_Ns3Waypoint_methods(root_module, root_module['ns3::Waypoint'])
     register_Ns3PositionAllocator_methods(root_module, root_module['ns3::PositionAllocator'])
     register_Ns3RandomDiscPositionAllocator_methods(root_module, root_module['ns3::RandomDiscPositionAllocator'])
     register_Ns3RandomRectanglePositionAllocator_methods(root_module, root_module['ns3::RandomRectanglePositionAllocator'])
-    register_Ns3RectangleChecker_methods(root_module, root_module['ns3::RectangleChecker'])
-    register_Ns3RectangleValue_methods(root_module, root_module['ns3::RectangleValue'])
+    register_Ns3UniformDiscPositionAllocator_methods(root_module, root_module['ns3::UniformDiscPositionAllocator'])
     register_Ns3GridPositionAllocator_methods(root_module, root_module['ns3::GridPositionAllocator'])
     register_Ns3ListPositionAllocator_methods(root_module, root_module['ns3::ListPositionAllocator'])
     register_Ns3MobilityModel_methods(root_module, root_module['ns3::MobilityModel'])
     register_Ns3RandomDirection2dMobilityModel_methods(root_module, root_module['ns3::RandomDirection2dMobilityModel'])
     register_Ns3RandomWalk2dMobilityModel_methods(root_module, root_module['ns3::RandomWalk2dMobilityModel'])
     register_Ns3RandomWaypointMobilityModel_methods(root_module, root_module['ns3::RandomWaypointMobilityModel'])
+    register_Ns3RectangleChecker_methods(root_module, root_module['ns3::RectangleChecker'])
+    register_Ns3RectangleValue_methods(root_module, root_module['ns3::RectangleValue'])
+    register_Ns3WaypointChecker_methods(root_module, root_module['ns3::WaypointChecker'])
+    register_Ns3WaypointMobilityModel_methods(root_module, root_module['ns3::WaypointMobilityModel'])
+    register_Ns3WaypointValue_methods(root_module, root_module['ns3::WaypointValue'])
     register_Ns3ConstantAccelerationMobilityModel_methods(root_module, root_module['ns3::ConstantAccelerationMobilityModel'])
     register_Ns3ConstantPositionMobilityModel_methods(root_module, root_module['ns3::ConstantPositionMobilityModel'])
     register_Ns3ConstantVelocityMobilityModel_methods(root_module, root_module['ns3::ConstantVelocityMobilityModel'])
@@ -214,6 +239,20 @@ def register_Ns3Rectangle_methods(root_module, cls):
     cls.add_instance_attribute('yMin', 'double', is_const=False)
     return
 
+def register_Ns3Waypoint_methods(root_module, cls):
+    cls.add_output_stream_operator()
+    ## waypoint.h: ns3::Waypoint::Waypoint(ns3::Waypoint const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::Waypoint const &', 'arg0')])
+    ## waypoint.h: ns3::Waypoint::Waypoint(ns3::Time const & waypointTime, ns3::Vector const & waypointPosition) [constructor]
+    cls.add_constructor([param('ns3::Time const &', 'waypointTime'), param('ns3::Vector const &', 'waypointPosition')])
+    ## waypoint.h: ns3::Waypoint::Waypoint() [constructor]
+    cls.add_constructor([])
+    ## waypoint.h: ns3::Waypoint::position [variable]
+    cls.add_instance_attribute('position', 'ns3::Vector', is_const=False)
+    ## waypoint.h: ns3::Waypoint::time [variable]
+    cls.add_instance_attribute('time', 'ns3::Time', is_const=False)
+    return
+
 def register_Ns3PositionAllocator_methods(root_module, cls):
     ## position-allocator.h: ns3::PositionAllocator::PositionAllocator(ns3::PositionAllocator const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::PositionAllocator const &', 'arg0')])
@@ -289,44 +328,33 @@ def register_Ns3RandomRectanglePositionAllocator_methods(root_module, cls):
                    [param('ns3::RandomVariable', 'y')])
     return
 
-def register_Ns3RectangleChecker_methods(root_module, cls):
-    ## rectangle.h: ns3::RectangleChecker::RectangleChecker() [constructor]
+def register_Ns3UniformDiscPositionAllocator_methods(root_module, cls):
+    ## position-allocator.h: ns3::UniformDiscPositionAllocator::UniformDiscPositionAllocator(ns3::UniformDiscPositionAllocator const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::UniformDiscPositionAllocator const &', 'arg0')])
+    ## position-allocator.h: ns3::UniformDiscPositionAllocator::UniformDiscPositionAllocator() [constructor]
     cls.add_constructor([])
-    ## rectangle.h: ns3::RectangleChecker::RectangleChecker(ns3::RectangleChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::RectangleChecker const &', 'arg0')])
-    return
-
-def register_Ns3RectangleValue_methods(root_module, cls):
-    ## rectangle.h: ns3::RectangleValue::RectangleValue() [constructor]
-    cls.add_constructor([])
-    ## rectangle.h: ns3::RectangleValue::RectangleValue(ns3::RectangleValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::RectangleValue const &', 'arg0')])
-    ## rectangle.h: ns3::RectangleValue::RectangleValue(ns3::Rectangle const & value) [constructor]
-    cls.add_constructor([param('ns3::Rectangle const &', 'value')])
-    ## rectangle.h: ns3::Ptr<ns3::AttributeValue> ns3::RectangleValue::Copy() const [member function]
-    cls.add_method('Copy', 
-                   'ns3::Ptr< ns3::AttributeValue >', 
+    ## position-allocator.h: ns3::Vector ns3::UniformDiscPositionAllocator::GetNext() const [member function]
+    cls.add_method('GetNext', 
+                   'ns3::Vector', 
                    [], 
                    is_const=True, is_virtual=True)
-    ## rectangle.h: bool ns3::RectangleValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
-    cls.add_method('DeserializeFromString', 
-                   'bool', 
-                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
-                   is_virtual=True)
-    ## rectangle.h: ns3::Rectangle ns3::RectangleValue::Get() const [member function]
-    cls.add_method('Get', 
-                   'ns3::Rectangle', 
+    ## position-allocator.h: static ns3::TypeId ns3::UniformDiscPositionAllocator::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
                    [], 
-                   is_const=True)
-    ## rectangle.h: std::string ns3::RectangleValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
-    cls.add_method('SerializeToString', 
-                   'std::string', 
-                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
-                   is_const=True, is_virtual=True)
-    ## rectangle.h: void ns3::RectangleValue::Set(ns3::Rectangle const & value) [member function]
-    cls.add_method('Set', 
+                   is_static=True)
+    ## position-allocator.h: void ns3::UniformDiscPositionAllocator::SetRho(double rho) [member function]
+    cls.add_method('SetRho', 
                    'void', 
-                   [param('ns3::Rectangle const &', 'value')])
+                   [param('double', 'rho')])
+    ## position-allocator.h: void ns3::UniformDiscPositionAllocator::SetX(double x) [member function]
+    cls.add_method('SetX', 
+                   'void', 
+                   [param('double', 'x')])
+    ## position-allocator.h: void ns3::UniformDiscPositionAllocator::SetY(double y) [member function]
+    cls.add_method('SetY', 
+                   'void', 
+                   [param('double', 'y')])
     return
 
 def register_Ns3GridPositionAllocator_methods(root_module, cls):
@@ -473,10 +501,10 @@ def register_Ns3MobilityModel_methods(root_module, cls):
     return
 
 def register_Ns3RandomDirection2dMobilityModel_methods(root_module, cls):
-    ## random-direction-2d-mobility-model.h: ns3::RandomDirection2dMobilityModel::RandomDirection2dMobilityModel(ns3::RandomDirection2dMobilityModel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::RandomDirection2dMobilityModel const &', 'arg0')])
     ## random-direction-2d-mobility-model.h: ns3::RandomDirection2dMobilityModel::RandomDirection2dMobilityModel() [constructor]
     cls.add_constructor([])
+    ## random-direction-2d-mobility-model.h: ns3::RandomDirection2dMobilityModel::RandomDirection2dMobilityModel(ns3::RandomDirection2dMobilityModel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::RandomDirection2dMobilityModel const &', 'arg0')])
     ## random-direction-2d-mobility-model.h: static ns3::TypeId ns3::RandomDirection2dMobilityModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -502,13 +530,18 @@ def register_Ns3RandomDirection2dMobilityModel_methods(root_module, cls):
                    'void', 
                    [param('ns3::Vector const &', 'position')], 
                    visibility='private', is_virtual=True)
+    ## random-direction-2d-mobility-model.h: void ns3::RandomDirection2dMobilityModel::DoStart() [member function]
+    cls.add_method('DoStart', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
     return
 
 def register_Ns3RandomWalk2dMobilityModel_methods(root_module, cls):
-    ## random-walk-2d-mobility-model.h: ns3::RandomWalk2dMobilityModel::RandomWalk2dMobilityModel(ns3::RandomWalk2dMobilityModel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::RandomWalk2dMobilityModel const &', 'arg0')])
     ## random-walk-2d-mobility-model.h: ns3::RandomWalk2dMobilityModel::RandomWalk2dMobilityModel() [constructor]
     cls.add_constructor([])
+    ## random-walk-2d-mobility-model.h: ns3::RandomWalk2dMobilityModel::RandomWalk2dMobilityModel(ns3::RandomWalk2dMobilityModel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::RandomWalk2dMobilityModel const &', 'arg0')])
     ## random-walk-2d-mobility-model.h: static ns3::TypeId ns3::RandomWalk2dMobilityModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -534,18 +567,28 @@ def register_Ns3RandomWalk2dMobilityModel_methods(root_module, cls):
                    'void', 
                    [param('ns3::Vector const &', 'position')], 
                    visibility='private', is_virtual=True)
+    ## random-walk-2d-mobility-model.h: void ns3::RandomWalk2dMobilityModel::DoStart() [member function]
+    cls.add_method('DoStart', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
     return
 
 def register_Ns3RandomWaypointMobilityModel_methods(root_module, cls):
-    ## random-waypoint-mobility-model.h: ns3::RandomWaypointMobilityModel::RandomWaypointMobilityModel(ns3::RandomWaypointMobilityModel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::RandomWaypointMobilityModel const &', 'arg0')])
     ## random-waypoint-mobility-model.h: ns3::RandomWaypointMobilityModel::RandomWaypointMobilityModel() [constructor]
     cls.add_constructor([])
+    ## random-waypoint-mobility-model.h: ns3::RandomWaypointMobilityModel::RandomWaypointMobilityModel(ns3::RandomWaypointMobilityModel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::RandomWaypointMobilityModel const &', 'arg0')])
     ## random-waypoint-mobility-model.h: static ns3::TypeId ns3::RandomWaypointMobilityModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
                    [], 
                    is_static=True)
+    ## random-waypoint-mobility-model.h: void ns3::RandomWaypointMobilityModel::DoStart() [member function]
+    cls.add_method('DoStart', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
     ## random-waypoint-mobility-model.h: ns3::Vector ns3::RandomWaypointMobilityModel::DoGetPosition() const [member function]
     cls.add_method('DoGetPosition', 
                    'ns3::Vector', 
@@ -563,6 +606,136 @@ def register_Ns3RandomWaypointMobilityModel_methods(root_module, cls):
                    visibility='private', is_virtual=True)
     return
 
+def register_Ns3RectangleChecker_methods(root_module, cls):
+    ## rectangle.h: ns3::RectangleChecker::RectangleChecker() [constructor]
+    cls.add_constructor([])
+    ## rectangle.h: ns3::RectangleChecker::RectangleChecker(ns3::RectangleChecker const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::RectangleChecker const &', 'arg0')])
+    return
+
+def register_Ns3RectangleValue_methods(root_module, cls):
+    ## rectangle.h: ns3::RectangleValue::RectangleValue() [constructor]
+    cls.add_constructor([])
+    ## rectangle.h: ns3::RectangleValue::RectangleValue(ns3::RectangleValue const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::RectangleValue const &', 'arg0')])
+    ## rectangle.h: ns3::RectangleValue::RectangleValue(ns3::Rectangle const & value) [constructor]
+    cls.add_constructor([param('ns3::Rectangle const &', 'value')])
+    ## rectangle.h: ns3::Ptr<ns3::AttributeValue> ns3::RectangleValue::Copy() const [member function]
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## rectangle.h: bool ns3::RectangleValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_virtual=True)
+    ## rectangle.h: ns3::Rectangle ns3::RectangleValue::Get() const [member function]
+    cls.add_method('Get', 
+                   'ns3::Rectangle', 
+                   [], 
+                   is_const=True)
+    ## rectangle.h: std::string ns3::RectangleValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, is_virtual=True)
+    ## rectangle.h: void ns3::RectangleValue::Set(ns3::Rectangle const & value) [member function]
+    cls.add_method('Set', 
+                   'void', 
+                   [param('ns3::Rectangle const &', 'value')])
+    return
+
+def register_Ns3WaypointChecker_methods(root_module, cls):
+    ## waypoint.h: ns3::WaypointChecker::WaypointChecker() [constructor]
+    cls.add_constructor([])
+    ## waypoint.h: ns3::WaypointChecker::WaypointChecker(ns3::WaypointChecker const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::WaypointChecker const &', 'arg0')])
+    return
+
+def register_Ns3WaypointMobilityModel_methods(root_module, cls):
+    ## waypoint-mobility-model.h: ns3::WaypointMobilityModel::WaypointMobilityModel(ns3::WaypointMobilityModel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::WaypointMobilityModel const &', 'arg0')])
+    ## waypoint-mobility-model.h: ns3::WaypointMobilityModel::WaypointMobilityModel() [constructor]
+    cls.add_constructor([])
+    ## waypoint-mobility-model.h: void ns3::WaypointMobilityModel::AddWaypoint(ns3::Waypoint const & waypoint) [member function]
+    cls.add_method('AddWaypoint', 
+                   'void', 
+                   [param('ns3::Waypoint const &', 'waypoint')])
+    ## waypoint-mobility-model.h: void ns3::WaypointMobilityModel::EndMobility() [member function]
+    cls.add_method('EndMobility', 
+                   'void', 
+                   [])
+    ## waypoint-mobility-model.h: ns3::Waypoint ns3::WaypointMobilityModel::GetNextWaypoint() const [member function]
+    cls.add_method('GetNextWaypoint', 
+                   'ns3::Waypoint', 
+                   [], 
+                   is_const=True)
+    ## waypoint-mobility-model.h: static ns3::TypeId ns3::WaypointMobilityModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## waypoint-mobility-model.h: uint32_t ns3::WaypointMobilityModel::WaypointsLeft() const [member function]
+    cls.add_method('WaypointsLeft', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
+    ## waypoint-mobility-model.h: void ns3::WaypointMobilityModel::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
+    ## waypoint-mobility-model.h: ns3::Vector ns3::WaypointMobilityModel::DoGetPosition() const [member function]
+    cls.add_method('DoGetPosition', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, visibility='private', is_virtual=True)
+    ## waypoint-mobility-model.h: ns3::Vector ns3::WaypointMobilityModel::DoGetVelocity() const [member function]
+    cls.add_method('DoGetVelocity', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, visibility='private', is_virtual=True)
+    ## waypoint-mobility-model.h: void ns3::WaypointMobilityModel::DoSetPosition(ns3::Vector const & position) [member function]
+    cls.add_method('DoSetPosition', 
+                   'void', 
+                   [param('ns3::Vector const &', 'position')], 
+                   visibility='private', is_virtual=True)
+    return
+
+def register_Ns3WaypointValue_methods(root_module, cls):
+    ## waypoint.h: ns3::WaypointValue::WaypointValue() [constructor]
+    cls.add_constructor([])
+    ## waypoint.h: ns3::WaypointValue::WaypointValue(ns3::WaypointValue const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::WaypointValue const &', 'arg0')])
+    ## waypoint.h: ns3::WaypointValue::WaypointValue(ns3::Waypoint const & value) [constructor]
+    cls.add_constructor([param('ns3::Waypoint const &', 'value')])
+    ## waypoint.h: ns3::Ptr<ns3::AttributeValue> ns3::WaypointValue::Copy() const [member function]
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## waypoint.h: bool ns3::WaypointValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_virtual=True)
+    ## waypoint.h: ns3::Waypoint ns3::WaypointValue::Get() const [member function]
+    cls.add_method('Get', 
+                   'ns3::Waypoint', 
+                   [], 
+                   is_const=True)
+    ## waypoint.h: std::string ns3::WaypointValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, is_virtual=True)
+    ## waypoint.h: void ns3::WaypointValue::Set(ns3::Waypoint const & value) [member function]
+    cls.add_method('Set', 
+                   'void', 
+                   [param('ns3::Waypoint const &', 'value')])
+    return
+
 def register_Ns3ConstantAccelerationMobilityModel_methods(root_module, cls):
     ## constant-acceleration-mobility-model.h: ns3::ConstantAccelerationMobilityModel::ConstantAccelerationMobilityModel(ns3::ConstantAccelerationMobilityModel const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::ConstantAccelerationMobilityModel const &', 'arg0')])
@@ -703,9 +876,14 @@ def register_functions(root_module):
     module.add_function('MakeRectangleChecker', 
                         'ns3::Ptr< ns3::AttributeChecker const >', 
                         [])
+    ## waypoint.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeWaypointChecker() [free function]
+    module.add_function('MakeWaypointChecker', 
+                        'ns3::Ptr< ns3::AttributeChecker const >', 
+                        [])
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -721,6 +899,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-ILP32/ns3_module_nix_vector_routing.py

@@ -30,6 +30,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -66,6 +72,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -129,15 +139,15 @@ def register_Ns3Ipv4NixVectorRouting_methods(root_module, cls):
                    'void', 
                    [param('uint32_t', 'interface'), param('ns3::Ipv4InterfaceAddress', 'address')], 
                    visibility='private', is_virtual=True)
-    ## ipv4-nix-vector-routing.h: bool ns3::Ipv4NixVectorRouting::RouteInput(ns3::Ptr<ns3::Packet const> p, ns3::Ipv4Header const & header, ns3::Ptr<const ns3::NetDevice> idev, ns3::Callback<void,ns3::Ptr<ns3::Ipv4Route>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ucb, ns3::Callback<void,ns3::Ptr<ns3::Ipv4MulticastRoute>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> mcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,unsigned int,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> lcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::Socket::SocketErrno,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ecb) [member function]
+    ## ipv4-nix-vector-routing.h: bool ns3::Ipv4NixVectorRouting::RouteInput(ns3::Ptr<ns3::Packet const> p, ns3::Ipv4Header const & header, ns3::Ptr<const ns3::NetDevice> idev, ns3::Callback<void, ns3::Ptr<ns3::Ipv4Route>, ns3::Ptr<ns3::Packet const>, ns3::Ipv4Header const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ucb, ns3::Callback<void,ns3::Ptr<ns3::Ipv4MulticastRoute>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> mcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,unsigned int,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> lcb, ns3::Callback<void, ns3::Ptr<ns3::Packet const>, ns3::Ipv4Header const&, ns3::Socket::SocketErrno, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ecb) [member function]
     cls.add_method('RouteInput', 
                    'bool', 
                    [param('ns3::Ptr< ns3::Packet const >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice const >', 'idev'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv4Route >, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ucb'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv4MulticastRoute >, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'mcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'lcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::Socket::SocketErrno, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ecb')], 
                    visibility='private', is_virtual=True)
-    ## ipv4-nix-vector-routing.h: ns3::Ptr<ns3::Ipv4Route> ns3::Ipv4NixVectorRouting::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Header const & header, uint32_t oif, ns3::Socket::SocketErrno & sockerr) [member function]
+    ## ipv4-nix-vector-routing.h: ns3::Ptr<ns3::Ipv4Route> ns3::Ipv4NixVectorRouting::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Header const & header, ns3::Ptr<ns3::NetDevice> oif, ns3::Socket::SocketErrno & sockerr) [member function]
     cls.add_method('RouteOutput', 
                    'ns3::Ptr< ns3::Ipv4Route >', 
-                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('uint32_t', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice >', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
                    visibility='private', is_virtual=True)
     ## ipv4-nix-vector-routing.h: void ns3::Ipv4NixVectorRouting::SetIpv4(ns3::Ptr<ns3::Ipv4> ipv4) [member function]
     cls.add_method('SetIpv4', 
@@ -151,6 +161,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -166,6 +177,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-ILP32/ns3_module_olsr.py

@@ -30,6 +30,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -66,6 +72,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -109,6 +119,8 @@ def register_types_ns3_olsr(module):
     module.add_class('NeighborTuple')
     ## olsr-repositories.h: ns3::olsr::NeighborTuple::Status [enumeration]
     module.add_enum('Status', ['STATUS_NOT_SYM', 'STATUS_SYM'], outer_class=root_module['ns3::olsr::NeighborTuple'])
+    ## olsr-routing-protocol.h: ns3::olsr::OlsrMprTestCase [class]
+    module.add_class('OlsrMprTestCase', parent=root_module['ns3::TestCase'])
     ## olsr-header.h: ns3::olsr::PacketHeader [class]
     module.add_class('PacketHeader', parent=root_module['ns3::Header'])
     ## olsr-routing-protocol.h: ns3::olsr::RoutingProtocol [class]
@@ -127,6 +139,9 @@ def register_types_ns3_olsr(module):
     typehandlers.add_type_alias('std::vector< ns3::olsr::NeighborTuple, std::allocator< ns3::olsr::NeighborTuple > >', 'ns3::olsr::NeighborSet')
     typehandlers.add_type_alias('std::vector< ns3::olsr::NeighborTuple, std::allocator< ns3::olsr::NeighborTuple > >*', 'ns3::olsr::NeighborSet*')
     typehandlers.add_type_alias('std::vector< ns3::olsr::NeighborTuple, std::allocator< ns3::olsr::NeighborTuple > >&', 'ns3::olsr::NeighborSet&')
+    typehandlers.add_type_alias('std::vector< ns3::olsr::LinkTuple, std::allocator< ns3::olsr::LinkTuple > >', 'ns3::olsr::LinkSet')
+    typehandlers.add_type_alias('std::vector< ns3::olsr::LinkTuple, std::allocator< ns3::olsr::LinkTuple > >*', 'ns3::olsr::LinkSet*')
+    typehandlers.add_type_alias('std::vector< ns3::olsr::LinkTuple, std::allocator< ns3::olsr::LinkTuple > >&', 'ns3::olsr::LinkSet&')
     typehandlers.add_type_alias('std::set< ns3::Ipv4Address, std::less< ns3::Ipv4Address >, std::allocator< ns3::Ipv4Address > >', 'ns3::olsr::MprSet')
     typehandlers.add_type_alias('std::set< ns3::Ipv4Address, std::less< ns3::Ipv4Address >, std::allocator< ns3::Ipv4Address > >*', 'ns3::olsr::MprSet*')
     typehandlers.add_type_alias('std::set< ns3::Ipv4Address, std::less< ns3::Ipv4Address >, std::allocator< ns3::Ipv4Address > >&', 'ns3::olsr::MprSet&')
@@ -145,9 +160,6 @@ def register_types_ns3_olsr(module):
     typehandlers.add_type_alias('std::vector< ns3::olsr::TwoHopNeighborTuple, std::allocator< ns3::olsr::TwoHopNeighborTuple > >', 'ns3::olsr::TwoHopNeighborSet')
     typehandlers.add_type_alias('std::vector< ns3::olsr::TwoHopNeighborTuple, std::allocator< ns3::olsr::TwoHopNeighborTuple > >*', 'ns3::olsr::TwoHopNeighborSet*')
     typehandlers.add_type_alias('std::vector< ns3::olsr::TwoHopNeighborTuple, std::allocator< ns3::olsr::TwoHopNeighborTuple > >&', 'ns3::olsr::TwoHopNeighborSet&')
-    typehandlers.add_type_alias('std::vector< ns3::olsr::LinkTuple, std::allocator< ns3::olsr::LinkTuple > >', 'ns3::olsr::LinkSet')
-    typehandlers.add_type_alias('std::vector< ns3::olsr::LinkTuple, std::allocator< ns3::olsr::LinkTuple > >*', 'ns3::olsr::LinkSet*')
-    typehandlers.add_type_alias('std::vector< ns3::olsr::LinkTuple, std::allocator< ns3::olsr::LinkTuple > >&', 'ns3::olsr::LinkSet&')
 
 def register_methods(root_module):
     register_Ns3OlsrState_methods(root_module, root_module['ns3::OlsrState'])
@@ -163,6 +175,7 @@ def register_methods(root_module):
     register_Ns3OlsrMessageHeaderTc_methods(root_module, root_module['ns3::olsr::MessageHeader::Tc'])
     register_Ns3OlsrMprSelectorTuple_methods(root_module, root_module['ns3::olsr::MprSelectorTuple'])
     register_Ns3OlsrNeighborTuple_methods(root_module, root_module['ns3::olsr::NeighborTuple'])
+    register_Ns3OlsrOlsrMprTestCase_methods(root_module, root_module['ns3::olsr::OlsrMprTestCase'])
     register_Ns3OlsrPacketHeader_methods(root_module, root_module['ns3::olsr::PacketHeader'])
     register_Ns3OlsrRoutingProtocol_methods(root_module, root_module['ns3::olsr::RoutingProtocol'])
     register_Ns3OlsrRoutingTableEntry_methods(root_module, root_module['ns3::olsr::RoutingTableEntry'])
@@ -301,6 +314,11 @@ def register_Ns3OlsrState_methods(root_module, cls):
                    'ns3::olsr::MprSelectorSet const &', 
                    [], 
                    is_const=True)
+    ## olsr-state.h: ns3::olsr::MprSet ns3::OlsrState::GetMprSet() const [member function]
+    cls.add_method('GetMprSet', 
+                   'ns3::olsr::MprSet', 
+                   [], 
+                   is_const=True)
     ## olsr-state.h: ns3::olsr::NeighborSet const & ns3::OlsrState::GetNeighbors() const [member function]
     cls.add_method('GetNeighbors', 
                    'ns3::olsr::NeighborSet const &', 
@@ -719,6 +737,16 @@ def register_Ns3OlsrNeighborTuple_methods(root_module, cls):
     cls.add_instance_attribute('willingness', 'uint8_t', is_const=False)
     return
 
+def register_Ns3OlsrOlsrMprTestCase_methods(root_module, cls):
+    ## olsr-routing-protocol.h: ns3::olsr::OlsrMprTestCase::OlsrMprTestCase() [constructor]
+    cls.add_constructor([])
+    ## olsr-routing-protocol.h: bool ns3::olsr::OlsrMprTestCase::DoRun() [member function]
+    cls.add_method('DoRun', 
+                   'bool', 
+                   [], 
+                   is_virtual=True)
+    return
+
 def register_Ns3OlsrPacketHeader_methods(root_module, cls):
     cls.add_output_stream_operator()
     ## olsr-header.h: ns3::olsr::PacketHeader::PacketHeader(ns3::olsr::PacketHeader const & arg0) [copy constructor]
@@ -780,6 +808,10 @@ def register_Ns3OlsrRoutingProtocol_methods(root_module, cls):
     cls.add_constructor([param('ns3::olsr::RoutingProtocol const &', 'arg0')])
     ## olsr-routing-protocol.h: ns3::olsr::RoutingProtocol::RoutingProtocol() [constructor]
     cls.add_constructor([])
+    ## olsr-routing-protocol.h: void ns3::olsr::RoutingProtocol::Dump() [member function]
+    cls.add_method('Dump', 
+                   'void', 
+                   [])
     ## olsr-routing-protocol.h: static ns3::TypeId ns3::olsr::RoutingProtocol::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -789,6 +821,11 @@ def register_Ns3OlsrRoutingProtocol_methods(root_module, cls):
     cls.add_method('SetMainInterface', 
                    'void', 
                    [param('uint32_t', 'interface')])
+    ## olsr-routing-protocol.h: void ns3::olsr::RoutingProtocol::DoStart() [member function]
+    cls.add_method('DoStart', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
     ## olsr-routing-protocol.h: void ns3::olsr::RoutingProtocol::DoDispose() [member function]
     cls.add_method('DoDispose', 
                    'void', 
@@ -814,15 +851,15 @@ def register_Ns3OlsrRoutingProtocol_methods(root_module, cls):
                    'void', 
                    [param('uint32_t', 'interface'), param('ns3::Ipv4InterfaceAddress', 'address')], 
                    visibility='private', is_virtual=True)
-    ## olsr-routing-protocol.h: bool ns3::olsr::RoutingProtocol::RouteInput(ns3::Ptr<ns3::Packet const> p, ns3::Ipv4Header const & header, ns3::Ptr<const ns3::NetDevice> idev, ns3::Callback<void,ns3::Ptr<ns3::Ipv4Route>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ucb, ns3::Callback<void,ns3::Ptr<ns3::Ipv4MulticastRoute>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> mcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,unsigned int,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> lcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::Socket::SocketErrno,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ecb) [member function]
+    ## olsr-routing-protocol.h: bool ns3::olsr::RoutingProtocol::RouteInput(ns3::Ptr<ns3::Packet const> p, ns3::Ipv4Header const & header, ns3::Ptr<const ns3::NetDevice> idev, ns3::Callback<void, ns3::Ptr<ns3::Ipv4Route>, ns3::Ptr<ns3::Packet const>, ns3::Ipv4Header const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ucb, ns3::Callback<void,ns3::Ptr<ns3::Ipv4MulticastRoute>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> mcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,unsigned int,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> lcb, ns3::Callback<void, ns3::Ptr<ns3::Packet const>, ns3::Ipv4Header const&, ns3::Socket::SocketErrno, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ecb) [member function]
     cls.add_method('RouteInput', 
                    'bool', 
                    [param('ns3::Ptr< ns3::Packet const >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice const >', 'idev'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv4Route >, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ucb'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv4MulticastRoute >, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'mcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'lcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::Socket::SocketErrno, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ecb')], 
                    visibility='private', is_virtual=True)
-    ## olsr-routing-protocol.h: ns3::Ptr<ns3::Ipv4Route> ns3::olsr::RoutingProtocol::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Header const & header, uint32_t oif, ns3::Socket::SocketErrno & sockerr) [member function]
+    ## olsr-routing-protocol.h: ns3::Ptr<ns3::Ipv4Route> ns3::olsr::RoutingProtocol::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Header const & header, ns3::Ptr<ns3::NetDevice> oif, ns3::Socket::SocketErrno & sockerr) [member function]
     cls.add_method('RouteOutput', 
                    'ns3::Ptr< ns3::Ipv4Route >', 
-                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('uint32_t', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice >', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
                    visibility='private', is_virtual=True)
     ## olsr-routing-protocol.h: void ns3::olsr::RoutingProtocol::SetIpv4(ns3::Ptr<ns3::Ipv4> ipv4) [member function]
     cls.add_method('SetIpv4', 
@@ -883,6 +920,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -898,6 +936,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-ILP32/ns3_module_onoff.py

@@ -24,6 +24,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -60,6 +66,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -116,6 +126,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -131,6 +142,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-ILP32/ns3_module_packet_sink.py

@@ -24,6 +24,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -60,6 +66,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -117,6 +127,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -132,6 +143,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-ILP32/ns3_module_ping6.py

@@ -24,6 +24,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -60,6 +66,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -102,6 +112,10 @@ def register_Ns3Ping6_methods(root_module, cls):
     cls.add_method('SetRemote', 
                    'void', 
                    [param('ns3::Ipv6Address', 'ipv6')])
+    ## ping6.h: void ns3::Ping6::SetRouters(std::vector<ns3::Ipv6Address, std::allocator<ns3::Ipv6Address> > routers) [member function]
+    cls.add_method('SetRouters', 
+                   'void', 
+                   [param('std::vector< ns3::Ipv6Address >', 'routers')])
     ## ping6.h: void ns3::Ping6::DoDispose() [member function]
     cls.add_method('DoDispose', 
                    'void', 
@@ -124,6 +138,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -139,6 +154,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-ILP32/ns3_module_point_to_point.py

@@ -28,6 +28,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -64,6 +70,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -101,6 +111,10 @@ def register_Ns3PppHeader_methods(root_module, cls):
                    'ns3::TypeId', 
                    [], 
                    is_const=True, is_virtual=True)
+    ## ppp-header.h: uint16_t ns3::PppHeader::GetProtocol() [member function]
+    cls.add_method('GetProtocol', 
+                   'uint16_t', 
+                   [])
     ## ppp-header.h: uint32_t ns3::PppHeader::GetSerializedSize() const [member function]
     cls.add_method('GetSerializedSize', 
                    'uint32_t', 
@@ -121,6 +135,10 @@ def register_Ns3PppHeader_methods(root_module, cls):
                    'void', 
                    [param('ns3::Buffer::Iterator', 'start')], 
                    is_const=True, is_virtual=True)
+    ## ppp-header.h: void ns3::PppHeader::SetProtocol(uint16_t protocol) [member function]
+    cls.add_method('SetProtocol', 
+                   'void', 
+                   [param('uint16_t', 'protocol')])
     return
 
 def register_Ns3PointToPointChannel_methods(root_module, cls):
@@ -333,6 +351,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -348,6 +367,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-ILP32/ns3_module_radvd.py

@@ -3,12 +3,16 @@ from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandler
 def register_types(module):
     root_module = module.get_root()
     
-    ## radvd-interface.h: ns3::RadvdInterface [class]
-    module.add_class('RadvdInterface', parent=root_module['ns3::RefCountBase'])
-    ## radvd-prefix.h: ns3::RadvdPrefix [class]
-    module.add_class('RadvdPrefix', parent=root_module['ns3::RefCountBase'])
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::RadvdInterface, ns3::empty, ns3::DefaultDeleter<ns3::RadvdInterface> > [class]
+    module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::RadvdInterface', 'ns3::empty', 'ns3::DefaultDeleter<ns3::RadvdInterface>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::RadvdPrefix, ns3::empty, ns3::DefaultDeleter<ns3::RadvdPrefix> > [class]
+    module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::RadvdPrefix', 'ns3::empty', 'ns3::DefaultDeleter<ns3::RadvdPrefix>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
     ## radvd.h: ns3::Radvd [class]
     module.add_class('Radvd', parent=root_module['ns3::Application'])
+    ## radvd-interface.h: ns3::RadvdInterface [class]
+    module.add_class('RadvdInterface', parent=root_module['ns3::SimpleRefCount< ns3::RadvdInterface, ns3::empty, ns3::DefaultDeleter<ns3::RadvdInterface> >'])
+    ## radvd-prefix.h: ns3::RadvdPrefix [class]
+    module.add_class('RadvdPrefix', parent=root_module['ns3::SimpleRefCount< ns3::RadvdPrefix, ns3::empty, ns3::DefaultDeleter<ns3::RadvdPrefix> >'])
     
     ## Register a nested module for the namespace Config
     
@@ -28,6 +32,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -64,6 +74,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -81,9 +95,42 @@ def register_types_ns3_olsr(module):
     
 
 def register_methods(root_module):
+    register_Ns3Radvd_methods(root_module, root_module['ns3::Radvd'])
     register_Ns3RadvdInterface_methods(root_module, root_module['ns3::RadvdInterface'])
     register_Ns3RadvdPrefix_methods(root_module, root_module['ns3::RadvdPrefix'])
-    register_Ns3Radvd_methods(root_module, root_module['ns3::Radvd'])
+    return
+
+def register_Ns3Radvd_methods(root_module, cls):
+    ## radvd.h: ns3::Radvd::Radvd(ns3::Radvd const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::Radvd const &', 'arg0')])
+    ## radvd.h: ns3::Radvd::Radvd() [constructor]
+    cls.add_constructor([])
+    ## radvd.h: void ns3::Radvd::AddConfiguration(ns3::Ptr<ns3::RadvdInterface> routerInterface) [member function]
+    cls.add_method('AddConfiguration', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::RadvdInterface >', 'routerInterface')])
+    ## radvd.h: static ns3::TypeId ns3::Radvd::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## radvd.h: ns3::Radvd::MAX_RA_DELAY_TIME [variable]
+    cls.add_static_attribute('MAX_RA_DELAY_TIME', 'uint32_t const', is_const=True)
+    ## radvd.h: void ns3::Radvd::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
+    ## radvd.h: void ns3::Radvd::StartApplication() [member function]
+    cls.add_method('StartApplication', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
+    ## radvd.h: void ns3::Radvd::StopApplication() [member function]
+    cls.add_method('StopApplication', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
     return
 
 def register_Ns3RadvdInterface_methods(root_module, cls):
@@ -350,44 +397,12 @@ def register_Ns3RadvdPrefix_methods(root_module, cls):
                    [param('uint32_t', 'validLifeTime')])
     return
 
-def register_Ns3Radvd_methods(root_module, cls):
-    ## radvd.h: ns3::Radvd::Radvd(ns3::Radvd const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Radvd const &', 'arg0')])
-    ## radvd.h: ns3::Radvd::Radvd() [constructor]
-    cls.add_constructor([])
-    ## radvd.h: void ns3::Radvd::AddConfiguration(ns3::Ptr<ns3::RadvdInterface> routerInterface) [member function]
-    cls.add_method('AddConfiguration', 
-                   'void', 
-                   [param('ns3::Ptr< ns3::RadvdInterface >', 'routerInterface')])
-    ## radvd.h: static ns3::TypeId ns3::Radvd::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 
-                   'ns3::TypeId', 
-                   [], 
-                   is_static=True)
-    ## radvd.h: ns3::Radvd::MAX_RA_DELAY_TIME [variable]
-    cls.add_static_attribute('MAX_RA_DELAY_TIME', 'uint32_t const', is_const=True)
-    ## radvd.h: void ns3::Radvd::DoDispose() [member function]
-    cls.add_method('DoDispose', 
-                   'void', 
-                   [], 
-                   visibility='protected', is_virtual=True)
-    ## radvd.h: void ns3::Radvd::StartApplication() [member function]
-    cls.add_method('StartApplication', 
-                   'void', 
-                   [], 
-                   visibility='private', is_virtual=True)
-    ## radvd.h: void ns3::Radvd::StopApplication() [member function]
-    cls.add_method('StopApplication', 
-                   'void', 
-                   [], 
-                   visibility='private', is_virtual=True)
-    return
-
 def register_functions(root_module):
     module = root_module
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -403,6 +418,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-ILP32/ns3_module_simulator.py

@@ -5,8 +5,6 @@ def register_types(module):
     
     ## event-id.h: ns3::EventId [class]
     module.add_class('EventId')
-    ## event-impl.h: ns3::EventImpl [class]
-    module.add_class('EventImpl', allow_subclassing=True)
     ## high-precision-128.h: ns3::HighPrecision [class]
     module.add_class('HighPrecision')
     ## simulator.h: ns3::Simulator [class]
@@ -35,20 +33,20 @@ def register_types(module):
     module.add_class('Event', outer_class=root_module['ns3::Scheduler'])
     ## scheduler.h: ns3::Scheduler::EventKey [struct]
     module.add_class('EventKey', outer_class=root_module['ns3::Scheduler'])
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::EventImpl, ns3::empty, ns3::DefaultDeleter<ns3::EventImpl> > [class]
+    module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::EventImpl', 'ns3::empty', 'ns3::DefaultDeleter<ns3::EventImpl>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
     ## simulator-impl.h: ns3::SimulatorImpl [class]
     module.add_class('SimulatorImpl', parent=root_module['ns3::Object'])
     ## synchronizer.h: ns3::Synchronizer [class]
     module.add_class('Synchronizer', parent=root_module['ns3::Object'])
-    ## nstime.h: ns3::TimeChecker [class]
-    module.add_class('TimeChecker', parent=root_module['ns3::AttributeChecker'])
-    ## nstime.h: ns3::TimeValue [class]
-    module.add_class('TimeValue', parent=root_module['ns3::AttributeValue'])
     ## wall-clock-synchronizer.h: ns3::WallClockSynchronizer [class]
     module.add_class('WallClockSynchronizer', parent=root_module['ns3::Synchronizer'])
     ## calendar-scheduler.h: ns3::CalendarScheduler [class]
     module.add_class('CalendarScheduler', parent=root_module['ns3::Scheduler'])
     ## default-simulator-impl.h: ns3::DefaultSimulatorImpl [class]
     module.add_class('DefaultSimulatorImpl', parent=root_module['ns3::SimulatorImpl'])
+    ## event-impl.h: ns3::EventImpl [class]
+    module.add_class('EventImpl', parent=root_module['ns3::SimpleRefCount< ns3::EventImpl, ns3::empty, ns3::DefaultDeleter<ns3::EventImpl> >'])
     ## heap-scheduler.h: ns3::HeapScheduler [class]
     module.add_class('HeapScheduler', parent=root_module['ns3::Scheduler'])
     ## list-scheduler.h: ns3::ListScheduler [class]
@@ -61,6 +59,10 @@ def register_types(module):
     module.add_class('RealtimeSimulatorImpl', parent=root_module['ns3::SimulatorImpl'])
     ## realtime-simulator-impl.h: ns3::RealtimeSimulatorImpl::SynchronizationMode [enumeration]
     module.add_enum('SynchronizationMode', ['SYNC_BEST_EFFORT', 'SYNC_HARD_LIMIT'], outer_class=root_module['ns3::RealtimeSimulatorImpl'])
+    ## nstime.h: ns3::TimeChecker [class]
+    module.add_class('TimeChecker', parent=root_module['ns3::AttributeChecker'])
+    ## nstime.h: ns3::TimeValue [class]
+    module.add_class('TimeValue', parent=root_module['ns3::AttributeValue'])
     typehandlers.add_type_alias('ns3::TimeUnit< 2 >', 'ns3::TimeSquare')
     typehandlers.add_type_alias('ns3::TimeUnit< 2 >*', 'ns3::TimeSquare*')
     typehandlers.add_type_alias('ns3::TimeUnit< 2 >&', 'ns3::TimeSquare&')
@@ -92,6 +94,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -130,6 +138,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -148,7 +160,6 @@ def register_types_ns3_olsr(module):
 
 def register_methods(root_module):
     register_Ns3EventId_methods(root_module, root_module['ns3::EventId'])
-    register_Ns3EventImpl_methods(root_module, root_module['ns3::EventImpl'])
     register_Ns3HighPrecision_methods(root_module, root_module['ns3::HighPrecision'])
     register_Ns3Simulator_methods(root_module, root_module['ns3::Simulator'])
     register_Ns3TimeInvert_methods(root_module, root_module['ns3::TimeInvert'])
@@ -163,16 +174,17 @@ def register_methods(root_module):
     register_Ns3SchedulerEventKey_methods(root_module, root_module['ns3::Scheduler::EventKey'])
     register_Ns3SimulatorImpl_methods(root_module, root_module['ns3::SimulatorImpl'])
     register_Ns3Synchronizer_methods(root_module, root_module['ns3::Synchronizer'])
-    register_Ns3TimeChecker_methods(root_module, root_module['ns3::TimeChecker'])
-    register_Ns3TimeValue_methods(root_module, root_module['ns3::TimeValue'])
     register_Ns3WallClockSynchronizer_methods(root_module, root_module['ns3::WallClockSynchronizer'])
     register_Ns3CalendarScheduler_methods(root_module, root_module['ns3::CalendarScheduler'])
     register_Ns3DefaultSimulatorImpl_methods(root_module, root_module['ns3::DefaultSimulatorImpl'])
+    register_Ns3EventImpl_methods(root_module, root_module['ns3::EventImpl'])
     register_Ns3HeapScheduler_methods(root_module, root_module['ns3::HeapScheduler'])
     register_Ns3ListScheduler_methods(root_module, root_module['ns3::ListScheduler'])
     register_Ns3MapScheduler_methods(root_module, root_module['ns3::MapScheduler'])
     register_Ns3Ns2CalendarScheduler_methods(root_module, root_module['ns3::Ns2CalendarScheduler'])
     register_Ns3RealtimeSimulatorImpl_methods(root_module, root_module['ns3::RealtimeSimulatorImpl'])
+    register_Ns3TimeChecker_methods(root_module, root_module['ns3::TimeChecker'])
+    register_Ns3TimeValue_methods(root_module, root_module['ns3::TimeValue'])
     return
 
 def register_Ns3EventId_methods(root_module, cls):
@@ -182,12 +194,17 @@ def register_Ns3EventId_methods(root_module, cls):
     cls.add_constructor([param('ns3::EventId const &', 'arg0')])
     ## event-id.h: ns3::EventId::EventId() [constructor]
     cls.add_constructor([])
-    ## event-id.h: ns3::EventId::EventId(ns3::Ptr<ns3::EventImpl> const & impl, uint64_t ts, uint32_t uid) [constructor]
-    cls.add_constructor([param('ns3::Ptr< ns3::EventImpl > const &', 'impl'), param('uint64_t', 'ts'), param('uint32_t', 'uid')])
+    ## event-id.h: ns3::EventId::EventId(ns3::Ptr<ns3::EventImpl> const & impl, uint64_t ts, uint32_t context, uint32_t uid) [constructor]
+    cls.add_constructor([param('ns3::Ptr< ns3::EventImpl > const &', 'impl'), param('uint64_t', 'ts'), param('uint32_t', 'context'), param('uint32_t', 'uid')])
     ## event-id.h: void ns3::EventId::Cancel() [member function]
     cls.add_method('Cancel', 
                    'void', 
                    [])
+    ## event-id.h: uint32_t ns3::EventId::GetContext() const [member function]
+    cls.add_method('GetContext', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## event-id.h: uint64_t ns3::EventId::GetTs() const [member function]
     cls.add_method('GetTs', 
                    'uint64_t', 
@@ -215,40 +232,6 @@ def register_Ns3EventId_methods(root_module, cls):
                    is_const=True)
     return
 
-def register_Ns3EventImpl_methods(root_module, cls):
-    ## event-impl.h: ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::EventImpl const &', 'arg0')])
-    ## event-impl.h: ns3::EventImpl::EventImpl() [constructor]
-    cls.add_constructor([])
-    ## event-impl.h: void ns3::EventImpl::Cancel() [member function]
-    cls.add_method('Cancel', 
-                   'void', 
-                   [])
-    ## event-impl.h: void ns3::EventImpl::Invoke() [member function]
-    cls.add_method('Invoke', 
-                   'void', 
-                   [])
-    ## event-impl.h: bool ns3::EventImpl::IsCancelled() [member function]
-    cls.add_method('IsCancelled', 
-                   'bool', 
-                   [])
-    ## event-impl.h: void ns3::EventImpl::Ref() const [member function]
-    cls.add_method('Ref', 
-                   'void', 
-                   [], 
-                   is_const=True)
-    ## event-impl.h: void ns3::EventImpl::Unref() const [member function]
-    cls.add_method('Unref', 
-                   'void', 
-                   [], 
-                   is_const=True)
-    ## event-impl.h: void ns3::EventImpl::Notify() [member function]
-    cls.add_method('Notify', 
-                   'void', 
-                   [], 
-                   is_pure_virtual=True, visibility='protected', is_virtual=True)
-    return
-
 def register_Ns3HighPrecision_methods(root_module, cls):
     ## high-precision-128.h: ns3::HighPrecision::HighPrecision(ns3::HighPrecision const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::HighPrecision const &', 'arg0')])
@@ -314,6 +297,11 @@ def register_Ns3Simulator_methods(root_module, cls):
                    'void', 
                    [], 
                    is_static=True)
+    ## simulator.h: static uint32_t ns3::Simulator::GetContext() [member function]
+    cls.add_method('GetContext', 
+                   'uint32_t', 
+                   [], 
+                   is_static=True)
     ## simulator.h: static ns3::Time ns3::Simulator::GetDelayLeft(ns3::EventId const & id) [member function]
     cls.add_method('GetDelayLeft', 
                    'ns3::Time', 
@@ -364,10 +352,10 @@ def register_Ns3Simulator_methods(root_module, cls):
                    'void', 
                    [param('ns3::Ptr< ns3::SimulatorImpl >', 'impl')], 
                    is_static=True)
-    ## simulator.h: static void ns3::Simulator::SetScheduler(ns3::Ptr<ns3::Scheduler> scheduler) [member function]
+    ## simulator.h: static void ns3::Simulator::SetScheduler(ns3::ObjectFactory schedulerFactory) [member function]
     cls.add_method('SetScheduler', 
                    'void', 
-                   [param('ns3::Ptr< ns3::Scheduler >', 'scheduler')], 
+                   [param('ns3::ObjectFactory', 'schedulerFactory')], 
                    is_static=True)
     ## simulator.h: static void ns3::Simulator::Stop() [member function]
     cls.add_method('Stop', 
@@ -769,6 +757,8 @@ def register_Ns3SchedulerEventKey_methods(root_module, cls):
     cls.add_constructor([])
     ## scheduler.h: ns3::Scheduler::EventKey::EventKey(ns3::Scheduler::EventKey const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::Scheduler::EventKey const &', 'arg0')])
+    ## scheduler.h: ns3::Scheduler::EventKey::m_context [variable]
+    cls.add_instance_attribute('m_context', 'uint32_t', is_const=False)
     ## scheduler.h: ns3::Scheduler::EventKey::m_ts [variable]
     cls.add_instance_attribute('m_ts', 'uint64_t', is_const=False)
     ## scheduler.h: ns3::Scheduler::EventKey::m_uid [variable]
@@ -790,6 +780,11 @@ def register_Ns3SimulatorImpl_methods(root_module, cls):
                    'void', 
                    [], 
                    is_pure_virtual=True, is_virtual=True)
+    ## simulator-impl.h: uint32_t ns3::SimulatorImpl::GetContext() const [member function]
+    cls.add_method('GetContext', 
+                   'uint32_t', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     ## simulator-impl.h: ns3::Time ns3::SimulatorImpl::GetDelayLeft(ns3::EventId const & id) const [member function]
     cls.add_method('GetDelayLeft', 
                    'ns3::Time', 
@@ -850,16 +845,26 @@ def register_Ns3SimulatorImpl_methods(root_module, cls):
                    'ns3::EventId', 
                    [param('ns3::EventImpl *', 'event')], 
                    is_pure_virtual=True, is_virtual=True)
-    ## simulator-impl.h: void ns3::SimulatorImpl::SetScheduler(ns3::Ptr<ns3::Scheduler> scheduler) [member function]
+    ## simulator-impl.h: void ns3::SimulatorImpl::ScheduleWithContext(uint32_t context, ns3::Time const & time, ns3::EventImpl * event) [member function]
+    cls.add_method('ScheduleWithContext', 
+                   'void', 
+                   [param('uint32_t', 'context'), param('ns3::Time const &', 'time'), param('ns3::EventImpl *', 'event')], 
+                   is_pure_virtual=True, is_virtual=True)
+    ## simulator-impl.h: void ns3::SimulatorImpl::SetScheduler(ns3::ObjectFactory schedulerFactory) [member function]
     cls.add_method('SetScheduler', 
                    'void', 
-                   [param('ns3::Ptr< ns3::Scheduler >', 'scheduler')], 
+                   [param('ns3::ObjectFactory', 'schedulerFactory')], 
                    is_pure_virtual=True, is_virtual=True)
     ## simulator-impl.h: void ns3::SimulatorImpl::Stop() [member function]
     cls.add_method('Stop', 
                    'void', 
                    [], 
                    is_pure_virtual=True, is_virtual=True)
+    ## simulator-impl.h: void ns3::SimulatorImpl::Stop(ns3::Time const & time) [member function]
+    cls.add_method('Stop', 
+                   'void', 
+                   [param('ns3::Time const &', 'time')], 
+                   is_pure_virtual=True, is_virtual=True)
     return
 
 def register_Ns3Synchronizer_methods(root_module, cls):
@@ -959,46 +964,6 @@ def register_Ns3Synchronizer_methods(root_module, cls):
                    is_pure_virtual=True, visibility='protected', is_virtual=True)
     return
 
-def register_Ns3TimeChecker_methods(root_module, cls):
-    ## nstime.h: ns3::TimeChecker::TimeChecker() [constructor]
-    cls.add_constructor([])
-    ## nstime.h: ns3::TimeChecker::TimeChecker(ns3::TimeChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::TimeChecker const &', 'arg0')])
-    return
-
-def register_Ns3TimeValue_methods(root_module, cls):
-    ## nstime.h: ns3::TimeValue::TimeValue() [constructor]
-    cls.add_constructor([])
-    ## nstime.h: ns3::TimeValue::TimeValue(ns3::TimeValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::TimeValue const &', 'arg0')])
-    ## nstime.h: ns3::TimeValue::TimeValue(ns3::Time const & value) [constructor]
-    cls.add_constructor([param('ns3::Time const &', 'value')])
-    ## nstime.h: ns3::Ptr<ns3::AttributeValue> ns3::TimeValue::Copy() const [member function]
-    cls.add_method('Copy', 
-                   'ns3::Ptr< ns3::AttributeValue >', 
-                   [], 
-                   is_const=True, is_virtual=True)
-    ## nstime.h: bool ns3::TimeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
-    cls.add_method('DeserializeFromString', 
-                   'bool', 
-                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
-                   is_virtual=True)
-    ## nstime.h: ns3::Time ns3::TimeValue::Get() const [member function]
-    cls.add_method('Get', 
-                   'ns3::Time', 
-                   [], 
-                   is_const=True)
-    ## nstime.h: std::string ns3::TimeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
-    cls.add_method('SerializeToString', 
-                   'std::string', 
-                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
-                   is_const=True, is_virtual=True)
-    ## nstime.h: void ns3::TimeValue::Set(ns3::Time const & value) [member function]
-    cls.add_method('Set', 
-                   'void', 
-                   [param('ns3::Time const &', 'value')])
-    return
-
 def register_Ns3WallClockSynchronizer_methods(root_module, cls):
     ## wall-clock-synchronizer.h: ns3::WallClockSynchronizer::WallClockSynchronizer(ns3::WallClockSynchronizer const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::WallClockSynchronizer const &', 'arg0')])
@@ -1149,6 +1114,11 @@ def register_Ns3DefaultSimulatorImpl_methods(root_module, cls):
                    'void', 
                    [], 
                    is_virtual=True)
+    ## default-simulator-impl.h: uint32_t ns3::DefaultSimulatorImpl::GetContext() const [member function]
+    cls.add_method('GetContext', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## default-simulator-impl.h: ns3::Time ns3::DefaultSimulatorImpl::GetDelayLeft(ns3::EventId const & id) const [member function]
     cls.add_method('GetDelayLeft', 
                    'ns3::Time', 
@@ -1214,16 +1184,55 @@ def register_Ns3DefaultSimulatorImpl_methods(root_module, cls):
                    'ns3::EventId', 
                    [param('ns3::EventImpl *', 'event')], 
                    is_virtual=True)
-    ## default-simulator-impl.h: void ns3::DefaultSimulatorImpl::SetScheduler(ns3::Ptr<ns3::Scheduler> scheduler) [member function]
+    ## default-simulator-impl.h: void ns3::DefaultSimulatorImpl::ScheduleWithContext(uint32_t context, ns3::Time const & time, ns3::EventImpl * event) [member function]
+    cls.add_method('ScheduleWithContext', 
+                   'void', 
+                   [param('uint32_t', 'context'), param('ns3::Time const &', 'time'), param('ns3::EventImpl *', 'event')], 
+                   is_virtual=True)
+    ## default-simulator-impl.h: void ns3::DefaultSimulatorImpl::SetScheduler(ns3::ObjectFactory schedulerFactory) [member function]
     cls.add_method('SetScheduler', 
                    'void', 
-                   [param('ns3::Ptr< ns3::Scheduler >', 'scheduler')], 
+                   [param('ns3::ObjectFactory', 'schedulerFactory')], 
                    is_virtual=True)
     ## default-simulator-impl.h: void ns3::DefaultSimulatorImpl::Stop() [member function]
     cls.add_method('Stop', 
                    'void', 
                    [], 
                    is_virtual=True)
+    ## default-simulator-impl.h: void ns3::DefaultSimulatorImpl::Stop(ns3::Time const & time) [member function]
+    cls.add_method('Stop', 
+                   'void', 
+                   [param('ns3::Time const &', 'time')], 
+                   is_virtual=True)
+    ## default-simulator-impl.h: void ns3::DefaultSimulatorImpl::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
+    return
+
+def register_Ns3EventImpl_methods(root_module, cls):
+    ## event-impl.h: ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::EventImpl const &', 'arg0')])
+    ## event-impl.h: ns3::EventImpl::EventImpl() [constructor]
+    cls.add_constructor([])
+    ## event-impl.h: void ns3::EventImpl::Cancel() [member function]
+    cls.add_method('Cancel', 
+                   'void', 
+                   [])
+    ## event-impl.h: void ns3::EventImpl::Invoke() [member function]
+    cls.add_method('Invoke', 
+                   'void', 
+                   [])
+    ## event-impl.h: bool ns3::EventImpl::IsCancelled() [member function]
+    cls.add_method('IsCancelled', 
+                   'bool', 
+                   [])
+    ## event-impl.h: void ns3::EventImpl::Notify() [member function]
+    cls.add_method('Notify', 
+                   'void', 
+                   [], 
+                   is_pure_virtual=True, visibility='protected', is_virtual=True)
     return
 
 def register_Ns3HeapScheduler_methods(root_module, cls):
@@ -1389,6 +1398,11 @@ def register_Ns3RealtimeSimulatorImpl_methods(root_module, cls):
                    'void', 
                    [], 
                    is_virtual=True)
+    ## realtime-simulator-impl.h: uint32_t ns3::RealtimeSimulatorImpl::GetContext() const [member function]
+    cls.add_method('GetContext', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## realtime-simulator-impl.h: ns3::Time ns3::RealtimeSimulatorImpl::GetDelayLeft(ns3::EventId const & id) const [member function]
     cls.add_method('GetDelayLeft', 
                    'ns3::Time', 
@@ -1477,14 +1491,27 @@ def register_Ns3RealtimeSimulatorImpl_methods(root_module, cls):
     cls.add_method('ScheduleRealtimeNow', 
                    'void', 
                    [param('ns3::EventImpl *', 'event')])
+    ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::ScheduleRealtimeNowWithContext(uint32_t context, ns3::EventImpl * event) [member function]
+    cls.add_method('ScheduleRealtimeNowWithContext', 
+                   'void', 
+                   [param('uint32_t', 'context'), param('ns3::EventImpl *', 'event')])
+    ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::ScheduleRealtimeWithContext(uint32_t context, ns3::Time const & time, ns3::EventImpl * event) [member function]
+    cls.add_method('ScheduleRealtimeWithContext', 
+                   'void', 
+                   [param('uint32_t', 'context'), param('ns3::Time const &', 'time'), param('ns3::EventImpl *', 'event')])
+    ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::ScheduleWithContext(uint32_t context, ns3::Time const & time, ns3::EventImpl * event) [member function]
+    cls.add_method('ScheduleWithContext', 
+                   'void', 
+                   [param('uint32_t', 'context'), param('ns3::Time const &', 'time'), param('ns3::EventImpl *', 'event')], 
+                   is_virtual=True)
     ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::SetHardLimit(ns3::Time limit) [member function]
     cls.add_method('SetHardLimit', 
                    'void', 
                    [param('ns3::Time', 'limit')])
-    ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::SetScheduler(ns3::Ptr<ns3::Scheduler> scheduler) [member function]
+    ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::SetScheduler(ns3::ObjectFactory schedulerFactory) [member function]
     cls.add_method('SetScheduler', 
                    'void', 
-                   [param('ns3::Ptr< ns3::Scheduler >', 'scheduler')], 
+                   [param('ns3::ObjectFactory', 'schedulerFactory')], 
                    is_virtual=True)
     ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::SetSynchronizationMode(ns3::RealtimeSimulatorImpl::SynchronizationMode mode) [member function]
     cls.add_method('SetSynchronizationMode', 
@@ -1495,6 +1522,56 @@ def register_Ns3RealtimeSimulatorImpl_methods(root_module, cls):
                    'void', 
                    [], 
                    is_virtual=True)
+    ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::Stop(ns3::Time const & time) [member function]
+    cls.add_method('Stop', 
+                   'void', 
+                   [param('ns3::Time const &', 'time')], 
+                   is_virtual=True)
+    ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
+    return
+
+def register_Ns3TimeChecker_methods(root_module, cls):
+    ## nstime.h: ns3::TimeChecker::TimeChecker() [constructor]
+    cls.add_constructor([])
+    ## nstime.h: ns3::TimeChecker::TimeChecker(ns3::TimeChecker const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::TimeChecker const &', 'arg0')])
+    return
+
+def register_Ns3TimeValue_methods(root_module, cls):
+    ## nstime.h: ns3::TimeValue::TimeValue() [constructor]
+    cls.add_constructor([])
+    ## nstime.h: ns3::TimeValue::TimeValue(ns3::TimeValue const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::TimeValue const &', 'arg0')])
+    ## nstime.h: ns3::TimeValue::TimeValue(ns3::Time const & value) [constructor]
+    cls.add_constructor([param('ns3::Time const &', 'value')])
+    ## nstime.h: ns3::Ptr<ns3::AttributeValue> ns3::TimeValue::Copy() const [member function]
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## nstime.h: bool ns3::TimeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_virtual=True)
+    ## nstime.h: ns3::Time ns3::TimeValue::Get() const [member function]
+    cls.add_method('Get', 
+                   'ns3::Time', 
+                   [], 
+                   is_const=True)
+    ## nstime.h: std::string ns3::TimeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, is_virtual=True)
+    ## nstime.h: void ns3::TimeValue::Set(ns3::Time const & value) [member function]
+    cls.add_method('Set', 
+                   'void', 
+                   [param('ns3::Time const &', 'value')])
     return
 
 def register_functions(root_module):
@@ -1515,7 +1592,7 @@ def register_functions(root_module):
     module.add_function('MakeTimeChecker', 
                         'ns3::Ptr< ns3::AttributeChecker const >', 
                         [])
-    ## high-precision.h: extern ns3::HighPrecision ns3::Max(ns3::HighPrecision const & a, ns3::HighPrecision const & b) [free function]
+    ## high-precision.h: ns3::HighPrecision ns3::Max(ns3::HighPrecision const & a, ns3::HighPrecision const & b) [free function]
     module.add_function('Max', 
                         'ns3::HighPrecision', 
                         [param('ns3::HighPrecision const &', 'a'), param('ns3::HighPrecision const &', 'b')])
@@ -1527,7 +1604,7 @@ def register_functions(root_module):
     module.add_function('MilliSeconds', 
                         'ns3::Time', 
                         [param('uint64_t', 'ms')])
-    ## high-precision.h: extern ns3::HighPrecision ns3::Min(ns3::HighPrecision const & a, ns3::HighPrecision const & b) [free function]
+    ## high-precision.h: ns3::HighPrecision ns3::Min(ns3::HighPrecision const & a, ns3::HighPrecision const & b) [free function]
     module.add_function('Min', 
                         'ns3::HighPrecision', 
                         [param('ns3::HighPrecision const &', 'a'), param('ns3::HighPrecision const &', 'b')])
@@ -1554,6 +1631,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -1577,6 +1655,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-ILP32/ns3_module_static_routing.py

@@ -34,6 +34,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -70,6 +76,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -447,15 +457,15 @@ def register_Ns3Ipv4StaticRouting_methods(root_module, cls):
     cls.add_method('RemoveRoute', 
                    'void', 
                    [param('uint32_t', 'i')])
-    ## ipv4-static-routing.h: bool ns3::Ipv4StaticRouting::RouteInput(ns3::Ptr<ns3::Packet const> p, ns3::Ipv4Header const & header, ns3::Ptr<const ns3::NetDevice> idev, ns3::Callback<void,ns3::Ptr<ns3::Ipv4Route>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ucb, ns3::Callback<void,ns3::Ptr<ns3::Ipv4MulticastRoute>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> mcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,unsigned int,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> lcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::Socket::SocketErrno,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ecb) [member function]
+    ## ipv4-static-routing.h: bool ns3::Ipv4StaticRouting::RouteInput(ns3::Ptr<ns3::Packet const> p, ns3::Ipv4Header const & header, ns3::Ptr<const ns3::NetDevice> idev, ns3::Callback<void, ns3::Ptr<ns3::Ipv4Route>, ns3::Ptr<ns3::Packet const>, ns3::Ipv4Header const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ucb, ns3::Callback<void,ns3::Ptr<ns3::Ipv4MulticastRoute>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> mcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,unsigned int,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> lcb, ns3::Callback<void, ns3::Ptr<ns3::Packet const>, ns3::Ipv4Header const&, ns3::Socket::SocketErrno, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ecb) [member function]
     cls.add_method('RouteInput', 
                    'bool', 
                    [param('ns3::Ptr< ns3::Packet const >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice const >', 'idev'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv4Route >, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ucb'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv4MulticastRoute >, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'mcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'lcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::Socket::SocketErrno, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ecb')], 
                    is_virtual=True)
-    ## ipv4-static-routing.h: ns3::Ptr<ns3::Ipv4Route> ns3::Ipv4StaticRouting::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Header const & header, uint32_t oif, ns3::Socket::SocketErrno & sockerr) [member function]
+    ## ipv4-static-routing.h: ns3::Ptr<ns3::Ipv4Route> ns3::Ipv4StaticRouting::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Header const & header, ns3::Ptr<ns3::NetDevice> oif, ns3::Socket::SocketErrno & sockerr) [member function]
     cls.add_method('RouteOutput', 
                    'ns3::Ptr< ns3::Ipv4Route >', 
-                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('uint32_t', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice >', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
                    is_virtual=True)
     ## ipv4-static-routing.h: void ns3::Ipv4StaticRouting::SetDefaultMulticastRoute(uint32_t outputInterface) [member function]
     cls.add_method('SetDefaultMulticastRoute', 
@@ -592,10 +602,10 @@ def register_Ns3Ipv6StaticRouting_methods(root_module, cls):
                    'bool', 
                    [param('ns3::Ptr< ns3::Packet const >', 'p'), param('ns3::Ipv6Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice const >', 'idev'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv6Route >, ns3::Ptr< ns3::Packet const >, ns3::Ipv6Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ucb'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv6MulticastRoute >, ns3::Ptr< ns3::Packet const >, ns3::Ipv6Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'mcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv6Header const &, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'lcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv6Header const &, ns3::Socket::SocketErrno, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ecb')], 
                    is_virtual=True)
-    ## ipv6-static-routing.h: ns3::Ptr<ns3::Ipv6Route> ns3::Ipv6StaticRouting::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv6Header const & header, uint32_t oif, ns3::Socket::SocketErrno & sockerr) [member function]
+    ## ipv6-static-routing.h: ns3::Ptr<ns3::Ipv6Route> ns3::Ipv6StaticRouting::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv6Header const & header, ns3::Ptr<ns3::NetDevice> oif, ns3::Socket::SocketErrno & sockerr) [member function]
     cls.add_method('RouteOutput', 
                    'ns3::Ptr< ns3::Ipv6Route >', 
-                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv6Header const &', 'header'), param('uint32_t', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv6Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice >', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
                    is_virtual=True)
     ## ipv6-static-routing.h: void ns3::Ipv6StaticRouting::SetDefaultMulticastRoute(uint32_t outputInterface) [member function]
     cls.add_method('SetDefaultMulticastRoute', 
@@ -622,6 +632,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -637,6 +648,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-ILP32/ns3_module_stats.py

@@ -5,18 +5,16 @@ def register_types(module):
     
     ## data-output-interface.h: ns3::DataOutputCallback [class]
     module.add_class('DataOutputCallback', allow_subclassing=True)
+    ## data-calculator.h: ns3::StatisticalSummary [class]
+    module.add_class('StatisticalSummary', allow_subclassing=True)
     ## data-calculator.h: ns3::DataCalculator [class]
     module.add_class('DataCalculator', parent=root_module['ns3::Object'])
     ## data-collector.h: ns3::DataCollector [class]
     module.add_class('DataCollector', parent=root_module['ns3::Object'])
     ## data-output-interface.h: ns3::DataOutputInterface [class]
     module.add_class('DataOutputInterface', parent=root_module['ns3::Object'])
-    ## basic-data-calculators.h: ns3::MinMaxAvgTotalCalculator<unsigned int> [class]
-    module.add_class('MinMaxAvgTotalCalculator', template_parameters=['unsigned int'], parent=root_module['ns3::DataCalculator'])
     ## omnet-data-output.h: ns3::OmnetDataOutput [class]
     module.add_class('OmnetDataOutput', parent=root_module['ns3::DataOutputInterface'])
-    ## packet-data-calculators.h: ns3::PacketSizeMinMaxAvgTotalCalculator [class]
-    module.add_class('PacketSizeMinMaxAvgTotalCalculator', parent=root_module['ns3::MinMaxAvgTotalCalculator< unsigned int >'])
     ## sqlite-data-output.h: ns3::SqliteDataOutput [class]
     module.add_class('SqliteDataOutput', parent=root_module['ns3::DataOutputInterface'])
     ## time-data-calculators.h: ns3::TimeMinMaxAvgTotalCalculator [class]
@@ -50,6 +48,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -86,6 +90,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -104,12 +112,11 @@ def register_types_ns3_olsr(module):
 
 def register_methods(root_module):
     register_Ns3DataOutputCallback_methods(root_module, root_module['ns3::DataOutputCallback'])
+    register_Ns3StatisticalSummary_methods(root_module, root_module['ns3::StatisticalSummary'])
     register_Ns3DataCalculator_methods(root_module, root_module['ns3::DataCalculator'])
     register_Ns3DataCollector_methods(root_module, root_module['ns3::DataCollector'])
     register_Ns3DataOutputInterface_methods(root_module, root_module['ns3::DataOutputInterface'])
-    register_Ns3MinMaxAvgTotalCalculator__Unsigned_int_methods(root_module, root_module['ns3::MinMaxAvgTotalCalculator< unsigned int >'])
     register_Ns3OmnetDataOutput_methods(root_module, root_module['ns3::OmnetDataOutput'])
-    register_Ns3PacketSizeMinMaxAvgTotalCalculator_methods(root_module, root_module['ns3::PacketSizeMinMaxAvgTotalCalculator'])
     register_Ns3SqliteDataOutput_methods(root_module, root_module['ns3::SqliteDataOutput'])
     register_Ns3TimeMinMaxAvgTotalCalculator_methods(root_module, root_module['ns3::TimeMinMaxAvgTotalCalculator'])
     register_Ns3CounterCalculator__Unsigned_int_methods(root_module, root_module['ns3::CounterCalculator< unsigned int >'])
@@ -146,6 +153,58 @@ def register_Ns3DataOutputCallback_methods(root_module, cls):
                    'void', 
                    [param('std::string', 'key'), param('std::string', 'variable'), param('ns3::Time', 'val')], 
                    is_pure_virtual=True, is_virtual=True)
+    ## data-output-interface.h: void ns3::DataOutputCallback::OutputStatistic(std::string key, std::string variable, ns3::StatisticalSummary const * statSum) [member function]
+    cls.add_method('OutputStatistic', 
+                   'void', 
+                   [param('std::string', 'key'), param('std::string', 'variable'), param('ns3::StatisticalSummary const *', 'statSum')], 
+                   is_pure_virtual=True, is_virtual=True)
+    return
+
+def register_Ns3StatisticalSummary_methods(root_module, cls):
+    ## data-calculator.h: ns3::StatisticalSummary::StatisticalSummary() [constructor]
+    cls.add_constructor([])
+    ## data-calculator.h: ns3::StatisticalSummary::StatisticalSummary(ns3::StatisticalSummary const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::StatisticalSummary const &', 'arg0')])
+    ## data-calculator.h: long int ns3::StatisticalSummary::getCount() const [member function]
+    cls.add_method('getCount', 
+                   'long int', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
+    ## data-calculator.h: double ns3::StatisticalSummary::getMax() const [member function]
+    cls.add_method('getMax', 
+                   'double', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
+    ## data-calculator.h: double ns3::StatisticalSummary::getMean() const [member function]
+    cls.add_method('getMean', 
+                   'double', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
+    ## data-calculator.h: double ns3::StatisticalSummary::getMin() const [member function]
+    cls.add_method('getMin', 
+                   'double', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
+    ## data-calculator.h: double ns3::StatisticalSummary::getSqrSum() const [member function]
+    cls.add_method('getSqrSum', 
+                   'double', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
+    ## data-calculator.h: double ns3::StatisticalSummary::getStddev() const [member function]
+    cls.add_method('getStddev', 
+                   'double', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
+    ## data-calculator.h: double ns3::StatisticalSummary::getSum() const [member function]
+    cls.add_method('getSum', 
+                   'double', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
+    ## data-calculator.h: double ns3::StatisticalSummary::getVariance() const [member function]
+    cls.add_method('getVariance', 
+                   'double', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     return
 
 def register_Ns3DataCalculator_methods(root_module, cls):
@@ -161,6 +220,11 @@ def register_Ns3DataCalculator_methods(root_module, cls):
     cls.add_method('Enable', 
                    'void', 
                    [])
+    ## data-calculator.h: std::string ns3::DataCalculator::GetContext() const [member function]
+    cls.add_method('GetContext', 
+                   'std::string', 
+                   [], 
+                   is_const=True)
     ## data-calculator.h: bool ns3::DataCalculator::GetEnabled() const [member function]
     cls.add_method('GetEnabled', 
                    'bool', 
@@ -176,6 +240,10 @@ def register_Ns3DataCalculator_methods(root_module, cls):
                    'void', 
                    [param('ns3::DataOutputCallback &', 'callback')], 
                    is_pure_virtual=True, is_const=True, is_virtual=True)
+    ## data-calculator.h: void ns3::DataCalculator::SetContext(std::string const context) [member function]
+    cls.add_method('SetContext', 
+                   'void', 
+                   [param('std::string const', 'context')])
     ## data-calculator.h: void ns3::DataCalculator::SetKey(std::string const key) [member function]
     cls.add_method('SetKey', 
                    'void', 
@@ -296,27 +364,6 @@ def register_Ns3DataOutputInterface_methods(root_module, cls):
                    visibility='protected', is_virtual=True)
     return
 
-def register_Ns3MinMaxAvgTotalCalculator__Unsigned_int_methods(root_module, cls):
-    ## basic-data-calculators.h: ns3::MinMaxAvgTotalCalculator<unsigned int>::MinMaxAvgTotalCalculator(ns3::MinMaxAvgTotalCalculator<unsigned int> const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::MinMaxAvgTotalCalculator< unsigned int > const &', 'arg0')])
-    ## basic-data-calculators.h: ns3::MinMaxAvgTotalCalculator<unsigned int>::MinMaxAvgTotalCalculator() [constructor]
-    cls.add_constructor([])
-    ## basic-data-calculators.h: void ns3::MinMaxAvgTotalCalculator<unsigned int>::Output(ns3::DataOutputCallback & callback) const [member function]
-    cls.add_method('Output', 
-                   'void', 
-                   [param('ns3::DataOutputCallback &', 'callback')], 
-                   is_const=True, is_virtual=True)
-    ## basic-data-calculators.h: void ns3::MinMaxAvgTotalCalculator<unsigned int>::Update(unsigned int const i) [member function]
-    cls.add_method('Update', 
-                   'void', 
-                   [param('unsigned int const', 'i')])
-    ## basic-data-calculators.h: void ns3::MinMaxAvgTotalCalculator<unsigned int>::DoDispose() [member function]
-    cls.add_method('DoDispose', 
-                   'void', 
-                   [], 
-                   visibility='protected', is_virtual=True)
-    return
-
 def register_Ns3OmnetDataOutput_methods(root_module, cls):
     ## omnet-data-output.h: ns3::OmnetDataOutput::OmnetDataOutput(ns3::OmnetDataOutput const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::OmnetDataOutput const &', 'arg0')])
@@ -334,26 +381,6 @@ def register_Ns3OmnetDataOutput_methods(root_module, cls):
                    visibility='protected', is_virtual=True)
     return
 
-def register_Ns3PacketSizeMinMaxAvgTotalCalculator_methods(root_module, cls):
-    ## packet-data-calculators.h: ns3::PacketSizeMinMaxAvgTotalCalculator::PacketSizeMinMaxAvgTotalCalculator(ns3::PacketSizeMinMaxAvgTotalCalculator const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::PacketSizeMinMaxAvgTotalCalculator const &', 'arg0')])
-    ## packet-data-calculators.h: ns3::PacketSizeMinMaxAvgTotalCalculator::PacketSizeMinMaxAvgTotalCalculator() [constructor]
-    cls.add_constructor([])
-    ## packet-data-calculators.h: void ns3::PacketSizeMinMaxAvgTotalCalculator::FrameUpdate(std::string path, ns3::Ptr<ns3::Packet const> packet, ns3::Mac48Address realto) [member function]
-    cls.add_method('FrameUpdate', 
-                   'void', 
-                   [param('std::string', 'path'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::Mac48Address', 'realto')])
-    ## packet-data-calculators.h: void ns3::PacketSizeMinMaxAvgTotalCalculator::PacketUpdate(std::string path, ns3::Ptr<ns3::Packet const> packet) [member function]
-    cls.add_method('PacketUpdate', 
-                   'void', 
-                   [param('std::string', 'path'), param('ns3::Ptr< ns3::Packet const >', 'packet')])
-    ## packet-data-calculators.h: void ns3::PacketSizeMinMaxAvgTotalCalculator::DoDispose() [member function]
-    cls.add_method('DoDispose', 
-                   'void', 
-                   [], 
-                   visibility='protected', is_virtual=True)
-    return
-
 def register_Ns3SqliteDataOutput_methods(root_module, cls):
     ## sqlite-data-output.h: ns3::SqliteDataOutput::SqliteDataOutput(ns3::SqliteDataOutput const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::SqliteDataOutput const &', 'arg0')])
@@ -444,9 +471,14 @@ def register_Ns3PacketCounterCalculator_methods(root_module, cls):
 
 def register_functions(root_module):
     module = root_module
+    ## data-calculator.h: bool ns3::isNaN(double x) [free function]
+    module.add_function('isNaN', 
+                        'bool', 
+                        [param('double', 'x')])
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -462,6 +494,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-ILP32/ns3_module_tap_bridge.py

@@ -26,6 +26,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -62,6 +68,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -258,6 +268,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -273,6 +284,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-ILP32/ns3_module_test.py

@@ -22,6 +22,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -58,6 +64,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -82,6 +92,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -97,6 +108,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-ILP32/ns3_module_udp_client_server.py

@@ -0,0 +1,284 @@
+from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandlers
+
+def register_types(module):
+    root_module = module.get_root()
+    
+    ## packet-loss-counter.h: ns3::PacketLossCounter [class]
+    module.add_class('PacketLossCounter')
+    ## udp-client.h: ns3::UdpClient [class]
+    module.add_class('UdpClient', parent=root_module['ns3::Application'])
+    ## udp-server.h: ns3::UdpServer [class]
+    module.add_class('UdpServer', parent=root_module['ns3::Application'])
+    ## udp-trace-client.h: ns3::UdpTraceClient [class]
+    module.add_class('UdpTraceClient', parent=root_module['ns3::Application'])
+    
+    ## Register a nested module for the namespace Config
+    
+    nested_module = module.add_cpp_namespace('Config')
+    register_types_ns3_Config(nested_module)
+    
+    
+    ## Register a nested module for the namespace TimeStepPrecision
+    
+    nested_module = module.add_cpp_namespace('TimeStepPrecision')
+    register_types_ns3_TimeStepPrecision(nested_module)
+    
+    
+    ## Register a nested module for the namespace addressUtils
+    
+    nested_module = module.add_cpp_namespace('addressUtils')
+    register_types_ns3_addressUtils(nested_module)
+    
+    
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
+    ## Register a nested module for the namespace dot11s
+    
+    nested_module = module.add_cpp_namespace('dot11s')
+    register_types_ns3_dot11s(nested_module)
+    
+    
+    ## Register a nested module for the namespace flame
+    
+    nested_module = module.add_cpp_namespace('flame')
+    register_types_ns3_flame(nested_module)
+    
+    
+    ## Register a nested module for the namespace internal
+    
+    nested_module = module.add_cpp_namespace('internal')
+    register_types_ns3_internal(nested_module)
+    
+    
+    ## Register a nested module for the namespace olsr
+    
+    nested_module = module.add_cpp_namespace('olsr')
+    register_types_ns3_olsr(nested_module)
+    
+
+def register_types_ns3_Config(module):
+    root_module = module.get_root()
+    
+
+def register_types_ns3_TimeStepPrecision(module):
+    root_module = module.get_root()
+    
+
+def register_types_ns3_addressUtils(module):
+    root_module = module.get_root()
+    
+
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
+def register_types_ns3_dot11s(module):
+    root_module = module.get_root()
+    
+
+def register_types_ns3_flame(module):
+    root_module = module.get_root()
+    
+
+def register_types_ns3_internal(module):
+    root_module = module.get_root()
+    
+
+def register_types_ns3_olsr(module):
+    root_module = module.get_root()
+    
+
+def register_methods(root_module):
+    register_Ns3PacketLossCounter_methods(root_module, root_module['ns3::PacketLossCounter'])
+    register_Ns3UdpClient_methods(root_module, root_module['ns3::UdpClient'])
+    register_Ns3UdpServer_methods(root_module, root_module['ns3::UdpServer'])
+    register_Ns3UdpTraceClient_methods(root_module, root_module['ns3::UdpTraceClient'])
+    return
+
+def register_Ns3PacketLossCounter_methods(root_module, cls):
+    ## packet-loss-counter.h: ns3::PacketLossCounter::PacketLossCounter(ns3::PacketLossCounter const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::PacketLossCounter const &', 'arg0')])
+    ## packet-loss-counter.h: ns3::PacketLossCounter::PacketLossCounter(uint8_t bitmapSize) [constructor]
+    cls.add_constructor([param('uint8_t', 'bitmapSize')])
+    ## packet-loss-counter.h: uint16_t ns3::PacketLossCounter::GetBitMapSize() const [member function]
+    cls.add_method('GetBitMapSize', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
+    ## packet-loss-counter.h: uint32_t ns3::PacketLossCounter::GetLost() const [member function]
+    cls.add_method('GetLost', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
+    ## packet-loss-counter.h: void ns3::PacketLossCounter::NotifyReceived(uint32_t seq) [member function]
+    cls.add_method('NotifyReceived', 
+                   'void', 
+                   [param('uint32_t', 'seq')])
+    ## packet-loss-counter.h: void ns3::PacketLossCounter::SetBitMapSize(uint16_t size) [member function]
+    cls.add_method('SetBitMapSize', 
+                   'void', 
+                   [param('uint16_t', 'size')])
+    return
+
+def register_Ns3UdpClient_methods(root_module, cls):
+    ## udp-client.h: ns3::UdpClient::UdpClient(ns3::UdpClient const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::UdpClient const &', 'arg0')])
+    ## udp-client.h: ns3::UdpClient::UdpClient() [constructor]
+    cls.add_constructor([])
+    ## udp-client.h: static ns3::TypeId ns3::UdpClient::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## udp-client.h: void ns3::UdpClient::SetRemote(ns3::Ipv4Address ip, uint16_t port) [member function]
+    cls.add_method('SetRemote', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'ip'), param('uint16_t', 'port')])
+    ## udp-client.h: void ns3::UdpClient::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
+    ## udp-client.h: void ns3::UdpClient::StartApplication() [member function]
+    cls.add_method('StartApplication', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
+    ## udp-client.h: void ns3::UdpClient::StopApplication() [member function]
+    cls.add_method('StopApplication', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
+    return
+
+def register_Ns3UdpServer_methods(root_module, cls):
+    ## udp-server.h: ns3::UdpServer::UdpServer(ns3::UdpServer const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::UdpServer const &', 'arg0')])
+    ## udp-server.h: ns3::UdpServer::UdpServer() [constructor]
+    cls.add_constructor([])
+    ## udp-server.h: uint32_t ns3::UdpServer::GetLost() const [member function]
+    cls.add_method('GetLost', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
+    ## udp-server.h: uint16_t ns3::UdpServer::GetPacketWindowSize() const [member function]
+    cls.add_method('GetPacketWindowSize', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
+    ## udp-server.h: uint32_t ns3::UdpServer::GetReceived() const [member function]
+    cls.add_method('GetReceived', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
+    ## udp-server.h: static ns3::TypeId ns3::UdpServer::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## udp-server.h: void ns3::UdpServer::SetPacketWindowSize(uint16_t size) [member function]
+    cls.add_method('SetPacketWindowSize', 
+                   'void', 
+                   [param('uint16_t', 'size')])
+    ## udp-server.h: void ns3::UdpServer::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
+    ## udp-server.h: void ns3::UdpServer::StartApplication() [member function]
+    cls.add_method('StartApplication', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
+    ## udp-server.h: void ns3::UdpServer::StopApplication() [member function]
+    cls.add_method('StopApplication', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
+    return
+
+def register_Ns3UdpTraceClient_methods(root_module, cls):
+    ## udp-trace-client.h: ns3::UdpTraceClient::UdpTraceClient(ns3::UdpTraceClient const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::UdpTraceClient const &', 'arg0')])
+    ## udp-trace-client.h: ns3::UdpTraceClient::UdpTraceClient() [constructor]
+    cls.add_constructor([])
+    ## udp-trace-client.h: ns3::UdpTraceClient::UdpTraceClient(ns3::Ipv4Address ip, uint16_t port, char * traceFile) [constructor]
+    cls.add_constructor([param('ns3::Ipv4Address', 'ip'), param('uint16_t', 'port'), param('char *', 'traceFile')])
+    ## udp-trace-client.h: uint16_t ns3::UdpTraceClient::GetMaxPacketSize() [member function]
+    cls.add_method('GetMaxPacketSize', 
+                   'uint16_t', 
+                   [])
+    ## udp-trace-client.h: static ns3::TypeId ns3::UdpTraceClient::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## udp-trace-client.h: void ns3::UdpTraceClient::SetMaxPacketSize(uint16_t maxPacketSize) [member function]
+    cls.add_method('SetMaxPacketSize', 
+                   'void', 
+                   [param('uint16_t', 'maxPacketSize')])
+    ## udp-trace-client.h: void ns3::UdpTraceClient::SetRemote(ns3::Ipv4Address ip, uint16_t port) [member function]
+    cls.add_method('SetRemote', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'ip'), param('uint16_t', 'port')])
+    ## udp-trace-client.h: void ns3::UdpTraceClient::SetTraceFile(std::string filename) [member function]
+    cls.add_method('SetTraceFile', 
+                   'void', 
+                   [param('std::string', 'filename')])
+    ## udp-trace-client.h: void ns3::UdpTraceClient::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
+    ## udp-trace-client.h: void ns3::UdpTraceClient::StartApplication() [member function]
+    cls.add_method('StartApplication', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
+    ## udp-trace-client.h: void ns3::UdpTraceClient::StopApplication() [member function]
+    cls.add_method('StopApplication', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
+    return
+
+def register_functions(root_module):
+    module = root_module
+    register_functions_ns3_Config(module.get_submodule('Config'), root_module)
+    register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
+    register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
+    register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
+    register_functions_ns3_flame(module.get_submodule('flame'), root_module)
+    register_functions_ns3_internal(module.get_submodule('internal'), root_module)
+    register_functions_ns3_olsr(module.get_submodule('olsr'), root_module)
+    return
+
+def register_functions_ns3_Config(module, root_module):
+    return
+
+def register_functions_ns3_TimeStepPrecision(module, root_module):
+    return
+
+def register_functions_ns3_addressUtils(module, root_module):
+    return
+
+def register_functions_ns3_aodv(module, root_module):
+    return
+
+def register_functions_ns3_dot11s(module, root_module):
+    return
+
+def register_functions_ns3_flame(module, root_module):
+    return
+
+def register_functions_ns3_internal(module, root_module):
+    return
+
+def register_functions_ns3_olsr(module, root_module):
+    return
+

bindings/python/apidefs/gcc-ILP32/ns3_module_udp_echo.py

@@ -26,6 +26,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -62,6 +68,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -167,6 +177,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -182,6 +193,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-ILP32/ns3_module_v4ping.py

@@ -24,6 +24,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -60,6 +66,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -112,6 +122,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -127,6 +138,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-ILP32/ns3_module_virtual_net_device.py

@@ -24,6 +24,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -60,6 +66,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -242,6 +252,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -257,6 +268,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-ILP32/ns3_module_wifi.py

@@ -8,7 +8,9 @@ def register_types(module):
     ## wifi-preamble.h: ns3::WifiPreamble [enumeration]
     module.add_enum('WifiPreamble', ['WIFI_PREAMBLE_LONG', 'WIFI_PREAMBLE_SHORT'])
     ## wifi-phy-standard.h: ns3::WifiPhyStandard [enumeration]
-    module.add_enum('WifiPhyStandard', ['WIFI_PHY_STANDARD_80211a', 'WIFI_PHY_STANDARD_80211b', 'WIFI_PHY_STANDARD_80211_10Mhz', 'WIFI_PHY_STANDARD_80211_5Mhz', 'WIFI_PHY_STANDARD_holland', 'WIFI_PHY_UNKNOWN'])
+    module.add_enum('WifiPhyStandard', ['WIFI_PHY_STANDARD_80211a', 'WIFI_PHY_STANDARD_80211b', 'WIFI_PHY_STANDARD_80211_10Mhz', 'WIFI_PHY_STANDARD_80211_5Mhz', 'WIFI_PHY_STANDARD_holland', 'WIFI_PHY_STANDARD_80211p_CCH', 'WIFI_PHY_STANDARD_80211p_SCH', 'WIFI_PHY_UNKNOWN'])
+    ## qos-tag.h: ns3::UserPriority [enumeration]
+    module.add_enum('UserPriority', ['UP_BK', 'UP_BE', 'UP_EE', 'UP_CL', 'UP_VI', 'UP_VO', 'UP_NC'])
     ## qos-utils.h: ns3::AccessClass [enumeration]
     module.add_enum('AccessClass', ['AC_VO', 'AC_VI', 'AC_BE', 'AC_BK', 'AC_BE_NQOS', 'AC_UNDEF'])
     ## edca-txop-n.h: ns3::TypeOfStation [enumeration]
@@ -83,12 +85,26 @@ def register_types(module):
     module.add_class('RandomPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
     ## rraa-wifi-manager.h: ns3::RraaWifiRemoteStation [class]
     module.add_class('RraaWifiRemoteStation', parent=root_module['ns3::WifiRemoteStation'])
-    ## ssid.h: ns3::SsidChecker [class]
-    module.add_class('SsidChecker', parent=root_module['ns3::AttributeChecker'])
-    ## ssid.h: ns3::SsidValue [class]
-    module.add_class('SsidValue', parent=root_module['ns3::AttributeValue'])
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::InterferenceHelper::Event, ns3::empty, ns3::DefaultDeleter<ns3::InterferenceHelper::Event> > [class]
+    module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::InterferenceHelper::Event', 'ns3::empty', 'ns3::DefaultDeleter<ns3::InterferenceHelper::Event>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
     ## propagation-loss-model.h: ns3::ThreeLogDistancePropagationLossModel [class]
     module.add_class('ThreeLogDistancePropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
+    ## mgt-headers.h: ns3::WifiActionHeader [class]
+    module.add_class('WifiActionHeader', parent=root_module['ns3::Header'])
+    ## mgt-headers.h: ns3::WifiActionHeader::CategoryValue [enumeration]
+    module.add_enum('CategoryValue', ['MESH_PEERING_MGT', 'MESH_LINK_METRIC', 'MESH_PATH_SELECTION', 'MESH_INTERWORKING', 'MESH_RESOURCE_COORDINATION', 'MESH_PROXY_FORWARDING'], outer_class=root_module['ns3::WifiActionHeader'])
+    ## mgt-headers.h: ns3::WifiActionHeader::PeerLinkMgtActionValue [enumeration]
+    module.add_enum('PeerLinkMgtActionValue', ['PEER_LINK_OPEN', 'PEER_LINK_CONFIRM', 'PEER_LINK_CLOSE'], outer_class=root_module['ns3::WifiActionHeader'])
+    ## mgt-headers.h: ns3::WifiActionHeader::LinkMetricActionValue [enumeration]
+    module.add_enum('LinkMetricActionValue', ['LINK_METRIC_REQUEST', 'LINK_METRIC_REPORT'], outer_class=root_module['ns3::WifiActionHeader'])
+    ## mgt-headers.h: ns3::WifiActionHeader::PathSelectionActionValue [enumeration]
+    module.add_enum('PathSelectionActionValue', ['PATH_SELECTION'], outer_class=root_module['ns3::WifiActionHeader'])
+    ## mgt-headers.h: ns3::WifiActionHeader::InterworkActionValue [enumeration]
+    module.add_enum('InterworkActionValue', ['PORTAL_ANNOUNCEMENT'], outer_class=root_module['ns3::WifiActionHeader'])
+    ## mgt-headers.h: ns3::WifiActionHeader::ResourceCoordinationActionValue [enumeration]
+    module.add_enum('ResourceCoordinationActionValue', ['CONGESTION_CONTROL_NOTIFICATION', 'MDA_SETUP_REQUEST', 'MDA_SETUP_REPLY', 'MDAOP_ADVERTISMENT_REQUEST', 'MDAOP_ADVERTISMENTS', 'MDAOP_SET_TEARDOWN', 'BEACON_TIMING_REQUEST', 'BEACON_TIMING_RESPONSE', 'TBTT_ADJUSTMENT_REQUEST', 'MESH_CHANNEL_SWITCH_ANNOUNCEMENT'], outer_class=root_module['ns3::WifiActionHeader'])
+    ## mgt-headers.h: ns3::WifiActionHeader::ActionValue [union]
+    module.add_class('ActionValue', outer_class=root_module['ns3::WifiActionHeader'])
     ## wifi-mac.h: ns3::WifiMac [class]
     module.add_class('WifiMac', parent=root_module['ns3::Object'])
     ## wifi-mac-header.h: ns3::WifiMacHeader [class]
@@ -97,14 +113,10 @@ def register_types(module):
     module.add_enum('QosAckPolicy', ['NORMAL_ACK', 'NO_ACK', 'NO_EXPLICIT_ACK', 'BLOCK_ACK'], outer_class=root_module['ns3::WifiMacHeader'])
     ## wifi-mac-header.h: ns3::WifiMacHeader::AddressType [enumeration]
     module.add_enum('AddressType', ['ADDR1', 'ADDR2', 'ADDR3', 'ADDR4'], outer_class=root_module['ns3::WifiMacHeader'])
-    ## wifi-mode.h: ns3::WifiModeChecker [class]
-    module.add_class('WifiModeChecker', parent=root_module['ns3::AttributeChecker'])
-    ## wifi-mode.h: ns3::WifiModeValue [class]
-    module.add_class('WifiModeValue', parent=root_module['ns3::AttributeValue'])
     ## wifi-phy.h: ns3::WifiPhy [class]
     module.add_class('WifiPhy', parent=root_module['ns3::Object'])
     ## wifi-phy.h: ns3::WifiPhy::State [enumeration]
-    module.add_enum('State', ['SYNC', 'TX', 'CCA_BUSY', 'IDLE', 'SWITCHING'], outer_class=root_module['ns3::WifiPhy'])
+    module.add_enum('State', ['IDLE', 'CCA_BUSY', 'TX', 'RX', 'SWITCHING'], outer_class=root_module['ns3::WifiPhy'])
     ## wifi-remote-station-manager.h: ns3::WifiRemoteStationManager [class]
     module.add_class('WifiRemoteStationManager', parent=root_module['ns3::Object'])
     ## yans-wifi-phy.h: ns3::YansWifiPhy [class]
@@ -163,8 +175,16 @@ def register_types(module):
     module.add_class('QstaWifiMac', parent=root_module['ns3::WifiMac'])
     ## rraa-wifi-manager.h: ns3::RraaWifiManager [class]
     module.add_class('RraaWifiManager', parent=root_module['ns3::WifiRemoteStationManager'])
+    ## ssid.h: ns3::SsidChecker [class]
+    module.add_class('SsidChecker', parent=root_module['ns3::AttributeChecker'])
+    ## ssid.h: ns3::SsidValue [class]
+    module.add_class('SsidValue', parent=root_module['ns3::AttributeValue'])
     ## wifi-channel.h: ns3::WifiChannel [class]
     module.add_class('WifiChannel', parent=root_module['ns3::Channel'])
+    ## wifi-mode.h: ns3::WifiModeChecker [class]
+    module.add_class('WifiModeChecker', parent=root_module['ns3::AttributeChecker'])
+    ## wifi-mode.h: ns3::WifiModeValue [class]
+    module.add_class('WifiModeValue', parent=root_module['ns3::AttributeValue'])
     ## wifi-net-device.h: ns3::WifiNetDevice [class]
     module.add_class('WifiNetDevice', parent=root_module['ns3::NetDevice'])
     ## yans-error-rate-model.h: ns3::YansErrorRateModel [class]
@@ -203,6 +223,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -239,6 +265,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -290,13 +320,11 @@ def register_methods(root_module):
     register_Ns3RandomPropagationDelayModel_methods(root_module, root_module['ns3::RandomPropagationDelayModel'])
     register_Ns3RandomPropagationLossModel_methods(root_module, root_module['ns3::RandomPropagationLossModel'])
     register_Ns3RraaWifiRemoteStation_methods(root_module, root_module['ns3::RraaWifiRemoteStation'])
-    register_Ns3SsidChecker_methods(root_module, root_module['ns3::SsidChecker'])
-    register_Ns3SsidValue_methods(root_module, root_module['ns3::SsidValue'])
     register_Ns3ThreeLogDistancePropagationLossModel_methods(root_module, root_module['ns3::ThreeLogDistancePropagationLossModel'])
+    register_Ns3WifiActionHeader_methods(root_module, root_module['ns3::WifiActionHeader'])
+    register_Ns3WifiActionHeaderActionValue_methods(root_module, root_module['ns3::WifiActionHeader::ActionValue'])
     register_Ns3WifiMac_methods(root_module, root_module['ns3::WifiMac'])
     register_Ns3WifiMacHeader_methods(root_module, root_module['ns3::WifiMacHeader'])
-    register_Ns3WifiModeChecker_methods(root_module, root_module['ns3::WifiModeChecker'])
-    register_Ns3WifiModeValue_methods(root_module, root_module['ns3::WifiModeValue'])
     register_Ns3WifiPhy_methods(root_module, root_module['ns3::WifiPhy'])
     register_Ns3WifiRemoteStationManager_methods(root_module, root_module['ns3::WifiRemoteStationManager'])
     register_Ns3YansWifiPhy_methods(root_module, root_module['ns3::YansWifiPhy'])
@@ -327,7 +355,11 @@ def register_methods(root_module):
     register_Ns3QapWifiMac_methods(root_module, root_module['ns3::QapWifiMac'])
     register_Ns3QstaWifiMac_methods(root_module, root_module['ns3::QstaWifiMac'])
     register_Ns3RraaWifiManager_methods(root_module, root_module['ns3::RraaWifiManager'])
+    register_Ns3SsidChecker_methods(root_module, root_module['ns3::SsidChecker'])
+    register_Ns3SsidValue_methods(root_module, root_module['ns3::SsidValue'])
     register_Ns3WifiChannel_methods(root_module, root_module['ns3::WifiChannel'])
+    register_Ns3WifiModeChecker_methods(root_module, root_module['ns3::WifiModeChecker'])
+    register_Ns3WifiModeValue_methods(root_module, root_module['ns3::WifiModeValue'])
     register_Ns3WifiNetDevice_methods(root_module, root_module['ns3::WifiNetDevice'])
     register_Ns3YansErrorRateModel_methods(root_module, root_module['ns3::YansErrorRateModel'])
     register_Ns3YansWifiChannel_methods(root_module, root_module['ns3::YansWifiChannel'])
@@ -1982,11 +2014,6 @@ def register_Ns3QosTag_methods(root_module, cls):
                    'void', 
                    [param('ns3::TagBuffer', 'i')], 
                    is_virtual=True)
-    ## qos-tag.h: uint8_t ns3::QosTag::Get() const [member function]
-    cls.add_method('Get', 
-                   'uint8_t', 
-                   [], 
-                   is_const=True)
     ## qos-tag.h: ns3::TypeId ns3::QosTag::GetInstanceTypeId() const [member function]
     cls.add_method('GetInstanceTypeId', 
                    'ns3::TypeId', 
@@ -1997,6 +2024,11 @@ def register_Ns3QosTag_methods(root_module, cls):
                    'uint32_t', 
                    [], 
                    is_const=True, is_virtual=True)
+    ## qos-tag.h: uint8_t ns3::QosTag::GetTid() const [member function]
+    cls.add_method('GetTid', 
+                   'uint8_t', 
+                   [], 
+                   is_const=True)
     ## qos-tag.h: static ns3::TypeId ns3::QosTag::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2012,10 +2044,14 @@ def register_Ns3QosTag_methods(root_module, cls):
                    'void', 
                    [param('ns3::TagBuffer', 'i')], 
                    is_const=True, is_virtual=True)
-    ## qos-tag.h: void ns3::QosTag::Set(uint8_t tid) [member function]
-    cls.add_method('Set', 
+    ## qos-tag.h: void ns3::QosTag::SetTid(uint8_t tid) [member function]
+    cls.add_method('SetTid', 
                    'void', 
                    [param('uint8_t', 'tid')])
+    ## qos-tag.h: void ns3::QosTag::SetUserPriority(ns3::UserPriority up) [member function]
+    cls.add_method('SetUserPriority', 
+                   'void', 
+                   [param('ns3::UserPriority', 'up')])
     return
 
 def register_Ns3RandomPropagationDelayModel_methods(root_module, cls):
@@ -2112,46 +2148,6 @@ def register_Ns3RraaWifiRemoteStation_methods(root_module, cls):
                    is_const=True, visibility='private', is_virtual=True)
     return
 
-def register_Ns3SsidChecker_methods(root_module, cls):
-    ## ssid.h: ns3::SsidChecker::SsidChecker() [constructor]
-    cls.add_constructor([])
-    ## ssid.h: ns3::SsidChecker::SsidChecker(ns3::SsidChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::SsidChecker const &', 'arg0')])
-    return
-
-def register_Ns3SsidValue_methods(root_module, cls):
-    ## ssid.h: ns3::SsidValue::SsidValue() [constructor]
-    cls.add_constructor([])
-    ## ssid.h: ns3::SsidValue::SsidValue(ns3::SsidValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::SsidValue const &', 'arg0')])
-    ## ssid.h: ns3::SsidValue::SsidValue(ns3::Ssid const & value) [constructor]
-    cls.add_constructor([param('ns3::Ssid const &', 'value')])
-    ## ssid.h: ns3::Ptr<ns3::AttributeValue> ns3::SsidValue::Copy() const [member function]
-    cls.add_method('Copy', 
-                   'ns3::Ptr< ns3::AttributeValue >', 
-                   [], 
-                   is_const=True, is_virtual=True)
-    ## ssid.h: bool ns3::SsidValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
-    cls.add_method('DeserializeFromString', 
-                   'bool', 
-                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
-                   is_virtual=True)
-    ## ssid.h: ns3::Ssid ns3::SsidValue::Get() const [member function]
-    cls.add_method('Get', 
-                   'ns3::Ssid', 
-                   [], 
-                   is_const=True)
-    ## ssid.h: std::string ns3::SsidValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
-    cls.add_method('SerializeToString', 
-                   'std::string', 
-                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
-                   is_const=True, is_virtual=True)
-    ## ssid.h: void ns3::SsidValue::Set(ns3::Ssid const & value) [member function]
-    cls.add_method('Set', 
-                   'void', 
-                   [param('ns3::Ssid const &', 'value')])
-    return
-
 def register_Ns3ThreeLogDistancePropagationLossModel_methods(root_module, cls):
     ## propagation-loss-model.h: static ns3::TypeId ns3::ThreeLogDistancePropagationLossModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
@@ -2167,6 +2163,72 @@ def register_Ns3ThreeLogDistancePropagationLossModel_methods(root_module, cls):
                    is_const=True, visibility='private', is_virtual=True)
     return
 
+def register_Ns3WifiActionHeader_methods(root_module, cls):
+    ## mgt-headers.h: ns3::WifiActionHeader::WifiActionHeader(ns3::WifiActionHeader const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::WifiActionHeader const &', 'arg0')])
+    ## mgt-headers.h: ns3::WifiActionHeader::WifiActionHeader() [constructor]
+    cls.add_constructor([])
+    ## mgt-headers.h: uint32_t ns3::WifiActionHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
+    cls.add_method('Deserialize', 
+                   'uint32_t', 
+                   [param('ns3::Buffer::Iterator', 'start')], 
+                   is_virtual=True)
+    ## mgt-headers.h: ns3::WifiActionHeader::ActionValue ns3::WifiActionHeader::GetAction() [member function]
+    cls.add_method('GetAction', 
+                   'ns3::WifiActionHeader::ActionValue', 
+                   [])
+    ## mgt-headers.h: ns3::WifiActionHeader::CategoryValue ns3::WifiActionHeader::GetCategory() [member function]
+    cls.add_method('GetCategory', 
+                   'ns3::WifiActionHeader::CategoryValue', 
+                   [])
+    ## mgt-headers.h: ns3::TypeId ns3::WifiActionHeader::GetInstanceTypeId() const [member function]
+    cls.add_method('GetInstanceTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## mgt-headers.h: uint32_t ns3::WifiActionHeader::GetSerializedSize() const [member function]
+    cls.add_method('GetSerializedSize', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## mgt-headers.h: static ns3::TypeId ns3::WifiActionHeader::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## mgt-headers.h: void ns3::WifiActionHeader::Print(std::ostream & os) const [member function]
+    cls.add_method('Print', 
+                   'void', 
+                   [param('std::ostream &', 'os')], 
+                   is_const=True, is_virtual=True)
+    ## mgt-headers.h: void ns3::WifiActionHeader::Serialize(ns3::Buffer::Iterator start) const [member function]
+    cls.add_method('Serialize', 
+                   'void', 
+                   [param('ns3::Buffer::Iterator', 'start')], 
+                   is_const=True, is_virtual=True)
+    ## mgt-headers.h: void ns3::WifiActionHeader::SetAction(ns3::WifiActionHeader::CategoryValue type, ns3::WifiActionHeader::ActionValue action) [member function]
+    cls.add_method('SetAction', 
+                   'void', 
+                   [param('ns3::WifiActionHeader::CategoryValue', 'type'), param('ns3::WifiActionHeader::ActionValue', 'action')])
+    return
+
+def register_Ns3WifiActionHeaderActionValue_methods(root_module, cls):
+    ## mgt-headers.h: ns3::WifiActionHeader::ActionValue::ActionValue() [constructor]
+    cls.add_constructor([])
+    ## mgt-headers.h: ns3::WifiActionHeader::ActionValue::ActionValue(ns3::WifiActionHeader::ActionValue const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::WifiActionHeader::ActionValue const &', 'arg0')])
+    ## mgt-headers.h: ns3::WifiActionHeader::ActionValue::interwork [variable]
+    cls.add_instance_attribute('interwork', 'ns3::WifiActionHeader::InterworkActionValue', is_const=False)
+    ## mgt-headers.h: ns3::WifiActionHeader::ActionValue::linkMetrtic [variable]
+    cls.add_instance_attribute('linkMetrtic', 'ns3::WifiActionHeader::LinkMetricActionValue', is_const=False)
+    ## mgt-headers.h: ns3::WifiActionHeader::ActionValue::pathSelection [variable]
+    cls.add_instance_attribute('pathSelection', 'ns3::WifiActionHeader::PathSelectionActionValue', is_const=False)
+    ## mgt-headers.h: ns3::WifiActionHeader::ActionValue::peerLink [variable]
+    cls.add_instance_attribute('peerLink', 'ns3::WifiActionHeader::PeerLinkMgtActionValue', is_const=False)
+    ## mgt-headers.h: ns3::WifiActionHeader::ActionValue::resourceCoordination [variable]
+    cls.add_instance_attribute('resourceCoordination', 'ns3::WifiActionHeader::ResourceCoordinationActionValue', is_const=False)
+    return
+
 def register_Ns3WifiMac_methods(root_module, cls):
     ## wifi-mac.h: ns3::WifiMac::WifiMac() [constructor]
     cls.add_constructor([])
@@ -2345,6 +2407,11 @@ def register_Ns3WifiMac_methods(root_module, cls):
                    'bool', 
                    [], 
                    is_pure_virtual=True, is_const=True, is_virtual=True)
+    ## wifi-mac.h: void ns3::WifiMac::ConfigureCCHDcf(ns3::Ptr<ns3::Dcf> dcf, uint32_t cwmin, uint32_t cwmax, ns3::AccessClass ac) [member function]
+    cls.add_method('ConfigureCCHDcf', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Dcf >', 'dcf'), param('uint32_t', 'cwmin'), param('uint32_t', 'cwmax'), param('ns3::AccessClass', 'ac')], 
+                   visibility='protected')
     ## wifi-mac.h: void ns3::WifiMac::ConfigureDcf(ns3::Ptr<ns3::Dcf> dcf, uint32_t cwmin, uint32_t cwmax, ns3::AccessClass ac) [member function]
     cls.add_method('ConfigureDcf', 
                    'void', 
@@ -2746,46 +2813,6 @@ def register_Ns3WifiMacHeader_methods(root_module, cls):
                    [])
     return
 
-def register_Ns3WifiModeChecker_methods(root_module, cls):
-    ## wifi-mode.h: ns3::WifiModeChecker::WifiModeChecker() [constructor]
-    cls.add_constructor([])
-    ## wifi-mode.h: ns3::WifiModeChecker::WifiModeChecker(ns3::WifiModeChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::WifiModeChecker const &', 'arg0')])
-    return
-
-def register_Ns3WifiModeValue_methods(root_module, cls):
-    ## wifi-mode.h: ns3::WifiModeValue::WifiModeValue() [constructor]
-    cls.add_constructor([])
-    ## wifi-mode.h: ns3::WifiModeValue::WifiModeValue(ns3::WifiModeValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::WifiModeValue const &', 'arg0')])
-    ## wifi-mode.h: ns3::WifiModeValue::WifiModeValue(ns3::WifiMode const & value) [constructor]
-    cls.add_constructor([param('ns3::WifiMode const &', 'value')])
-    ## wifi-mode.h: ns3::Ptr<ns3::AttributeValue> ns3::WifiModeValue::Copy() const [member function]
-    cls.add_method('Copy', 
-                   'ns3::Ptr< ns3::AttributeValue >', 
-                   [], 
-                   is_const=True, is_virtual=True)
-    ## wifi-mode.h: bool ns3::WifiModeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
-    cls.add_method('DeserializeFromString', 
-                   'bool', 
-                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
-                   is_virtual=True)
-    ## wifi-mode.h: ns3::WifiMode ns3::WifiModeValue::Get() const [member function]
-    cls.add_method('Get', 
-                   'ns3::WifiMode', 
-                   [], 
-                   is_const=True)
-    ## wifi-mode.h: std::string ns3::WifiModeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
-    cls.add_method('SerializeToString', 
-                   'std::string', 
-                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
-                   is_const=True, is_virtual=True)
-    ## wifi-mode.h: void ns3::WifiModeValue::Set(ns3::WifiMode const & value) [member function]
-    cls.add_method('Set', 
-                   'void', 
-                   [param('ns3::WifiMode const &', 'value')])
-    return
-
 def register_Ns3WifiPhy_methods(root_module, cls):
     ## wifi-phy.h: ns3::WifiPhy::WifiPhy(ns3::WifiPhy const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::WifiPhy const &', 'arg0')])
@@ -3016,8 +3043,13 @@ def register_Ns3WifiPhy_methods(root_module, cls):
                    'bool', 
                    [], 
                    is_pure_virtual=True, is_virtual=True)
-    ## wifi-phy.h: bool ns3::WifiPhy::IsStateSync() [member function]
-    cls.add_method('IsStateSync', 
+    ## wifi-phy.h: bool ns3::WifiPhy::IsStateRx() [member function]
+    cls.add_method('IsStateRx', 
+                   'bool', 
+                   [], 
+                   is_pure_virtual=True, is_virtual=True)
+    ## wifi-phy.h: bool ns3::WifiPhy::IsStateSwitching() [member function]
+    cls.add_method('IsStateSwitching', 
                    'bool', 
                    [], 
                    is_pure_virtual=True, is_virtual=True)
@@ -3363,8 +3395,8 @@ def register_Ns3YansWifiPhy_methods(root_module, cls):
                    'bool', 
                    [], 
                    is_virtual=True)
-    ## yans-wifi-phy.h: bool ns3::YansWifiPhy::IsStateSync() [member function]
-    cls.add_method('IsStateSync', 
+    ## yans-wifi-phy.h: bool ns3::YansWifiPhy::IsStateRx() [member function]
+    cls.add_method('IsStateRx', 
                    'bool', 
                    [], 
                    is_virtual=True)
@@ -4510,6 +4542,11 @@ def register_Ns3NqapWifiMac_methods(root_module, cls):
                    'void', 
                    [], 
                    visibility='private', is_virtual=True)
+    ## nqap-wifi-mac.h: void ns3::NqapWifiMac::DoStart() [member function]
+    cls.add_method('DoStart', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
     ## nqap-wifi-mac.h: void ns3::NqapWifiMac::FinishConfigureStandard(ns3::WifiPhyStandard standard) [member function]
     cls.add_method('FinishConfigureStandard', 
                    'void', 
@@ -4991,6 +5028,11 @@ def register_Ns3QapWifiMac_methods(root_module, cls):
                    'void', 
                    [], 
                    visibility='private', is_virtual=True)
+    ## qap-wifi-mac.h: void ns3::QapWifiMac::DoStart() [member function]
+    cls.add_method('DoStart', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
     ## qap-wifi-mac.h: void ns3::QapWifiMac::FinishConfigureStandard(ns3::WifiPhyStandard standard) [member function]
     cls.add_method('FinishConfigureStandard', 
                    'void', 
@@ -5190,6 +5232,46 @@ def register_Ns3RraaWifiManager_methods(root_module, cls):
                    visibility='private', is_virtual=True)
     return
 
+def register_Ns3SsidChecker_methods(root_module, cls):
+    ## ssid.h: ns3::SsidChecker::SsidChecker() [constructor]
+    cls.add_constructor([])
+    ## ssid.h: ns3::SsidChecker::SsidChecker(ns3::SsidChecker const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::SsidChecker const &', 'arg0')])
+    return
+
+def register_Ns3SsidValue_methods(root_module, cls):
+    ## ssid.h: ns3::SsidValue::SsidValue() [constructor]
+    cls.add_constructor([])
+    ## ssid.h: ns3::SsidValue::SsidValue(ns3::SsidValue const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::SsidValue const &', 'arg0')])
+    ## ssid.h: ns3::SsidValue::SsidValue(ns3::Ssid const & value) [constructor]
+    cls.add_constructor([param('ns3::Ssid const &', 'value')])
+    ## ssid.h: ns3::Ptr<ns3::AttributeValue> ns3::SsidValue::Copy() const [member function]
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## ssid.h: bool ns3::SsidValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_virtual=True)
+    ## ssid.h: ns3::Ssid ns3::SsidValue::Get() const [member function]
+    cls.add_method('Get', 
+                   'ns3::Ssid', 
+                   [], 
+                   is_const=True)
+    ## ssid.h: std::string ns3::SsidValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, is_virtual=True)
+    ## ssid.h: void ns3::SsidValue::Set(ns3::Ssid const & value) [member function]
+    cls.add_method('Set', 
+                   'void', 
+                   [param('ns3::Ssid const &', 'value')])
+    return
+
 def register_Ns3WifiChannel_methods(root_module, cls):
     ## wifi-channel.h: ns3::WifiChannel::WifiChannel() [constructor]
     cls.add_constructor([])
@@ -5202,6 +5284,46 @@ def register_Ns3WifiChannel_methods(root_module, cls):
                    is_static=True)
     return
 
+def register_Ns3WifiModeChecker_methods(root_module, cls):
+    ## wifi-mode.h: ns3::WifiModeChecker::WifiModeChecker() [constructor]
+    cls.add_constructor([])
+    ## wifi-mode.h: ns3::WifiModeChecker::WifiModeChecker(ns3::WifiModeChecker const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::WifiModeChecker const &', 'arg0')])
+    return
+
+def register_Ns3WifiModeValue_methods(root_module, cls):
+    ## wifi-mode.h: ns3::WifiModeValue::WifiModeValue() [constructor]
+    cls.add_constructor([])
+    ## wifi-mode.h: ns3::WifiModeValue::WifiModeValue(ns3::WifiModeValue const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::WifiModeValue const &', 'arg0')])
+    ## wifi-mode.h: ns3::WifiModeValue::WifiModeValue(ns3::WifiMode const & value) [constructor]
+    cls.add_constructor([param('ns3::WifiMode const &', 'value')])
+    ## wifi-mode.h: ns3::Ptr<ns3::AttributeValue> ns3::WifiModeValue::Copy() const [member function]
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## wifi-mode.h: bool ns3::WifiModeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_virtual=True)
+    ## wifi-mode.h: ns3::WifiMode ns3::WifiModeValue::Get() const [member function]
+    cls.add_method('Get', 
+                   'ns3::WifiMode', 
+                   [], 
+                   is_const=True)
+    ## wifi-mode.h: std::string ns3::WifiModeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, is_virtual=True)
+    ## wifi-mode.h: void ns3::WifiModeValue::Set(ns3::WifiMode const & value) [member function]
+    cls.add_method('Set', 
+                   'void', 
+                   [param('ns3::WifiMode const &', 'value')])
+    return
+
 def register_Ns3WifiNetDevice_methods(root_module, cls):
     ## wifi-net-device.h: ns3::WifiNetDevice::WifiNetDevice(ns3::WifiNetDevice const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::WifiNetDevice const &', 'arg0')])
@@ -5364,6 +5486,11 @@ def register_Ns3WifiNetDevice_methods(root_module, cls):
                    'void', 
                    [], 
                    visibility='private', is_virtual=True)
+    ## wifi-net-device.h: void ns3::WifiNetDevice::DoStart() [member function]
+    cls.add_method('DoStart', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
     return
 
 def register_Ns3YansErrorRateModel_methods(root_module, cls):
@@ -5537,6 +5664,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -5552,6 +5680,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/callbacks_list.py

@@ -4,18 +4,21 @@ callback_classes = [
     ['void', 'ns3::Ptr<ns3::Packet>', 'ns3::Mac48Address', 'ns3::Mac48Address', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['void', 'ns3::Mac48Address', 'ns3::Mac48Address', 'unsigned int', 'bool', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['void', 'unsigned int', 'ns3::Mac48Address', 'ns3::Mac48Address', 'ns3::dot11s::PeerLink::PeerState', 'ns3::dot11s::PeerLink::PeerState', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
-    ['void', 'ns3::WifiMacHeader const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['unsigned int', 'ns3::Mac48Address', 'ns3::Ptr<ns3::MeshWifiInterfaceMac>', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['void', 'ns3::Ptr<ns3::Packet>', 'ns3::WifiMacHeader const*', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
+    ['std::vector<ns3::Mac48Address, std::allocator<ns3::Mac48Address> >', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
+    ['void', 'bool', 'ns3::Ptr<ns3::Packet>', 'ns3::Mac48Address', 'ns3::Mac48Address', 'unsigned short', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
+    ['void', 'ns3::WifiMacHeader const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
+    ['bool', 'std::string', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
+    ['bool', 'ns3::Ptr<ns3::NetDevice>', 'ns3::Ptr<ns3::Packet const>', 'unsigned short', 'ns3::Address const&', 'ns3::Address const&', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
+    ['bool', 'ns3::Ptr<ns3::NetDevice>', 'ns3::Ptr<ns3::Packet const>', 'unsigned short', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
+    ['void', 'ns3::Ptr<ns3::Packet const>', 'ns3::Ipv4Header const&', 'ns3::Socket::SocketErrno', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
+    ['void', 'ns3::Ptr<ns3::Ipv4Route>', 'ns3::Ptr<ns3::Packet const>', 'ns3::Ipv4Header const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['void', 'ns3::Ptr<ns3::Socket>', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['void', 'ns3::Ptr<ns3::Socket>', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['void', 'ns3::Ptr<ns3::Socket>', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['bool', 'ns3::Ptr<ns3::Socket>', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
-    ['std::vector<ns3::Mac48Address, std::allocator<ns3::Mac48Address> >', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
-    ['void', 'bool', 'ns3::Ptr<ns3::Packet>', 'ns3::Mac48Address', 'ns3::Mac48Address', 'unsigned short', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
-    ['bool', 'std::string', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
-    ['bool', 'ns3::Ptr<ns3::NetDevice>', 'ns3::Ptr<ns3::Packet const>', 'unsigned short', 'ns3::Address const&', 'ns3::Address const&', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
-    ['bool', 'ns3::Ptr<ns3::NetDevice>', 'ns3::Ptr<ns3::Packet const>', 'unsigned short', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
+    ['void', 'ns3::Ipv4Address', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['void', 'ns3::Ptr<ns3::ArpCache const>', 'ns3::Ipv4Address', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['void', 'ns3::Ptr<ns3::NetDevice>', 'ns3::Ptr<ns3::Packet const>', 'unsigned short', 'ns3::Address const&', 'ns3::Address const&', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
 ]

bindings/python/apidefs/gcc-LP64/ns3_module_bridge.py

@@ -26,6 +26,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -62,6 +68,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -290,6 +300,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -305,6 +316,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/ns3_module_common.py

@@ -21,8 +21,6 @@ def register_types(module):
     module.add_class('Item', outer_class=root_module['ns3::ByteTagList::Iterator'])
     ## data-rate.h: ns3::DataRate [class]
     module.add_class('DataRate')
-    ## packet.h: ns3::Packet [class]
-    module.add_class('Packet', memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
     ## packet-metadata.h: ns3::PacketMetadata [class]
     module.add_class('PacketMetadata')
     ## packet-metadata.h: ns3::PacketMetadata::Item [struct]
@@ -45,28 +43,34 @@ def register_types(module):
     module.add_class('Tag', parent=root_module['ns3::ObjectBase'])
     ## tag-buffer.h: ns3::TagBuffer [class]
     module.add_class('TagBuffer')
-    ## ascii-writer.h: ns3::AsciiWriter [class]
-    module.add_class('AsciiWriter', parent=root_module['ns3::RefCountBase'])
-    ## ascii-writer.h: ns3::AsciiWriter::Type [enumeration]
-    module.add_enum('Type', ['ENQUEUE', 'DEQUEUE', 'DROP', 'TX', 'RX'], outer_class=root_module['ns3::AsciiWriter'])
     ## chunk.h: ns3::Chunk [class]
     module.add_class('Chunk', parent=root_module['ns3::ObjectBase'])
-    ## data-rate.h: ns3::DataRateChecker [class]
-    module.add_class('DataRateChecker', parent=root_module['ns3::AttributeChecker'])
-    ## data-rate.h: ns3::DataRateValue [class]
-    module.add_class('DataRateValue', parent=root_module['ns3::AttributeValue'])
     ## header.h: ns3::Header [class]
     module.add_class('Header', parent=root_module['ns3::Chunk'])
     ## pcap-writer.h: ns3::PcapWriter [class]
     module.add_class('PcapWriter', parent=root_module['ns3::Object'])
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::AsciiWriter, ns3::empty, ns3::DefaultDeleter<ns3::AsciiWriter> > [class]
+    module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::AsciiWriter', 'ns3::empty', 'ns3::DefaultDeleter<ns3::AsciiWriter>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> > [class]
+    module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::Packet', 'ns3::empty', 'ns3::DefaultDeleter<ns3::Packet>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
     ## trailer.h: ns3::Trailer [class]
     module.add_class('Trailer', parent=root_module['ns3::Chunk'])
+    ## ascii-writer.h: ns3::AsciiWriter [class]
+    module.add_class('AsciiWriter', parent=root_module['ns3::SimpleRefCount< ns3::AsciiWriter, ns3::empty, ns3::DefaultDeleter<ns3::AsciiWriter> >'])
+    ## ascii-writer.h: ns3::AsciiWriter::Type [enumeration]
+    module.add_enum('Type', ['ENQUEUE', 'DEQUEUE', 'DROP', 'TX', 'RX'], outer_class=root_module['ns3::AsciiWriter'])
+    ## data-rate.h: ns3::DataRateChecker [class]
+    module.add_class('DataRateChecker', parent=root_module['ns3::AttributeChecker'])
+    ## data-rate.h: ns3::DataRateValue [class]
+    module.add_class('DataRateValue', parent=root_module['ns3::AttributeValue'])
     ## error-model.h: ns3::ErrorModel [class]
     module.add_class('ErrorModel', parent=root_module['ns3::Object'])
     ## error-model.h: ns3::ListErrorModel [class]
     module.add_class('ListErrorModel', parent=root_module['ns3::ErrorModel'])
     ## nix-vector.h: ns3::NixVector [class]
     module.add_class('NixVector', parent=root_module['ns3::Object'])
+    ## packet.h: ns3::Packet [class]
+    module.add_class('Packet', parent=root_module['ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> >'])
     ## error-model.h: ns3::RateErrorModel [class]
     module.add_class('RateErrorModel', parent=root_module['ns3::ErrorModel'])
     
@@ -88,6 +92,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -124,6 +134,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -149,7 +163,6 @@ def register_methods(root_module):
     register_Ns3ByteTagListIterator_methods(root_module, root_module['ns3::ByteTagList::Iterator'])
     register_Ns3ByteTagListIteratorItem_methods(root_module, root_module['ns3::ByteTagList::Iterator::Item'])
     register_Ns3DataRate_methods(root_module, root_module['ns3::DataRate'])
-    register_Ns3Packet_methods(root_module, root_module['ns3::Packet'])
     register_Ns3PacketMetadata_methods(root_module, root_module['ns3::PacketMetadata'])
     register_Ns3PacketMetadataItem_methods(root_module, root_module['ns3::PacketMetadata::Item'])
     register_Ns3PacketMetadataItemIterator_methods(root_module, root_module['ns3::PacketMetadata::ItemIterator'])
@@ -160,16 +173,17 @@ def register_methods(root_module):
     register_Ns3PcapFile_methods(root_module, root_module['ns3::PcapFile'])
     register_Ns3Tag_methods(root_module, root_module['ns3::Tag'])
     register_Ns3TagBuffer_methods(root_module, root_module['ns3::TagBuffer'])
-    register_Ns3AsciiWriter_methods(root_module, root_module['ns3::AsciiWriter'])
     register_Ns3Chunk_methods(root_module, root_module['ns3::Chunk'])
-    register_Ns3DataRateChecker_methods(root_module, root_module['ns3::DataRateChecker'])
-    register_Ns3DataRateValue_methods(root_module, root_module['ns3::DataRateValue'])
     register_Ns3Header_methods(root_module, root_module['ns3::Header'])
     register_Ns3PcapWriter_methods(root_module, root_module['ns3::PcapWriter'])
     register_Ns3Trailer_methods(root_module, root_module['ns3::Trailer'])
+    register_Ns3AsciiWriter_methods(root_module, root_module['ns3::AsciiWriter'])
+    register_Ns3DataRateChecker_methods(root_module, root_module['ns3::DataRateChecker'])
+    register_Ns3DataRateValue_methods(root_module, root_module['ns3::DataRateValue'])
     register_Ns3ErrorModel_methods(root_module, root_module['ns3::ErrorModel'])
     register_Ns3ListErrorModel_methods(root_module, root_module['ns3::ListErrorModel'])
     register_Ns3NixVector_methods(root_module, root_module['ns3::NixVector'])
+    register_Ns3Packet_methods(root_module, root_module['ns3::Packet'])
     register_Ns3RateErrorModel_methods(root_module, root_module['ns3::RateErrorModel'])
     return
 
@@ -529,184 +543,6 @@ def register_Ns3DataRate_methods(root_module, cls):
                    is_const=True)
     return
 
-def register_Ns3Packet_methods(root_module, cls):
-    cls.add_output_stream_operator()
-    ## packet.h: ns3::Packet::Packet() [constructor]
-    cls.add_constructor([])
-    ## packet.h: ns3::Packet::Packet(ns3::Packet const & o) [copy constructor]
-    cls.add_constructor([param('ns3::Packet const &', 'o')])
-    ## packet.h: ns3::Packet::Packet(uint32_t size) [constructor]
-    cls.add_constructor([param('uint32_t', 'size')])
-    ## packet.h: ns3::Packet::Packet(uint8_t const * buffer, uint32_t size) [constructor]
-    cls.add_constructor([param('uint8_t const *', 'buffer'), param('uint32_t', 'size')])
-    ## packet.h: void ns3::Packet::AddAtEnd(ns3::Ptr<ns3::Packet const> packet) [member function]
-    cls.add_method('AddAtEnd', 
-                   'void', 
-                   [param('ns3::Ptr< ns3::Packet const >', 'packet')])
-    ## packet.h: void ns3::Packet::AddByteTag(ns3::Tag const & tag) const [member function]
-    cls.add_method('AddByteTag', 
-                   'void', 
-                   [param('ns3::Tag const &', 'tag')], 
-                   is_const=True)
-    ## packet.h: void ns3::Packet::AddHeader(ns3::Header const & header) [member function]
-    cls.add_method('AddHeader', 
-                   'void', 
-                   [param('ns3::Header const &', 'header')])
-    ## packet.h: void ns3::Packet::AddPacketTag(ns3::Tag const & tag) const [member function]
-    cls.add_method('AddPacketTag', 
-                   'void', 
-                   [param('ns3::Tag const &', 'tag')], 
-                   is_const=True)
-    ## packet.h: void ns3::Packet::AddPaddingAtEnd(uint32_t size) [member function]
-    cls.add_method('AddPaddingAtEnd', 
-                   'void', 
-                   [param('uint32_t', 'size')])
-    ## packet.h: void ns3::Packet::AddTrailer(ns3::Trailer const & trailer) [member function]
-    cls.add_method('AddTrailer', 
-                   'void', 
-                   [param('ns3::Trailer const &', 'trailer')])
-    ## packet.h: ns3::PacketMetadata::ItemIterator ns3::Packet::BeginItem() const [member function]
-    cls.add_method('BeginItem', 
-                   'ns3::PacketMetadata::ItemIterator', 
-                   [], 
-                   is_const=True)
-    ## packet.h: ns3::Ptr<ns3::Packet> ns3::Packet::Copy() const [member function]
-    cls.add_method('Copy', 
-                   'ns3::Ptr< ns3::Packet >', 
-                   [], 
-                   is_const=True)
-    ## packet.h: uint32_t ns3::Packet::CopyData(uint8_t * buffer, uint32_t size) const [member function]
-    cls.add_method('CopyData', 
-                   'uint32_t', 
-                   [param('uint8_t *', 'buffer'), param('uint32_t', 'size')], 
-                   is_const=True)
-    ## packet.h: void ns3::Packet::CopyData(std::ostream * os, uint32_t size) const [member function]
-    cls.add_method('CopyData', 
-                   'void', 
-                   [param('std::ostream *', 'os'), param('uint32_t', 'size')], 
-                   is_const=True)
-    ## packet.h: ns3::Ptr<ns3::Packet> ns3::Packet::CreateFragment(uint32_t start, uint32_t length) const [member function]
-    cls.add_method('CreateFragment', 
-                   'ns3::Ptr< ns3::Packet >', 
-                   [param('uint32_t', 'start'), param('uint32_t', 'length')], 
-                   is_const=True)
-    ## packet.h: void ns3::Packet::Deserialize(ns3::Buffer buffer) [member function]
-    cls.add_method('Deserialize', 
-                   'void', 
-                   [param('ns3::Buffer', 'buffer')])
-    ## packet.h: static void ns3::Packet::EnableChecking() [member function]
-    cls.add_method('EnableChecking', 
-                   'void', 
-                   [], 
-                   is_static=True)
-    ## packet.h: static void ns3::Packet::EnablePrinting() [member function]
-    cls.add_method('EnablePrinting', 
-                   'void', 
-                   [], 
-                   is_static=True)
-    ## packet.h: bool ns3::Packet::FindFirstMatchingByteTag(ns3::Tag & tag) const [member function]
-    cls.add_method('FindFirstMatchingByteTag', 
-                   'bool', 
-                   [param('ns3::Tag &', 'tag')], 
-                   is_const=True)
-    ## packet.h: ns3::ByteTagIterator ns3::Packet::GetByteTagIterator() const [member function]
-    cls.add_method('GetByteTagIterator', 
-                   'ns3::ByteTagIterator', 
-                   [], 
-                   is_const=True)
-    ## packet.h: ns3::Ptr<ns3::NixVector> ns3::Packet::GetNixVector() const [member function]
-    cls.add_method('GetNixVector', 
-                   'ns3::Ptr< ns3::NixVector >', 
-                   [], 
-                   is_const=True)
-    ## packet.h: ns3::PacketTagIterator ns3::Packet::GetPacketTagIterator() const [member function]
-    cls.add_method('GetPacketTagIterator', 
-                   'ns3::PacketTagIterator', 
-                   [], 
-                   is_const=True)
-    ## packet.h: uint32_t ns3::Packet::GetSize() const [member function]
-    cls.add_method('GetSize', 
-                   'uint32_t', 
-                   [], 
-                   is_const=True)
-    ## packet.h: uint32_t ns3::Packet::GetUid() const [member function]
-    cls.add_method('GetUid', 
-                   'uint32_t', 
-                   [], 
-                   is_const=True)
-    ## packet.h: uint8_t const * ns3::Packet::PeekData() const [member function]
-    cls.add_method('PeekData', 
-                   'uint8_t const *', 
-                   [], 
-                   is_const=True)
-    ## packet.h: uint32_t ns3::Packet::PeekHeader(ns3::Header & header) const [member function]
-    cls.add_method('PeekHeader', 
-                   'uint32_t', 
-                   [param('ns3::Header &', 'header')], 
-                   is_const=True)
-    ## packet.h: bool ns3::Packet::PeekPacketTag(ns3::Tag & tag) const [member function]
-    cls.add_method('PeekPacketTag', 
-                   'bool', 
-                   [param('ns3::Tag &', 'tag')], 
-                   is_const=True)
-    ## packet.h: uint32_t ns3::Packet::PeekTrailer(ns3::Trailer & trailer) [member function]
-    cls.add_method('PeekTrailer', 
-                   'uint32_t', 
-                   [param('ns3::Trailer &', 'trailer')])
-    ## packet.h: void ns3::Packet::Print(std::ostream & os) const [member function]
-    cls.add_method('Print', 
-                   'void', 
-                   [param('std::ostream &', 'os')], 
-                   is_const=True)
-    ## packet.h: void ns3::Packet::PrintByteTags(std::ostream & os) const [member function]
-    cls.add_method('PrintByteTags', 
-                   'void', 
-                   [param('std::ostream &', 'os')], 
-                   is_const=True)
-    ## packet.h: void ns3::Packet::PrintPacketTags(std::ostream & os) const [member function]
-    cls.add_method('PrintPacketTags', 
-                   'void', 
-                   [param('std::ostream &', 'os')], 
-                   is_const=True)
-    ## packet.h: void ns3::Packet::RemoveAllByteTags() [member function]
-    cls.add_method('RemoveAllByteTags', 
-                   'void', 
-                   [])
-    ## packet.h: void ns3::Packet::RemoveAllPacketTags() [member function]
-    cls.add_method('RemoveAllPacketTags', 
-                   'void', 
-                   [])
-    ## packet.h: void ns3::Packet::RemoveAtEnd(uint32_t size) [member function]
-    cls.add_method('RemoveAtEnd', 
-                   'void', 
-                   [param('uint32_t', 'size')])
-    ## packet.h: void ns3::Packet::RemoveAtStart(uint32_t size) [member function]
-    cls.add_method('RemoveAtStart', 
-                   'void', 
-                   [param('uint32_t', 'size')])
-    ## packet.h: uint32_t ns3::Packet::RemoveHeader(ns3::Header & header) [member function]
-    cls.add_method('RemoveHeader', 
-                   'uint32_t', 
-                   [param('ns3::Header &', 'header')])
-    ## packet.h: bool ns3::Packet::RemovePacketTag(ns3::Tag & tag) [member function]
-    cls.add_method('RemovePacketTag', 
-                   'bool', 
-                   [param('ns3::Tag &', 'tag')])
-    ## packet.h: uint32_t ns3::Packet::RemoveTrailer(ns3::Trailer & trailer) [member function]
-    cls.add_method('RemoveTrailer', 
-                   'uint32_t', 
-                   [param('ns3::Trailer &', 'trailer')])
-    ## packet.h: ns3::Buffer ns3::Packet::Serialize() const [member function]
-    cls.add_method('Serialize', 
-                   'ns3::Buffer', 
-                   [], 
-                   is_const=True)
-    ## packet.h: void ns3::Packet::SetNixVector(ns3::Ptr<ns3::NixVector> arg0) [member function]
-    cls.add_method('SetNixVector', 
-                   'void', 
-                   [param('ns3::Ptr< ns3::NixVector >', 'arg0')])
-    return
-
 def register_Ns3PacketMetadata_methods(root_module, cls):
     ## packet-metadata.h: ns3::PacketMetadata::PacketMetadata(uint32_t uid, uint32_t size) [constructor]
     cls.add_constructor([param('uint32_t', 'uid'), param('uint32_t', 'size')])
@@ -903,6 +739,11 @@ def register_Ns3PcapFile_methods(root_module, cls):
     cls.add_method('Close', 
                    'void', 
                    [])
+    ## pcap-file.h: static bool ns3::PcapFile::Diff(std::string const & f1, std::string const & f2, uint32_t & sec, uint32_t & usec, uint32_t snapLen=ns3::PcapFile::SNAPLEN_DEFAULT) [member function]
+    cls.add_method('Diff', 
+                   'bool', 
+                   [param('std::string const &', 'f1'), param('std::string const &', 'f2'), param('uint32_t &', 'sec'), param('uint32_t &', 'usec'), param('uint32_t', 'snapLen', default_value='ns3::PcapFile::SNAPLEN_DEFAULT')], 
+                   is_static=True)
     ## pcap-file.h: uint32_t ns3::PcapFile::GetDataLinkType() [member function]
     cls.add_method('GetDataLinkType', 
                    'uint32_t', 
@@ -1052,20 +893,6 @@ def register_Ns3TagBuffer_methods(root_module, cls):
                    [param('uint8_t', 'v')])
     return
 
-def register_Ns3AsciiWriter_methods(root_module, cls):
-    ## ascii-writer.h: ns3::AsciiWriter::AsciiWriter(ns3::AsciiWriter const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::AsciiWriter const &', 'arg0')])
-    ## ascii-writer.h: static ns3::Ptr<ns3::AsciiWriter> ns3::AsciiWriter::Get(std::ostream & os) [member function]
-    cls.add_method('Get', 
-                   'ns3::Ptr< ns3::AsciiWriter >', 
-                   [param('std::ostream &', 'os')], 
-                   is_static=True)
-    ## ascii-writer.h: void ns3::AsciiWriter::WritePacket(ns3::AsciiWriter::Type type, std::string message, ns3::Ptr<ns3::Packet const> p) [member function]
-    cls.add_method('WritePacket', 
-                   'void', 
-                   [param('ns3::AsciiWriter::Type', 'type'), param('std::string', 'message'), param('ns3::Ptr< ns3::Packet const >', 'p')])
-    return
-
 def register_Ns3Chunk_methods(root_module, cls):
     ## chunk.h: ns3::Chunk::Chunk() [constructor]
     cls.add_constructor([])
@@ -1088,46 +915,6 @@ def register_Ns3Chunk_methods(root_module, cls):
                    is_pure_virtual=True, is_const=True, is_virtual=True)
     return
 
-def register_Ns3DataRateChecker_methods(root_module, cls):
-    ## data-rate.h: ns3::DataRateChecker::DataRateChecker() [constructor]
-    cls.add_constructor([])
-    ## data-rate.h: ns3::DataRateChecker::DataRateChecker(ns3::DataRateChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::DataRateChecker const &', 'arg0')])
-    return
-
-def register_Ns3DataRateValue_methods(root_module, cls):
-    ## data-rate.h: ns3::DataRateValue::DataRateValue() [constructor]
-    cls.add_constructor([])
-    ## data-rate.h: ns3::DataRateValue::DataRateValue(ns3::DataRateValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::DataRateValue const &', 'arg0')])
-    ## data-rate.h: ns3::DataRateValue::DataRateValue(ns3::DataRate const & value) [constructor]
-    cls.add_constructor([param('ns3::DataRate const &', 'value')])
-    ## data-rate.h: ns3::Ptr<ns3::AttributeValue> ns3::DataRateValue::Copy() const [member function]
-    cls.add_method('Copy', 
-                   'ns3::Ptr< ns3::AttributeValue >', 
-                   [], 
-                   is_const=True, is_virtual=True)
-    ## data-rate.h: bool ns3::DataRateValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
-    cls.add_method('DeserializeFromString', 
-                   'bool', 
-                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
-                   is_virtual=True)
-    ## data-rate.h: ns3::DataRate ns3::DataRateValue::Get() const [member function]
-    cls.add_method('Get', 
-                   'ns3::DataRate', 
-                   [], 
-                   is_const=True)
-    ## data-rate.h: std::string ns3::DataRateValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
-    cls.add_method('SerializeToString', 
-                   'std::string', 
-                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
-                   is_const=True, is_virtual=True)
-    ## data-rate.h: void ns3::DataRateValue::Set(ns3::DataRate const & value) [member function]
-    cls.add_method('Set', 
-                   'void', 
-                   [param('ns3::DataRate const &', 'value')])
-    return
-
 def register_Ns3Header_methods(root_module, cls):
     cls.add_output_stream_operator()
     ## header.h: ns3::Header::Header() [constructor]
@@ -1246,6 +1033,60 @@ def register_Ns3Trailer_methods(root_module, cls):
                    is_pure_virtual=True, is_const=True, is_virtual=True)
     return
 
+def register_Ns3AsciiWriter_methods(root_module, cls):
+    ## ascii-writer.h: ns3::AsciiWriter::AsciiWriter(ns3::AsciiWriter const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::AsciiWriter const &', 'arg0')])
+    ## ascii-writer.h: static ns3::Ptr<ns3::AsciiWriter> ns3::AsciiWriter::Get(std::ostream & os) [member function]
+    cls.add_method('Get', 
+                   'ns3::Ptr< ns3::AsciiWriter >', 
+                   [param('std::ostream &', 'os')], 
+                   is_static=True)
+    ## ascii-writer.h: void ns3::AsciiWriter::WritePacket(ns3::AsciiWriter::Type type, std::string message, ns3::Ptr<ns3::Packet const> p) [member function]
+    cls.add_method('WritePacket', 
+                   'void', 
+                   [param('ns3::AsciiWriter::Type', 'type'), param('std::string', 'message'), param('ns3::Ptr< ns3::Packet const >', 'p')])
+    return
+
+def register_Ns3DataRateChecker_methods(root_module, cls):
+    ## data-rate.h: ns3::DataRateChecker::DataRateChecker() [constructor]
+    cls.add_constructor([])
+    ## data-rate.h: ns3::DataRateChecker::DataRateChecker(ns3::DataRateChecker const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::DataRateChecker const &', 'arg0')])
+    return
+
+def register_Ns3DataRateValue_methods(root_module, cls):
+    ## data-rate.h: ns3::DataRateValue::DataRateValue() [constructor]
+    cls.add_constructor([])
+    ## data-rate.h: ns3::DataRateValue::DataRateValue(ns3::DataRateValue const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::DataRateValue const &', 'arg0')])
+    ## data-rate.h: ns3::DataRateValue::DataRateValue(ns3::DataRate const & value) [constructor]
+    cls.add_constructor([param('ns3::DataRate const &', 'value')])
+    ## data-rate.h: ns3::Ptr<ns3::AttributeValue> ns3::DataRateValue::Copy() const [member function]
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## data-rate.h: bool ns3::DataRateValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_virtual=True)
+    ## data-rate.h: ns3::DataRate ns3::DataRateValue::Get() const [member function]
+    cls.add_method('Get', 
+                   'ns3::DataRate', 
+                   [], 
+                   is_const=True)
+    ## data-rate.h: std::string ns3::DataRateValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, is_virtual=True)
+    ## data-rate.h: void ns3::DataRateValue::Set(ns3::DataRate const & value) [member function]
+    cls.add_method('Set', 
+                   'void', 
+                   [param('ns3::DataRate const &', 'value')])
+    return
+
 def register_Ns3ErrorModel_methods(root_module, cls):
     ## error-model.h: ns3::ErrorModel::ErrorModel(ns3::ErrorModel const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::ErrorModel const &', 'arg0')])
@@ -1374,6 +1215,184 @@ def register_Ns3NixVector_methods(root_module, cls):
                    is_const=True)
     return
 
+def register_Ns3Packet_methods(root_module, cls):
+    cls.add_output_stream_operator()
+    ## packet.h: ns3::Packet::Packet() [constructor]
+    cls.add_constructor([])
+    ## packet.h: ns3::Packet::Packet(ns3::Packet const & o) [copy constructor]
+    cls.add_constructor([param('ns3::Packet const &', 'o')])
+    ## packet.h: ns3::Packet::Packet(uint32_t size) [constructor]
+    cls.add_constructor([param('uint32_t', 'size')])
+    ## packet.h: ns3::Packet::Packet(uint8_t const * buffer, uint32_t size) [constructor]
+    cls.add_constructor([param('uint8_t const *', 'buffer'), param('uint32_t', 'size')])
+    ## packet.h: void ns3::Packet::AddAtEnd(ns3::Ptr<ns3::Packet const> packet) [member function]
+    cls.add_method('AddAtEnd', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Packet const >', 'packet')])
+    ## packet.h: void ns3::Packet::AddByteTag(ns3::Tag const & tag) const [member function]
+    cls.add_method('AddByteTag', 
+                   'void', 
+                   [param('ns3::Tag const &', 'tag')], 
+                   is_const=True)
+    ## packet.h: void ns3::Packet::AddHeader(ns3::Header const & header) [member function]
+    cls.add_method('AddHeader', 
+                   'void', 
+                   [param('ns3::Header const &', 'header')])
+    ## packet.h: void ns3::Packet::AddPacketTag(ns3::Tag const & tag) const [member function]
+    cls.add_method('AddPacketTag', 
+                   'void', 
+                   [param('ns3::Tag const &', 'tag')], 
+                   is_const=True)
+    ## packet.h: void ns3::Packet::AddPaddingAtEnd(uint32_t size) [member function]
+    cls.add_method('AddPaddingAtEnd', 
+                   'void', 
+                   [param('uint32_t', 'size')])
+    ## packet.h: void ns3::Packet::AddTrailer(ns3::Trailer const & trailer) [member function]
+    cls.add_method('AddTrailer', 
+                   'void', 
+                   [param('ns3::Trailer const &', 'trailer')])
+    ## packet.h: ns3::PacketMetadata::ItemIterator ns3::Packet::BeginItem() const [member function]
+    cls.add_method('BeginItem', 
+                   'ns3::PacketMetadata::ItemIterator', 
+                   [], 
+                   is_const=True)
+    ## packet.h: ns3::Ptr<ns3::Packet> ns3::Packet::Copy() const [member function]
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::Packet >', 
+                   [], 
+                   is_const=True)
+    ## packet.h: uint32_t ns3::Packet::CopyData(uint8_t * buffer, uint32_t size) const [member function]
+    cls.add_method('CopyData', 
+                   'uint32_t', 
+                   [param('uint8_t *', 'buffer'), param('uint32_t', 'size')], 
+                   is_const=True)
+    ## packet.h: void ns3::Packet::CopyData(std::ostream * os, uint32_t size) const [member function]
+    cls.add_method('CopyData', 
+                   'void', 
+                   [param('std::ostream *', 'os'), param('uint32_t', 'size')], 
+                   is_const=True)
+    ## packet.h: ns3::Ptr<ns3::Packet> ns3::Packet::CreateFragment(uint32_t start, uint32_t length) const [member function]
+    cls.add_method('CreateFragment', 
+                   'ns3::Ptr< ns3::Packet >', 
+                   [param('uint32_t', 'start'), param('uint32_t', 'length')], 
+                   is_const=True)
+    ## packet.h: void ns3::Packet::Deserialize(ns3::Buffer buffer) [member function]
+    cls.add_method('Deserialize', 
+                   'void', 
+                   [param('ns3::Buffer', 'buffer')])
+    ## packet.h: static void ns3::Packet::EnableChecking() [member function]
+    cls.add_method('EnableChecking', 
+                   'void', 
+                   [], 
+                   is_static=True)
+    ## packet.h: static void ns3::Packet::EnablePrinting() [member function]
+    cls.add_method('EnablePrinting', 
+                   'void', 
+                   [], 
+                   is_static=True)
+    ## packet.h: bool ns3::Packet::FindFirstMatchingByteTag(ns3::Tag & tag) const [member function]
+    cls.add_method('FindFirstMatchingByteTag', 
+                   'bool', 
+                   [param('ns3::Tag &', 'tag')], 
+                   is_const=True)
+    ## packet.h: ns3::ByteTagIterator ns3::Packet::GetByteTagIterator() const [member function]
+    cls.add_method('GetByteTagIterator', 
+                   'ns3::ByteTagIterator', 
+                   [], 
+                   is_const=True)
+    ## packet.h: ns3::Ptr<ns3::NixVector> ns3::Packet::GetNixVector() const [member function]
+    cls.add_method('GetNixVector', 
+                   'ns3::Ptr< ns3::NixVector >', 
+                   [], 
+                   is_const=True)
+    ## packet.h: ns3::PacketTagIterator ns3::Packet::GetPacketTagIterator() const [member function]
+    cls.add_method('GetPacketTagIterator', 
+                   'ns3::PacketTagIterator', 
+                   [], 
+                   is_const=True)
+    ## packet.h: uint32_t ns3::Packet::GetSize() const [member function]
+    cls.add_method('GetSize', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
+    ## packet.h: uint32_t ns3::Packet::GetUid() const [member function]
+    cls.add_method('GetUid', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
+    ## packet.h: uint8_t const * ns3::Packet::PeekData() const [member function]
+    cls.add_method('PeekData', 
+                   'uint8_t const *', 
+                   [], 
+                   deprecated=True, is_const=True)
+    ## packet.h: uint32_t ns3::Packet::PeekHeader(ns3::Header & header) const [member function]
+    cls.add_method('PeekHeader', 
+                   'uint32_t', 
+                   [param('ns3::Header &', 'header')], 
+                   is_const=True)
+    ## packet.h: bool ns3::Packet::PeekPacketTag(ns3::Tag & tag) const [member function]
+    cls.add_method('PeekPacketTag', 
+                   'bool', 
+                   [param('ns3::Tag &', 'tag')], 
+                   is_const=True)
+    ## packet.h: uint32_t ns3::Packet::PeekTrailer(ns3::Trailer & trailer) [member function]
+    cls.add_method('PeekTrailer', 
+                   'uint32_t', 
+                   [param('ns3::Trailer &', 'trailer')])
+    ## packet.h: void ns3::Packet::Print(std::ostream & os) const [member function]
+    cls.add_method('Print', 
+                   'void', 
+                   [param('std::ostream &', 'os')], 
+                   is_const=True)
+    ## packet.h: void ns3::Packet::PrintByteTags(std::ostream & os) const [member function]
+    cls.add_method('PrintByteTags', 
+                   'void', 
+                   [param('std::ostream &', 'os')], 
+                   is_const=True)
+    ## packet.h: void ns3::Packet::PrintPacketTags(std::ostream & os) const [member function]
+    cls.add_method('PrintPacketTags', 
+                   'void', 
+                   [param('std::ostream &', 'os')], 
+                   is_const=True)
+    ## packet.h: void ns3::Packet::RemoveAllByteTags() [member function]
+    cls.add_method('RemoveAllByteTags', 
+                   'void', 
+                   [])
+    ## packet.h: void ns3::Packet::RemoveAllPacketTags() [member function]
+    cls.add_method('RemoveAllPacketTags', 
+                   'void', 
+                   [])
+    ## packet.h: void ns3::Packet::RemoveAtEnd(uint32_t size) [member function]
+    cls.add_method('RemoveAtEnd', 
+                   'void', 
+                   [param('uint32_t', 'size')])
+    ## packet.h: void ns3::Packet::RemoveAtStart(uint32_t size) [member function]
+    cls.add_method('RemoveAtStart', 
+                   'void', 
+                   [param('uint32_t', 'size')])
+    ## packet.h: uint32_t ns3::Packet::RemoveHeader(ns3::Header & header) [member function]
+    cls.add_method('RemoveHeader', 
+                   'uint32_t', 
+                   [param('ns3::Header &', 'header')])
+    ## packet.h: bool ns3::Packet::RemovePacketTag(ns3::Tag & tag) [member function]
+    cls.add_method('RemovePacketTag', 
+                   'bool', 
+                   [param('ns3::Tag &', 'tag')])
+    ## packet.h: uint32_t ns3::Packet::RemoveTrailer(ns3::Trailer & trailer) [member function]
+    cls.add_method('RemoveTrailer', 
+                   'uint32_t', 
+                   [param('ns3::Trailer &', 'trailer')])
+    ## packet.h: ns3::Buffer ns3::Packet::Serialize() const [member function]
+    cls.add_method('Serialize', 
+                   'ns3::Buffer', 
+                   [], 
+                   is_const=True)
+    ## packet.h: void ns3::Packet::SetNixVector(ns3::Ptr<ns3::NixVector> arg0) [member function]
+    cls.add_method('SetNixVector', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::NixVector >', 'arg0')])
+    return
+
 def register_Ns3RateErrorModel_methods(root_module, cls):
     ## error-model.h: ns3::RateErrorModel::RateErrorModel(ns3::RateErrorModel const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::RateErrorModel const &', 'arg0')])
@@ -1442,6 +1461,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -1457,6 +1477,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/ns3_module_contrib.py

@@ -3,6 +3,8 @@ from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandler
 def register_types(module):
     root_module = module.get_root()
     
+    ## average.h: ns3::Average<double> [class]
+    module.add_class('Average', template_parameters=['double'])
     ## delay-jitter-estimation.h: ns3::DelayJitterEstimation [class]
     module.add_class('DelayJitterEstimation')
     ## event-garbage-collector.h: ns3::EventGarbageCollector [class]
@@ -58,6 +60,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -94,6 +102,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -111,6 +123,7 @@ def register_types_ns3_olsr(module):
     
 
 def register_methods(root_module):
+    register_Ns3Average__Double_methods(root_module, root_module['ns3::Average< double >'])
     register_Ns3DelayJitterEstimation_methods(root_module, root_module['ns3::DelayJitterEstimation'])
     register_Ns3EventGarbageCollector_methods(root_module, root_module['ns3::EventGarbageCollector'])
     register_Ns3FileConfig_methods(root_module, root_module['ns3::FileConfig'])
@@ -127,6 +140,71 @@ def register_methods(root_module):
     register_Ns3Gnuplot3dFunction_methods(root_module, root_module['ns3::Gnuplot3dFunction'])
     return
 
+def register_Ns3Average__Double_methods(root_module, cls):
+    ## average.h: ns3::Average<double>::Average(ns3::Average<double> const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::Average< double > const &', 'arg0')])
+    ## average.h: ns3::Average<double>::Average() [constructor]
+    cls.add_constructor([])
+    ## average.h: double ns3::Average<double>::Avg() const [member function]
+    cls.add_method('Avg', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## average.h: uint32_t ns3::Average<double>::Count() const [member function]
+    cls.add_method('Count', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
+    ## average.h: double ns3::Average<double>::Error90() const [member function]
+    cls.add_method('Error90', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## average.h: double ns3::Average<double>::Error95() const [member function]
+    cls.add_method('Error95', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## average.h: double ns3::Average<double>::Error99() const [member function]
+    cls.add_method('Error99', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## average.h: double ns3::Average<double>::Max() const [member function]
+    cls.add_method('Max', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## average.h: double ns3::Average<double>::Mean() const [member function]
+    cls.add_method('Mean', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## average.h: double ns3::Average<double>::Min() const [member function]
+    cls.add_method('Min', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## average.h: void ns3::Average<double>::Reset() [member function]
+    cls.add_method('Reset', 
+                   'void', 
+                   [])
+    ## average.h: double ns3::Average<double>::Stddev() const [member function]
+    cls.add_method('Stddev', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## average.h: void ns3::Average<double>::Update(double const & x) [member function]
+    cls.add_method('Update', 
+                   'void', 
+                   [param('double const &', 'x')])
+    ## average.h: double ns3::Average<double>::Var() const [member function]
+    cls.add_method('Var', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    return
+
 def register_Ns3DelayJitterEstimation_methods(root_module, cls):
     ## delay-jitter-estimation.h: ns3::DelayJitterEstimation::DelayJitterEstimation(ns3::DelayJitterEstimation const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::DelayJitterEstimation const &', 'arg0')])
@@ -501,6 +579,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -516,6 +595,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/ns3_module_csma.py

@@ -34,6 +34,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -70,6 +76,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -432,11 +442,6 @@ def register_Ns3CsmaNetDevice_methods(root_module, cls):
                    'void', 
                    [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Mac48Address', 'source'), param('ns3::Mac48Address', 'dest'), param('uint16_t', 'protocolNumber')], 
                    visibility='protected')
-    ## csma-net-device.h: bool ns3::CsmaNetDevice::ProcessHeader(ns3::Ptr<ns3::Packet> p, uint16_t & param) [member function]
-    cls.add_method('ProcessHeader', 
-                   'bool', 
-                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint16_t &', 'param')], 
-                   visibility='protected')
     return
 
 def register_functions(root_module):
@@ -444,6 +449,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -459,6 +465,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/ns3_module_dot11s.py

@@ -3,6 +3,8 @@ from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandler
 def register_types(module):
     root_module = module.get_root()
     
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::dot11s::IeBeaconTimingUnit, ns3::empty, ns3::DefaultDeleter<ns3::dot11s::IeBeaconTimingUnit> > [class]
+    module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::dot11s::IeBeaconTimingUnit', 'ns3::empty', 'ns3::DefaultDeleter<ns3::dot11s::IeBeaconTimingUnit>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
     
     ## Register a nested module for the namespace Config
     
@@ -22,6 +24,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -58,6 +66,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -65,14 +77,14 @@ def register_types_ns3_dot11s(module):
     module.add_enum('dot11sSynchronizationProtocolIdentifier', ['SYNC_NEIGHBOUR_OFFSET', 'SYNC_NULL'])
     ## ie-dot11s-configuration.h: ns3::dot11s::dot11sCongestionControlMode [enumeration]
     module.add_enum('dot11sCongestionControlMode', ['CONGESTION_SIGNALING', 'CONGESTION_NULL'])
-    ## ie-dot11s-configuration.h: ns3::dot11s::dot11sAuthenticationProtocol [enumeration]
-    module.add_enum('dot11sAuthenticationProtocol', ['AUTH_NULL', 'AUTH_SAE'])
-    ## ie-dot11s-peer-management.h: ns3::dot11s::PmpReasonCode [enumeration]
-    module.add_enum('PmpReasonCode', ['REASON11S_PEERING_CANCELLED', 'REASON11S_MESH_MAX_PEERS', 'REASON11S_MESH_CAPABILITY_POLICY_VIOLATION', 'REASON11S_MESH_CLOSE_RCVD', 'REASON11S_MESH_MAX_RETRIES', 'REASON11S_MESH_CONFIRM_TIMEOUT', 'REASON11S_MESH_INVALID_GTK', 'REASON11S_MESH_INCONSISTENT_PARAMETERS', 'REASON11S_MESH_INVALID_SECURITY_CAPABILITY', 'REASON11S_RESERVED'])
     ## ie-dot11s-configuration.h: ns3::dot11s::dot11sPathSelectionMetric [enumeration]
     module.add_enum('dot11sPathSelectionMetric', ['METRIC_AIRTIME'])
+    ## ie-dot11s-peer-management.h: ns3::dot11s::PmpReasonCode [enumeration]
+    module.add_enum('PmpReasonCode', ['REASON11S_PEERING_CANCELLED', 'REASON11S_MESH_MAX_PEERS', 'REASON11S_MESH_CAPABILITY_POLICY_VIOLATION', 'REASON11S_MESH_CLOSE_RCVD', 'REASON11S_MESH_MAX_RETRIES', 'REASON11S_MESH_CONFIRM_TIMEOUT', 'REASON11S_MESH_INVALID_GTK', 'REASON11S_MESH_INCONSISTENT_PARAMETERS', 'REASON11S_MESH_INVALID_SECURITY_CAPABILITY', 'REASON11S_RESERVED'])
     ## ie-dot11s-configuration.h: ns3::dot11s::dot11sPathSelectionProtocol [enumeration]
     module.add_enum('dot11sPathSelectionProtocol', ['PROTOCOL_HWMP'])
+    ## ie-dot11s-configuration.h: ns3::dot11s::dot11sAuthenticationProtocol [enumeration]
+    module.add_enum('dot11sAuthenticationProtocol', ['AUTH_NULL', 'AUTH_SAE'])
     ## ie-dot11s-configuration.h: ns3::dot11s::Dot11sMeshCapability [class]
     module.add_class('Dot11sMeshCapability')
     ## hwmp-protocol.h: ns3::dot11s::HwmpProtocol [class]
@@ -82,7 +94,7 @@ def register_types_ns3_dot11s(module):
     ## ie-dot11s-beacon-timing.h: ns3::dot11s::IeBeaconTiming [class]
     module.add_class('IeBeaconTiming', parent=root_module['ns3::WifiInformationElement'])
     ## ie-dot11s-beacon-timing.h: ns3::dot11s::IeBeaconTimingUnit [class]
-    module.add_class('IeBeaconTimingUnit', parent=root_module['ns3::RefCountBase'])
+    module.add_class('IeBeaconTimingUnit', parent=root_module['ns3::SimpleRefCount< ns3::dot11s::IeBeaconTimingUnit, ns3::empty, ns3::DefaultDeleter<ns3::dot11s::IeBeaconTimingUnit> >'])
     ## ie-dot11s-configuration.h: ns3::dot11s::IeConfiguration [class]
     module.add_class('IeConfiguration', parent=root_module['ns3::WifiInformationElement'])
     ## ie-dot11s-id.h: ns3::dot11s::IeMeshId [class]
@@ -599,6 +611,11 @@ def register_Ns3Dot11sPeerLink_methods(root_module, cls):
     cls.add_method('SetLocalAid', 
                    'void', 
                    [param('uint16_t', 'aid')])
+    ## peer-link.h: uint16_t ns3::dot11s::PeerLink::GetPeerAid() const [member function]
+    cls.add_method('GetPeerAid', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
     ## peer-link.h: void ns3::dot11s::PeerLink::SetBeaconTimingElement(ns3::dot11s::IeBeaconTiming beaconTiming) [member function]
     cls.add_method('SetBeaconTimingElement', 
                    'void', 
@@ -675,14 +692,15 @@ def register_Ns3Dot11sPeerManagementProtocol_methods(root_module, cls):
     cls.add_method('FindPeerLink', 
                    'ns3::Ptr< ns3::dot11s::PeerLink >', 
                    [param('uint32_t', 'interface'), param('ns3::Mac48Address', 'peerAddress')])
-    ## peer-management-protocol.h: std::vector<ns3::Mac48Address,std::allocator<ns3::Mac48Address> > ns3::dot11s::PeerManagementProtocol::GetActiveLinks(uint32_t interface) [member function]
-    cls.add_method('GetActiveLinks', 
-                   'std::vector< ns3::Mac48Address >', 
-                   [param('uint32_t', 'interface')])
     ## peer-management-protocol.h: ns3::Mac48Address ns3::dot11s::PeerManagementProtocol::GetAddress() [member function]
     cls.add_method('GetAddress', 
                    'ns3::Mac48Address', 
                    [])
+    ## peer-management-protocol.h: bool ns3::dot11s::PeerManagementProtocol::GetBeaconCollisionAvoidance() const [member function]
+    cls.add_method('GetBeaconCollisionAvoidance', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## peer-management-protocol.h: ns3::Ptr<ns3::dot11s::IeBeaconTiming> ns3::dot11s::PeerManagementProtocol::GetBeaconTimingElement(uint32_t interface) [member function]
     cls.add_method('GetBeaconTimingElement', 
                    'ns3::Ptr< ns3::dot11s::IeBeaconTiming >', 
@@ -696,6 +714,16 @@ def register_Ns3Dot11sPeerManagementProtocol_methods(root_module, cls):
     cls.add_method('GetNumberOfLinks', 
                    'uint8_t', 
                    [])
+    ## peer-management-protocol.h: std::vector<ns3::Ptr<ns3::dot11s::PeerLink>,std::allocator<ns3::Ptr<ns3::dot11s::PeerLink> > > ns3::dot11s::PeerManagementProtocol::GetPeerLinks() const [member function]
+    cls.add_method('GetPeerLinks', 
+                   'std::vector< ns3::Ptr< ns3::dot11s::PeerLink > >', 
+                   [], 
+                   is_const=True)
+    ## peer-management-protocol.h: std::vector<ns3::Mac48Address,std::allocator<ns3::Mac48Address> > ns3::dot11s::PeerManagementProtocol::GetPeers(uint32_t interface) const [member function]
+    cls.add_method('GetPeers', 
+                   'std::vector< ns3::Mac48Address >', 
+                   [param('uint32_t', 'interface')], 
+                   is_const=True)
     ## peer-management-protocol.h: static ns3::TypeId ns3::dot11s::PeerManagementProtocol::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -709,6 +737,14 @@ def register_Ns3Dot11sPeerManagementProtocol_methods(root_module, cls):
     cls.add_method('IsActiveLink', 
                    'bool', 
                    [param('uint32_t', 'interface'), param('ns3::Mac48Address', 'peerAddress')])
+    ## peer-management-protocol.h: void ns3::dot11s::PeerManagementProtocol::NotifyBeaconSent(uint32_t interface, ns3::Time beaconInterval) [member function]
+    cls.add_method('NotifyBeaconSent', 
+                   'void', 
+                   [param('uint32_t', 'interface'), param('ns3::Time', 'beaconInterval')])
+    ## peer-management-protocol.h: void ns3::dot11s::PeerManagementProtocol::ReceiveBeacon(uint32_t interface, ns3::Mac48Address peerAddress, ns3::Time beaconInterval, ns3::Ptr<ns3::dot11s::IeBeaconTiming> beaconTiming) [member function]
+    cls.add_method('ReceiveBeacon', 
+                   'void', 
+                   [param('uint32_t', 'interface'), param('ns3::Mac48Address', 'peerAddress'), param('ns3::Time', 'beaconInterval'), param('ns3::Ptr< ns3::dot11s::IeBeaconTiming >', 'beaconTiming')])
     ## peer-management-protocol.h: void ns3::dot11s::PeerManagementProtocol::ReceivePeerLinkFrame(uint32_t interface, ns3::Mac48Address peerAddress, ns3::Mac48Address peerMeshPointAddress, uint16_t aid, ns3::dot11s::IePeerManagement peerManagementElement, ns3::dot11s::IeConfiguration meshConfig) [member function]
     cls.add_method('ReceivePeerLinkFrame', 
                    'void', 
@@ -722,6 +758,10 @@ def register_Ns3Dot11sPeerManagementProtocol_methods(root_module, cls):
     cls.add_method('ResetStats', 
                    'void', 
                    [])
+    ## peer-management-protocol.h: void ns3::dot11s::PeerManagementProtocol::SetBeaconCollisionAvoidance(bool enable) [member function]
+    cls.add_method('SetBeaconCollisionAvoidance', 
+                   'void', 
+                   [param('bool', 'enable')])
     ## peer-management-protocol.h: void ns3::dot11s::PeerManagementProtocol::SetMeshId(std::string s) [member function]
     cls.add_method('SetMeshId', 
                    'void', 
@@ -738,10 +778,6 @@ def register_Ns3Dot11sPeerManagementProtocol_methods(root_module, cls):
     cls.add_method('TransmissionSuccess', 
                    'void', 
                    [param('uint32_t', 'interface'), param('ns3::Mac48Address const', 'peerAddress')])
-    ## peer-management-protocol.h: void ns3::dot11s::PeerManagementProtocol::UpdatePeerBeaconTiming(uint32_t interface, bool meshBeacon, ns3::dot11s::IeBeaconTiming timingElement, ns3::Mac48Address peerAddress, ns3::Time receivingTime, ns3::Time beaconInterval) [member function]
-    cls.add_method('UpdatePeerBeaconTiming', 
-                   'void', 
-                   [param('uint32_t', 'interface'), param('bool', 'meshBeacon'), param('ns3::dot11s::IeBeaconTiming', 'timingElement'), param('ns3::Mac48Address', 'peerAddress'), param('ns3::Time', 'receivingTime'), param('ns3::Time', 'beaconInterval')])
     return
 
 def register_functions(root_module):
@@ -749,6 +785,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -764,6 +801,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     ## ie-dot11s-id.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::dot11s::MakeIeMeshIdChecker() [free function]
     module.add_function('MakeIeMeshIdChecker', 

bindings/python/apidefs/gcc-LP64/ns3_module_emu.py

@@ -5,6 +5,8 @@ def register_types(module):
     
     ## emu-net-device.h: ns3::EmuNetDevice [class]
     module.add_class('EmuNetDevice', parent=root_module['ns3::NetDevice'])
+    ## emu-net-device.h: ns3::EmuNetDevice::EncapsulationMode [enumeration]
+    module.add_enum('EncapsulationMode', ['ILLEGAL', 'DIX', 'LLC'], outer_class=root_module['ns3::EmuNetDevice'])
     
     ## Register a nested module for the namespace Config
     
@@ -24,6 +26,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -60,6 +68,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -105,6 +117,11 @@ def register_Ns3EmuNetDevice_methods(root_module, cls):
                    'ns3::Ptr< ns3::Channel >', 
                    [], 
                    is_const=True, is_virtual=True)
+    ## emu-net-device.h: ns3::EmuNetDevice::EncapsulationMode ns3::EmuNetDevice::GetEncapsulationMode() const [member function]
+    cls.add_method('GetEncapsulationMode', 
+                   'ns3::EmuNetDevice::EncapsulationMode', 
+                   [], 
+                   is_const=True)
     ## emu-net-device.h: uint32_t ns3::EmuNetDevice::GetIfIndex() const [member function]
     cls.add_method('GetIfIndex', 
                    'uint32_t', 
@@ -184,6 +201,10 @@ def register_Ns3EmuNetDevice_methods(root_module, cls):
     cls.add_method('SetDataRate', 
                    'void', 
                    [param('ns3::DataRate', 'bps')])
+    ## emu-net-device.h: void ns3::EmuNetDevice::SetEncapsulationMode(ns3::EmuNetDevice::EncapsulationMode mode) [member function]
+    cls.add_method('SetEncapsulationMode', 
+                   'void', 
+                   [param('ns3::EmuNetDevice::EncapsulationMode', 'mode')])
     ## emu-net-device.h: void ns3::EmuNetDevice::SetIfIndex(uint32_t const index) [member function]
     cls.add_method('SetIfIndex', 
                    'void', 
@@ -238,6 +259,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -253,6 +275,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/ns3_module_flame.py

@@ -22,6 +22,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -58,6 +64,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -171,6 +181,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -186,6 +197,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/ns3_module_flow_monitor.py

@@ -5,10 +5,18 @@ def register_types(module):
     
     ## histogram.h: ns3::Histogram [class]
     module.add_class('Histogram')
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::FlowClassifier, ns3::empty, ns3::DefaultDeleter<ns3::FlowClassifier> > [class]
+    module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::FlowClassifier', 'ns3::empty', 'ns3::DefaultDeleter<ns3::FlowClassifier>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::FlowProbe, ns3::empty, ns3::DefaultDeleter<ns3::FlowProbe> > [class]
+    module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::FlowProbe', 'ns3::empty', 'ns3::DefaultDeleter<ns3::FlowProbe>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
     ## flow-classifier.h: ns3::FlowClassifier [class]
-    module.add_class('FlowClassifier', parent=root_module['ns3::RefCountBase'])
+    module.add_class('FlowClassifier', parent=root_module['ns3::SimpleRefCount< ns3::FlowClassifier, ns3::empty, ns3::DefaultDeleter<ns3::FlowClassifier> >'])
+    ## flow-monitor.h: ns3::FlowMonitor [class]
+    module.add_class('FlowMonitor', parent=root_module['ns3::Object'])
+    ## flow-monitor.h: ns3::FlowMonitor::FlowStats [struct]
+    module.add_class('FlowStats', outer_class=root_module['ns3::FlowMonitor'])
     ## flow-probe.h: ns3::FlowProbe [class]
-    module.add_class('FlowProbe', parent=root_module['ns3::RefCountBase'])
+    module.add_class('FlowProbe', parent=root_module['ns3::SimpleRefCount< ns3::FlowProbe, ns3::empty, ns3::DefaultDeleter<ns3::FlowProbe> >'])
     ## flow-probe.h: ns3::FlowProbe::FlowStats [struct]
     module.add_class('FlowStats', outer_class=root_module['ns3::FlowProbe'])
     ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier [class]
@@ -19,12 +27,8 @@ def register_types(module):
     module.add_class('Ipv4FlowProbe', parent=root_module['ns3::FlowProbe'])
     ## ipv4-flow-probe.h: ns3::Ipv4FlowProbe::DropReason [enumeration]
     module.add_enum('DropReason', ['DROP_NO_ROUTE', 'DROP_TTL_EXPIRE', 'DROP_BAD_CHECKSUM', 'DROP_INVALID_REASON'], outer_class=root_module['ns3::Ipv4FlowProbe'])
-    ## flow-monitor.h: ns3::FlowMonitor [class]
-    module.add_class('FlowMonitor', parent=root_module['ns3::Object'])
-    ## flow-monitor.h: ns3::FlowMonitor::FlowStats [struct]
-    module.add_class('FlowStats', outer_class=root_module['ns3::FlowMonitor'])
-    module.add_container('std::map< unsigned int, ns3::FlowProbe::FlowStats >', ('unsigned int', 'ns3::FlowProbe::FlowStats'), container_type='map')
     module.add_container('std::map< unsigned int, ns3::FlowMonitor::FlowStats >', ('unsigned int', 'ns3::FlowMonitor::FlowStats'), container_type='map')
+    module.add_container('std::map< unsigned int, ns3::FlowProbe::FlowStats >', ('unsigned int', 'ns3::FlowProbe::FlowStats'), container_type='map')
     typehandlers.add_type_alias('uint32_t', 'ns3::FlowPacketId')
     typehandlers.add_type_alias('uint32_t*', 'ns3::FlowPacketId*')
     typehandlers.add_type_alias('uint32_t&', 'ns3::FlowPacketId&')
@@ -50,6 +54,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -86,6 +96,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -105,13 +119,13 @@ def register_types_ns3_olsr(module):
 def register_methods(root_module):
     register_Ns3Histogram_methods(root_module, root_module['ns3::Histogram'])
     register_Ns3FlowClassifier_methods(root_module, root_module['ns3::FlowClassifier'])
+    register_Ns3FlowMonitor_methods(root_module, root_module['ns3::FlowMonitor'])
+    register_Ns3FlowMonitorFlowStats_methods(root_module, root_module['ns3::FlowMonitor::FlowStats'])
     register_Ns3FlowProbe_methods(root_module, root_module['ns3::FlowProbe'])
     register_Ns3FlowProbeFlowStats_methods(root_module, root_module['ns3::FlowProbe::FlowStats'])
     register_Ns3Ipv4FlowClassifier_methods(root_module, root_module['ns3::Ipv4FlowClassifier'])
     register_Ns3Ipv4FlowClassifierFiveTuple_methods(root_module, root_module['ns3::Ipv4FlowClassifier::FiveTuple'])
     register_Ns3Ipv4FlowProbe_methods(root_module, root_module['ns3::Ipv4FlowProbe'])
-    register_Ns3FlowMonitor_methods(root_module, root_module['ns3::FlowMonitor'])
-    register_Ns3FlowMonitorFlowStats_methods(root_module, root_module['ns3::FlowMonitor::FlowStats'])
     return
 
 def register_Ns3Histogram_methods(root_module, cls):
@@ -159,8 +173,6 @@ def register_Ns3Histogram_methods(root_module, cls):
     return
 
 def register_Ns3FlowClassifier_methods(root_module, cls):
-    ## flow-classifier.h: ns3::FlowClassifier::FlowClassifier(ns3::FlowClassifier const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::FlowClassifier const &', 'arg0')])
     ## flow-classifier.h: ns3::FlowClassifier::FlowClassifier() [constructor]
     cls.add_constructor([])
     ## flow-classifier.h: void ns3::FlowClassifier::SerializeToXmlStream(std::ostream & os, int indent) const [member function]
@@ -175,96 +187,6 @@ def register_Ns3FlowClassifier_methods(root_module, cls):
                    visibility='protected')
     return
 
-def register_Ns3FlowProbe_methods(root_module, cls):
-    ## flow-probe.h: ns3::FlowProbe::FlowProbe(ns3::FlowProbe const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::FlowProbe const &', 'arg0')])
-    ## flow-probe.h: void ns3::FlowProbe::AddPacketDropStats(ns3::FlowId flowId, uint32_t packetSize, uint32_t reasonCode) [member function]
-    cls.add_method('AddPacketDropStats', 
-                   'void', 
-                   [param('ns3::FlowId', 'flowId'), param('uint32_t', 'packetSize'), param('uint32_t', 'reasonCode')])
-    ## flow-probe.h: void ns3::FlowProbe::AddPacketStats(ns3::FlowId flowId, uint32_t packetSize, ns3::Time delayFromFirstProbe) [member function]
-    cls.add_method('AddPacketStats', 
-                   'void', 
-                   [param('ns3::FlowId', 'flowId'), param('uint32_t', 'packetSize'), param('ns3::Time', 'delayFromFirstProbe')])
-    ## flow-probe.h: std::map<unsigned int, ns3::FlowProbe::FlowStats, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, ns3::FlowProbe::FlowStats> > > ns3::FlowProbe::GetStats() const [member function]
-    cls.add_method('GetStats', 
-                   'std::map< unsigned int, ns3::FlowProbe::FlowStats >', 
-                   [], 
-                   is_const=True)
-    ## flow-probe.h: void ns3::FlowProbe::SerializeToXmlStream(std::ostream & os, int indent, uint32_t index) const [member function]
-    cls.add_method('SerializeToXmlStream', 
-                   'void', 
-                   [param('std::ostream &', 'os'), param('int', 'indent'), param('uint32_t', 'index')], 
-                   is_const=True)
-    ## flow-probe.h: ns3::FlowProbe::FlowProbe(ns3::Ptr<ns3::FlowMonitor> flowMonitor) [constructor]
-    cls.add_constructor([param('ns3::Ptr< ns3::FlowMonitor >', 'flowMonitor')], 
-                        visibility='protected')
-    return
-
-def register_Ns3FlowProbeFlowStats_methods(root_module, cls):
-    ## flow-probe.h: ns3::FlowProbe::FlowStats::FlowStats(ns3::FlowProbe::FlowStats const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::FlowProbe::FlowStats const &', 'arg0')])
-    ## flow-probe.h: ns3::FlowProbe::FlowStats::FlowStats() [constructor]
-    cls.add_constructor([])
-    ## flow-probe.h: ns3::FlowProbe::FlowStats::bytes [variable]
-    cls.add_instance_attribute('bytes', 'uint64_t', is_const=False)
-    ## flow-probe.h: ns3::FlowProbe::FlowStats::bytesDropped [variable]
-    cls.add_instance_attribute('bytesDropped', 'std::vector< unsigned long >', is_const=False)
-    ## flow-probe.h: ns3::FlowProbe::FlowStats::delayFromFirstProbeSum [variable]
-    cls.add_instance_attribute('delayFromFirstProbeSum', 'ns3::Time', is_const=False)
-    ## flow-probe.h: ns3::FlowProbe::FlowStats::packets [variable]
-    cls.add_instance_attribute('packets', 'uint32_t', is_const=False)
-    ## flow-probe.h: ns3::FlowProbe::FlowStats::packetsDropped [variable]
-    cls.add_instance_attribute('packetsDropped', 'std::vector< unsigned int >', is_const=False)
-    return
-
-def register_Ns3Ipv4FlowClassifier_methods(root_module, cls):
-    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::Ipv4FlowClassifier(ns3::Ipv4FlowClassifier const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Ipv4FlowClassifier const &', 'arg0')])
-    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::Ipv4FlowClassifier() [constructor]
-    cls.add_constructor([])
-    ## ipv4-flow-classifier.h: bool ns3::Ipv4FlowClassifier::Classify(ns3::Ipv4Header const & ipHeader, ns3::Ptr<ns3::Packet const> ipPayload, uint32_t * out_flowId, uint32_t * out_packetId) [member function]
-    cls.add_method('Classify', 
-                   'bool', 
-                   [param('ns3::Ipv4Header const &', 'ipHeader'), param('ns3::Ptr< ns3::Packet const >', 'ipPayload'), param('uint32_t *', 'out_flowId'), param('uint32_t *', 'out_packetId')])
-    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple ns3::Ipv4FlowClassifier::FindFlow(ns3::FlowId flowId) const [member function]
-    cls.add_method('FindFlow', 
-                   'ns3::Ipv4FlowClassifier::FiveTuple', 
-                   [param('ns3::FlowId', 'flowId')], 
-                   is_const=True)
-    ## ipv4-flow-classifier.h: void ns3::Ipv4FlowClassifier::SerializeToXmlStream(std::ostream & os, int indent) const [member function]
-    cls.add_method('SerializeToXmlStream', 
-                   'void', 
-                   [param('std::ostream &', 'os'), param('int', 'indent')], 
-                   is_const=True, is_virtual=True)
-    return
-
-def register_Ns3Ipv4FlowClassifierFiveTuple_methods(root_module, cls):
-    cls.add_binary_comparison_operator('<')
-    cls.add_binary_comparison_operator('==')
-    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::FiveTuple() [constructor]
-    cls.add_constructor([])
-    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::FiveTuple(ns3::Ipv4FlowClassifier::FiveTuple const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Ipv4FlowClassifier::FiveTuple const &', 'arg0')])
-    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::destinationAddress [variable]
-    cls.add_instance_attribute('destinationAddress', 'ns3::Ipv4Address', is_const=False)
-    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::destinationPort [variable]
-    cls.add_instance_attribute('destinationPort', 'uint16_t', is_const=False)
-    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::protocol [variable]
-    cls.add_instance_attribute('protocol', 'uint8_t', is_const=False)
-    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::sourceAddress [variable]
-    cls.add_instance_attribute('sourceAddress', 'ns3::Ipv4Address', is_const=False)
-    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::sourcePort [variable]
-    cls.add_instance_attribute('sourcePort', 'uint16_t', is_const=False)
-    return
-
-def register_Ns3Ipv4FlowProbe_methods(root_module, cls):
-    ## ipv4-flow-probe.h: ns3::Ipv4FlowProbe::Ipv4FlowProbe(ns3::Ipv4FlowProbe const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Ipv4FlowProbe const &', 'arg0')])
-    ## ipv4-flow-probe.h: ns3::Ipv4FlowProbe::Ipv4FlowProbe(ns3::Ptr<ns3::FlowMonitor> monitor, ns3::Ptr<ns3::Ipv4FlowClassifier> classifier, ns3::Ptr<ns3::Node> node) [constructor]
-    cls.add_constructor([param('ns3::Ptr< ns3::FlowMonitor >', 'monitor'), param('ns3::Ptr< ns3::Ipv4FlowClassifier >', 'classifier'), param('ns3::Ptr< ns3::Node >', 'node')])
-    return
-
 def register_Ns3FlowMonitor_methods(root_module, cls):
     ## flow-monitor.h: ns3::FlowMonitor::FlowMonitor(ns3::FlowMonitor const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::FlowMonitor const &', 'arg0')])
@@ -400,11 +322,96 @@ def register_Ns3FlowMonitorFlowStats_methods(root_module, cls):
     cls.add_instance_attribute('txPackets', 'uint32_t', is_const=False)
     return
 
+def register_Ns3FlowProbe_methods(root_module, cls):
+    ## flow-probe.h: void ns3::FlowProbe::AddPacketDropStats(ns3::FlowId flowId, uint32_t packetSize, uint32_t reasonCode) [member function]
+    cls.add_method('AddPacketDropStats', 
+                   'void', 
+                   [param('ns3::FlowId', 'flowId'), param('uint32_t', 'packetSize'), param('uint32_t', 'reasonCode')])
+    ## flow-probe.h: void ns3::FlowProbe::AddPacketStats(ns3::FlowId flowId, uint32_t packetSize, ns3::Time delayFromFirstProbe) [member function]
+    cls.add_method('AddPacketStats', 
+                   'void', 
+                   [param('ns3::FlowId', 'flowId'), param('uint32_t', 'packetSize'), param('ns3::Time', 'delayFromFirstProbe')])
+    ## flow-probe.h: std::map<unsigned int, ns3::FlowProbe::FlowStats, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, ns3::FlowProbe::FlowStats> > > ns3::FlowProbe::GetStats() const [member function]
+    cls.add_method('GetStats', 
+                   'std::map< unsigned int, ns3::FlowProbe::FlowStats >', 
+                   [], 
+                   is_const=True)
+    ## flow-probe.h: void ns3::FlowProbe::SerializeToXmlStream(std::ostream & os, int indent, uint32_t index) const [member function]
+    cls.add_method('SerializeToXmlStream', 
+                   'void', 
+                   [param('std::ostream &', 'os'), param('int', 'indent'), param('uint32_t', 'index')], 
+                   is_const=True)
+    ## flow-probe.h: ns3::FlowProbe::FlowProbe(ns3::Ptr<ns3::FlowMonitor> flowMonitor) [constructor]
+    cls.add_constructor([param('ns3::Ptr< ns3::FlowMonitor >', 'flowMonitor')], 
+                        visibility='protected')
+    return
+
+def register_Ns3FlowProbeFlowStats_methods(root_module, cls):
+    ## flow-probe.h: ns3::FlowProbe::FlowStats::FlowStats(ns3::FlowProbe::FlowStats const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::FlowProbe::FlowStats const &', 'arg0')])
+    ## flow-probe.h: ns3::FlowProbe::FlowStats::FlowStats() [constructor]
+    cls.add_constructor([])
+    ## flow-probe.h: ns3::FlowProbe::FlowStats::bytes [variable]
+    cls.add_instance_attribute('bytes', 'uint64_t', is_const=False)
+    ## flow-probe.h: ns3::FlowProbe::FlowStats::bytesDropped [variable]
+    cls.add_instance_attribute('bytesDropped', 'std::vector< unsigned long >', is_const=False)
+    ## flow-probe.h: ns3::FlowProbe::FlowStats::delayFromFirstProbeSum [variable]
+    cls.add_instance_attribute('delayFromFirstProbeSum', 'ns3::Time', is_const=False)
+    ## flow-probe.h: ns3::FlowProbe::FlowStats::packets [variable]
+    cls.add_instance_attribute('packets', 'uint32_t', is_const=False)
+    ## flow-probe.h: ns3::FlowProbe::FlowStats::packetsDropped [variable]
+    cls.add_instance_attribute('packetsDropped', 'std::vector< unsigned int >', is_const=False)
+    return
+
+def register_Ns3Ipv4FlowClassifier_methods(root_module, cls):
+    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::Ipv4FlowClassifier() [constructor]
+    cls.add_constructor([])
+    ## ipv4-flow-classifier.h: bool ns3::Ipv4FlowClassifier::Classify(ns3::Ipv4Header const & ipHeader, ns3::Ptr<ns3::Packet const> ipPayload, uint32_t * out_flowId, uint32_t * out_packetId) [member function]
+    cls.add_method('Classify', 
+                   'bool', 
+                   [param('ns3::Ipv4Header const &', 'ipHeader'), param('ns3::Ptr< ns3::Packet const >', 'ipPayload'), param('uint32_t *', 'out_flowId'), param('uint32_t *', 'out_packetId')])
+    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple ns3::Ipv4FlowClassifier::FindFlow(ns3::FlowId flowId) const [member function]
+    cls.add_method('FindFlow', 
+                   'ns3::Ipv4FlowClassifier::FiveTuple', 
+                   [param('ns3::FlowId', 'flowId')], 
+                   is_const=True)
+    ## ipv4-flow-classifier.h: void ns3::Ipv4FlowClassifier::SerializeToXmlStream(std::ostream & os, int indent) const [member function]
+    cls.add_method('SerializeToXmlStream', 
+                   'void', 
+                   [param('std::ostream &', 'os'), param('int', 'indent')], 
+                   is_const=True, is_virtual=True)
+    return
+
+def register_Ns3Ipv4FlowClassifierFiveTuple_methods(root_module, cls):
+    cls.add_binary_comparison_operator('<')
+    cls.add_binary_comparison_operator('==')
+    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::FiveTuple() [constructor]
+    cls.add_constructor([])
+    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::FiveTuple(ns3::Ipv4FlowClassifier::FiveTuple const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::Ipv4FlowClassifier::FiveTuple const &', 'arg0')])
+    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::destinationAddress [variable]
+    cls.add_instance_attribute('destinationAddress', 'ns3::Ipv4Address', is_const=False)
+    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::destinationPort [variable]
+    cls.add_instance_attribute('destinationPort', 'uint16_t', is_const=False)
+    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::protocol [variable]
+    cls.add_instance_attribute('protocol', 'uint8_t', is_const=False)
+    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::sourceAddress [variable]
+    cls.add_instance_attribute('sourceAddress', 'ns3::Ipv4Address', is_const=False)
+    ## ipv4-flow-classifier.h: ns3::Ipv4FlowClassifier::FiveTuple::sourcePort [variable]
+    cls.add_instance_attribute('sourcePort', 'uint16_t', is_const=False)
+    return
+
+def register_Ns3Ipv4FlowProbe_methods(root_module, cls):
+    ## ipv4-flow-probe.h: ns3::Ipv4FlowProbe::Ipv4FlowProbe(ns3::Ptr<ns3::FlowMonitor> monitor, ns3::Ptr<ns3::Ipv4FlowClassifier> classifier, ns3::Ptr<ns3::Node> node) [constructor]
+    cls.add_constructor([param('ns3::Ptr< ns3::FlowMonitor >', 'monitor'), param('ns3::Ptr< ns3::Ipv4FlowClassifier >', 'classifier'), param('ns3::Ptr< ns3::Node >', 'node')])
+    return
+
 def register_functions(root_module):
     module = root_module
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -420,6 +427,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/ns3_module_global_routing.py

@@ -38,6 +38,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -74,6 +80,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -99,16 +109,6 @@ def register_methods(root_module):
     return
 
 def register_Ns3GlobalRouteManager_methods(root_module, cls):
-    ## global-route-manager.h: static void ns3::GlobalRouteManager::PopulateRoutingTables() [member function]
-    cls.add_method('PopulateRoutingTables', 
-                   'void', 
-                   [], 
-                   is_static=True, deprecated=True)
-    ## global-route-manager.h: static void ns3::GlobalRouteManager::RecomputeRoutingTables() [member function]
-    cls.add_method('RecomputeRoutingTables', 
-                   'void', 
-                   [], 
-                   is_static=True, deprecated=True)
     ## global-route-manager.h: static uint32_t ns3::GlobalRouteManager::AllocateRouterId() [member function]
     cls.add_method('AllocateRouterId', 
                    'uint32_t', 
@@ -410,15 +410,15 @@ def register_Ns3Ipv4GlobalRouting_methods(root_module, cls):
     cls.add_method('RemoveRoute', 
                    'void', 
                    [param('uint32_t', 'i')])
-    ## ipv4-global-routing.h: bool ns3::Ipv4GlobalRouting::RouteInput(ns3::Ptr<ns3::Packet const> p, ns3::Ipv4Header const & header, ns3::Ptr<const ns3::NetDevice> idev, ns3::Callback<void,ns3::Ptr<ns3::Ipv4Route>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ucb, ns3::Callback<void,ns3::Ptr<ns3::Ipv4MulticastRoute>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> mcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,unsigned int,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> lcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::Socket::SocketErrno,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ecb) [member function]
+    ## ipv4-global-routing.h: bool ns3::Ipv4GlobalRouting::RouteInput(ns3::Ptr<ns3::Packet const> p, ns3::Ipv4Header const & header, ns3::Ptr<const ns3::NetDevice> idev, ns3::Callback<void, ns3::Ptr<ns3::Ipv4Route>, ns3::Ptr<ns3::Packet const>, ns3::Ipv4Header const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ucb, ns3::Callback<void,ns3::Ptr<ns3::Ipv4MulticastRoute>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> mcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,unsigned int,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> lcb, ns3::Callback<void, ns3::Ptr<ns3::Packet const>, ns3::Ipv4Header const&, ns3::Socket::SocketErrno, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ecb) [member function]
     cls.add_method('RouteInput', 
                    'bool', 
                    [param('ns3::Ptr< ns3::Packet const >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice const >', 'idev'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv4Route >, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ucb'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv4MulticastRoute >, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'mcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'lcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::Socket::SocketErrno, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ecb')], 
                    is_virtual=True)
-    ## ipv4-global-routing.h: ns3::Ptr<ns3::Ipv4Route> ns3::Ipv4GlobalRouting::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Header const & header, uint32_t oif, ns3::Socket::SocketErrno & sockerr) [member function]
+    ## ipv4-global-routing.h: ns3::Ptr<ns3::Ipv4Route> ns3::Ipv4GlobalRouting::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Header const & header, ns3::Ptr<ns3::NetDevice> oif, ns3::Socket::SocketErrno & sockerr) [member function]
     cls.add_method('RouteOutput', 
                    'ns3::Ptr< ns3::Ipv4Route >', 
-                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('uint32_t', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice >', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
                    is_virtual=True)
     ## ipv4-global-routing.h: void ns3::Ipv4GlobalRouting::SetIpv4(ns3::Ptr<ns3::Ipv4> ipv4) [member function]
     cls.add_method('SetIpv4', 
@@ -437,6 +437,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -452,6 +453,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/ns3_module_helper.py

@@ -3,6 +3,8 @@ from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandler
 def register_types(module):
     root_module = module.get_root()
     
+    ## animation-interface.h: ns3::AnimationInterface [class]
+    module.add_class('AnimationInterface')
     ## application-container.h: ns3::ApplicationContainer [class]
     module.add_class('ApplicationContainer')
     ## athstats-helper.h: ns3::AthstatsHelper [class]
@@ -11,6 +13,8 @@ def register_types(module):
     module.add_class('BridgeHelper', allow_subclassing=False)
     ## csma-helper.h: ns3::CsmaHelper [class]
     module.add_class('CsmaHelper', allow_subclassing=False)
+    ## csma-star-helper.h: ns3::CsmaStarHelper [class]
+    module.add_class('CsmaStarHelper', allow_subclassing=False)
     ## emu-helper.h: ns3::EmuHelper [class]
     module.add_class('EmuHelper', allow_subclassing=False)
     ## flow-monitor-helper.h: ns3::FlowMonitorHelper [class]
@@ -55,14 +59,26 @@ def register_types(module):
     module.add_class('PacketSocketHelper', allow_subclassing=False)
     ## ping6-helper.h: ns3::Ping6Helper [class]
     module.add_class('Ping6Helper', allow_subclassing=False)
+    ## point-to-point-dumbbell-helper.h: ns3::PointToPointDumbbellHelper [class]
+    module.add_class('PointToPointDumbbellHelper', allow_subclassing=False)
+    ## point-to-point-grid-helper.h: ns3::PointToPointGridHelper [class]
+    module.add_class('PointToPointGridHelper', allow_subclassing=False)
     ## point-to-point-helper.h: ns3::PointToPointHelper [class]
     module.add_class('PointToPointHelper', allow_subclassing=False)
+    ## point-to-point-star-helper.h: ns3::PointToPointStarHelper [class]
+    module.add_class('PointToPointStarHelper', allow_subclassing=False)
     ## tap-bridge-helper.h: ns3::TapBridgeHelper [class]
     module.add_class('TapBridgeHelper', allow_subclassing=False)
+    ## udp-client-server-helper.h: ns3::UdpClientHelper [class]
+    module.add_class('UdpClientHelper', allow_subclassing=False)
     ## udp-echo-helper.h: ns3::UdpEchoClientHelper [class]
     module.add_class('UdpEchoClientHelper', allow_subclassing=False)
     ## udp-echo-helper.h: ns3::UdpEchoServerHelper [class]
     module.add_class('UdpEchoServerHelper', allow_subclassing=False)
+    ## udp-client-server-helper.h: ns3::UdpServerHelper [class]
+    module.add_class('UdpServerHelper', allow_subclassing=False)
+    ## udp-client-server-helper.h: ns3::UdpTraceClientHelper [class]
+    module.add_class('UdpTraceClientHelper', allow_subclassing=False)
     ## v4ping-helper.h: ns3::V4PingHelper [class]
     module.add_class('V4PingHelper', allow_subclassing=False)
     ## wifi-helper.h: ns3::WifiHelper [class]
@@ -77,6 +93,8 @@ def register_types(module):
     module.add_class('YansWifiPhyHelper', allow_subclassing=False, parent=root_module['ns3::WifiPhyHelper'])
     ## yans-wifi-helper.h: ns3::YansWifiPhyHelper::PcapFormat [enumeration]
     module.add_enum('PcapFormat', ['PCAP_FORMAT_80211', 'PCAP_FORMAT_80211_PRISM', 'PCAP_FORMAT_80211_RADIOTAP'], outer_class=root_module['ns3::YansWifiPhyHelper'])
+    ## aodv-helper.h: ns3::AodvHelper [class]
+    module.add_class('AodvHelper', allow_subclassing=False, parent=root_module['ns3::Ipv4RoutingHelper'])
     ## ipv4-global-routing-helper.h: ns3::Ipv4GlobalRoutingHelper [class]
     module.add_class('Ipv4GlobalRoutingHelper', allow_subclassing=False, parent=root_module['ns3::Ipv4RoutingHelper'])
     ## ipv4-list-routing-helper.h: ns3::Ipv4ListRoutingHelper [class]
@@ -91,6 +109,8 @@ def register_types(module):
     module.add_class('QosWifiMacHelper', allow_subclassing=False, parent=root_module['ns3::WifiMacHelper'])
     ## athstats-helper.h: ns3::AthstatsWifiTraceSink [class]
     module.add_class('AthstatsWifiTraceSink', parent=root_module['ns3::Object'])
+    ## canvas-location.h: ns3::CanvasLocation [class]
+    module.add_class('CanvasLocation', parent=root_module['ns3::Object'])
     ## mesh-stack-installer.h: ns3::MeshStack [class]
     module.add_class('MeshStack', parent=root_module['ns3::Object'])
     ## dot11s-installer.h: ns3::Dot11sStack [class]
@@ -116,6 +136,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -152,6 +178,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -169,10 +199,12 @@ def register_types_ns3_olsr(module):
     
 
 def register_methods(root_module):
+    register_Ns3AnimationInterface_methods(root_module, root_module['ns3::AnimationInterface'])
     register_Ns3ApplicationContainer_methods(root_module, root_module['ns3::ApplicationContainer'])
     register_Ns3AthstatsHelper_methods(root_module, root_module['ns3::AthstatsHelper'])
     register_Ns3BridgeHelper_methods(root_module, root_module['ns3::BridgeHelper'])
     register_Ns3CsmaHelper_methods(root_module, root_module['ns3::CsmaHelper'])
+    register_Ns3CsmaStarHelper_methods(root_module, root_module['ns3::CsmaStarHelper'])
     register_Ns3EmuHelper_methods(root_module, root_module['ns3::EmuHelper'])
     register_Ns3FlowMonitorHelper_methods(root_module, root_module['ns3::FlowMonitorHelper'])
     register_Ns3InternetStackHelper_methods(root_module, root_module['ns3::InternetStackHelper'])
@@ -194,16 +226,23 @@ def register_methods(root_module):
     register_Ns3PacketSinkHelper_methods(root_module, root_module['ns3::PacketSinkHelper'])
     register_Ns3PacketSocketHelper_methods(root_module, root_module['ns3::PacketSocketHelper'])
     register_Ns3Ping6Helper_methods(root_module, root_module['ns3::Ping6Helper'])
+    register_Ns3PointToPointDumbbellHelper_methods(root_module, root_module['ns3::PointToPointDumbbellHelper'])
+    register_Ns3PointToPointGridHelper_methods(root_module, root_module['ns3::PointToPointGridHelper'])
     register_Ns3PointToPointHelper_methods(root_module, root_module['ns3::PointToPointHelper'])
+    register_Ns3PointToPointStarHelper_methods(root_module, root_module['ns3::PointToPointStarHelper'])
     register_Ns3TapBridgeHelper_methods(root_module, root_module['ns3::TapBridgeHelper'])
+    register_Ns3UdpClientHelper_methods(root_module, root_module['ns3::UdpClientHelper'])
     register_Ns3UdpEchoClientHelper_methods(root_module, root_module['ns3::UdpEchoClientHelper'])
     register_Ns3UdpEchoServerHelper_methods(root_module, root_module['ns3::UdpEchoServerHelper'])
+    register_Ns3UdpServerHelper_methods(root_module, root_module['ns3::UdpServerHelper'])
+    register_Ns3UdpTraceClientHelper_methods(root_module, root_module['ns3::UdpTraceClientHelper'])
     register_Ns3V4PingHelper_methods(root_module, root_module['ns3::V4PingHelper'])
     register_Ns3WifiHelper_methods(root_module, root_module['ns3::WifiHelper'])
     register_Ns3WifiMacHelper_methods(root_module, root_module['ns3::WifiMacHelper'])
     register_Ns3WifiPhyHelper_methods(root_module, root_module['ns3::WifiPhyHelper'])
     register_Ns3YansWifiChannelHelper_methods(root_module, root_module['ns3::YansWifiChannelHelper'])
     register_Ns3YansWifiPhyHelper_methods(root_module, root_module['ns3::YansWifiPhyHelper'])
+    register_Ns3AodvHelper_methods(root_module, root_module['ns3::AodvHelper'])
     register_Ns3Ipv4GlobalRoutingHelper_methods(root_module, root_module['ns3::Ipv4GlobalRoutingHelper'])
     register_Ns3Ipv4ListRoutingHelper_methods(root_module, root_module['ns3::Ipv4ListRoutingHelper'])
     register_Ns3Ipv4NixVectorHelper_methods(root_module, root_module['ns3::Ipv4NixVectorHelper'])
@@ -211,11 +250,35 @@ def register_methods(root_module):
     register_Ns3NqosWifiMacHelper_methods(root_module, root_module['ns3::NqosWifiMacHelper'])
     register_Ns3QosWifiMacHelper_methods(root_module, root_module['ns3::QosWifiMacHelper'])
     register_Ns3AthstatsWifiTraceSink_methods(root_module, root_module['ns3::AthstatsWifiTraceSink'])
+    register_Ns3CanvasLocation_methods(root_module, root_module['ns3::CanvasLocation'])
     register_Ns3MeshStack_methods(root_module, root_module['ns3::MeshStack'])
     register_Ns3Dot11sStack_methods(root_module, root_module['ns3::Dot11sStack'])
     register_Ns3FlameStack_methods(root_module, root_module['ns3::FlameStack'])
     return
 
+def register_Ns3AnimationInterface_methods(root_module, cls):
+    ## animation-interface.h: ns3::AnimationInterface::AnimationInterface(ns3::AnimationInterface const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::AnimationInterface const &', 'arg0')])
+    ## animation-interface.h: ns3::AnimationInterface::AnimationInterface() [constructor]
+    cls.add_constructor([])
+    ## animation-interface.h: bool ns3::AnimationInterface::SetOutputFile(std::string const & fn) [member function]
+    cls.add_method('SetOutputFile', 
+                   'bool', 
+                   [param('std::string const &', 'fn')])
+    ## animation-interface.h: bool ns3::AnimationInterface::SetServerPort(uint16_t port) [member function]
+    cls.add_method('SetServerPort', 
+                   'bool', 
+                   [param('uint16_t', 'port')])
+    ## animation-interface.h: void ns3::AnimationInterface::StartAnimation() [member function]
+    cls.add_method('StartAnimation', 
+                   'void', 
+                   [])
+    ## animation-interface.h: void ns3::AnimationInterface::StopAnimation() [member function]
+    cls.add_method('StopAnimation', 
+                   'void', 
+                   [])
+    return
+
 def register_Ns3ApplicationContainer_methods(root_module, cls):
     ## application-container.h: ns3::ApplicationContainer::ApplicationContainer(ns3::ApplicationContainer const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::ApplicationContainer const &', 'arg0')])
@@ -409,14 +472,6 @@ def register_Ns3CsmaHelper_methods(root_module, cls):
                    'ns3::NetDeviceContainer', 
                    [param('ns3::NodeContainer const &', 'c'), param('std::string', 'channelName')], 
                    is_const=True)
-    ## csma-helper.h: void ns3::CsmaHelper::InstallStar(ns3::Ptr<ns3::Node> hub, ns3::NodeContainer spokes, ns3::NetDeviceContainer & hubDevices, ns3::NetDeviceContainer & spokeDevices) [member function]
-    cls.add_method('InstallStar', 
-                   'void', 
-                   [param('ns3::Ptr< ns3::Node >', 'hub'), param('ns3::NodeContainer', 'spokes'), param('ns3::NetDeviceContainer &', 'hubDevices'), param('ns3::NetDeviceContainer &', 'spokeDevices')])
-    ## csma-helper.h: void ns3::CsmaHelper::InstallStar(std::string hubName, ns3::NodeContainer spokes, ns3::NetDeviceContainer & hubDevices, ns3::NetDeviceContainer & spokeDevices) [member function]
-    cls.add_method('InstallStar', 
-                   'void', 
-                   [param('std::string', 'hubName'), param('ns3::NodeContainer', 'spokes'), param('ns3::NetDeviceContainer &', 'hubDevices'), param('ns3::NetDeviceContainer &', 'spokeDevices')])
     ## csma-helper.h: void ns3::CsmaHelper::SetChannelAttribute(std::string n1, ns3::AttributeValue const & v1) [member function]
     cls.add_method('SetChannelAttribute', 
                    'void', 
@@ -431,6 +486,56 @@ def register_Ns3CsmaHelper_methods(root_module, cls):
                    [param('std::string', 'type'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue const &', 'v1', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue const &', 'v2', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue const &', 'v3', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue const &', 'v4', default_value='ns3::EmptyAttributeValue()')])
     return
 
+def register_Ns3CsmaStarHelper_methods(root_module, cls):
+    ## csma-star-helper.h: ns3::CsmaStarHelper::CsmaStarHelper(ns3::CsmaStarHelper const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::CsmaStarHelper const &', 'arg0')])
+    ## csma-star-helper.h: ns3::CsmaStarHelper::CsmaStarHelper(uint32_t numSpokes, ns3::CsmaHelper csmaHelper) [constructor]
+    cls.add_constructor([param('uint32_t', 'numSpokes'), param('ns3::CsmaHelper', 'csmaHelper')])
+    ## csma-star-helper.h: void ns3::CsmaStarHelper::AssignIpv4Addresses(ns3::Ipv4AddressHelper address) [member function]
+    cls.add_method('AssignIpv4Addresses', 
+                   'void', 
+                   [param('ns3::Ipv4AddressHelper', 'address')])
+    ## csma-star-helper.h: ns3::Ptr<ns3::Node> ns3::CsmaStarHelper::GetHub() const [member function]
+    cls.add_method('GetHub', 
+                   'ns3::Ptr< ns3::Node >', 
+                   [], 
+                   is_const=True)
+    ## csma-star-helper.h: ns3::NetDeviceContainer ns3::CsmaStarHelper::GetHubDevices() const [member function]
+    cls.add_method('GetHubDevices', 
+                   'ns3::NetDeviceContainer', 
+                   [], 
+                   is_const=True)
+    ## csma-star-helper.h: ns3::Ipv4Address ns3::CsmaStarHelper::GetHubIpv4Address(uint32_t i) const [member function]
+    cls.add_method('GetHubIpv4Address', 
+                   'ns3::Ipv4Address', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
+    ## csma-star-helper.h: ns3::NetDeviceContainer ns3::CsmaStarHelper::GetSpokeDevices() const [member function]
+    cls.add_method('GetSpokeDevices', 
+                   'ns3::NetDeviceContainer', 
+                   [], 
+                   is_const=True)
+    ## csma-star-helper.h: ns3::Ipv4Address ns3::CsmaStarHelper::GetSpokeIpv4Address(uint32_t i) const [member function]
+    cls.add_method('GetSpokeIpv4Address', 
+                   'ns3::Ipv4Address', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
+    ## csma-star-helper.h: ns3::Ptr<ns3::Node> ns3::CsmaStarHelper::GetSpokeNode(uint32_t i) const [member function]
+    cls.add_method('GetSpokeNode', 
+                   'ns3::Ptr< ns3::Node >', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
+    ## csma-star-helper.h: void ns3::CsmaStarHelper::InstallStack(ns3::InternetStackHelper stack) [member function]
+    cls.add_method('InstallStack', 
+                   'void', 
+                   [param('ns3::InternetStackHelper', 'stack')])
+    ## csma-star-helper.h: uint32_t ns3::CsmaStarHelper::SpokeCount() const [member function]
+    cls.add_method('SpokeCount', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
+    return
+
 def register_Ns3EmuHelper_methods(root_module, cls):
     ## emu-helper.h: ns3::EmuHelper::EmuHelper(ns3::EmuHelper const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::EmuHelper const &', 'arg0')])
@@ -650,10 +755,10 @@ def register_Ns3Ipv4InterfaceContainer_methods(root_module, cls):
     cls.add_method('Add', 
                    'void', 
                    [param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')])
-    ## ipv4-interface-container.h: void ns3::Ipv4InterfaceContainer::Add(std::pair<ns3::Ptr<ns3::Ipv4>,unsigned int> arg0) [member function]
+    ## ipv4-interface-container.h: void ns3::Ipv4InterfaceContainer::Add(std::pair<ns3::Ptr<ns3::Ipv4>,unsigned int> ipInterfacePair) [member function]
     cls.add_method('Add', 
                    'void', 
-                   [param('std::pair< ns3::Ptr< ns3::Ipv4 >, unsigned int >', 'arg0')])
+                   [param('std::pair< ns3::Ptr< ns3::Ipv4 >, unsigned int >', 'ipInterfacePair')])
     ## ipv4-interface-container.h: void ns3::Ipv4InterfaceContainer::Add(std::string ipv4Name, uint32_t interface) [member function]
     cls.add_method('Add', 
                    'void', 
@@ -1230,6 +1335,96 @@ def register_Ns3Ping6Helper_methods(root_module, cls):
     cls.add_method('SetRemote', 
                    'void', 
                    [param('ns3::Ipv6Address', 'ip')])
+    ## ping6-helper.h: void ns3::Ping6Helper::SetRoutersAddress(std::vector<ns3::Ipv6Address, std::allocator<ns3::Ipv6Address> > routers) [member function]
+    cls.add_method('SetRoutersAddress', 
+                   'void', 
+                   [param('std::vector< ns3::Ipv6Address >', 'routers')])
+    return
+
+def register_Ns3PointToPointDumbbellHelper_methods(root_module, cls):
+    ## point-to-point-dumbbell-helper.h: ns3::PointToPointDumbbellHelper::PointToPointDumbbellHelper(ns3::PointToPointDumbbellHelper const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::PointToPointDumbbellHelper const &', 'arg0')])
+    ## point-to-point-dumbbell-helper.h: ns3::PointToPointDumbbellHelper::PointToPointDumbbellHelper(uint32_t nLeftLeaf, ns3::PointToPointHelper leftHelper, uint32_t nRightLeaf, ns3::PointToPointHelper rightHelper, ns3::PointToPointHelper bottleneckHelper) [constructor]
+    cls.add_constructor([param('uint32_t', 'nLeftLeaf'), param('ns3::PointToPointHelper', 'leftHelper'), param('uint32_t', 'nRightLeaf'), param('ns3::PointToPointHelper', 'rightHelper'), param('ns3::PointToPointHelper', 'bottleneckHelper')])
+    ## point-to-point-dumbbell-helper.h: void ns3::PointToPointDumbbellHelper::AssignIpv4Addresses(ns3::Ipv4AddressHelper leftIp, ns3::Ipv4AddressHelper rightIp, ns3::Ipv4AddressHelper routerIp) [member function]
+    cls.add_method('AssignIpv4Addresses', 
+                   'void', 
+                   [param('ns3::Ipv4AddressHelper', 'leftIp'), param('ns3::Ipv4AddressHelper', 'rightIp'), param('ns3::Ipv4AddressHelper', 'routerIp')])
+    ## point-to-point-dumbbell-helper.h: void ns3::PointToPointDumbbellHelper::BoundingBox(double arg0, double arg1, double arg2, double arg3) [member function]
+    cls.add_method('BoundingBox', 
+                   'void', 
+                   [param('double', 'arg0'), param('double', 'arg1'), param('double', 'arg2'), param('double', 'arg3')])
+    ## point-to-point-dumbbell-helper.h: ns3::Ptr<ns3::Node> ns3::PointToPointDumbbellHelper::GetLeft() const [member function]
+    cls.add_method('GetLeft', 
+                   'ns3::Ptr< ns3::Node >', 
+                   [], 
+                   is_const=True)
+    ## point-to-point-dumbbell-helper.h: ns3::Ptr<ns3::Node> ns3::PointToPointDumbbellHelper::GetLeft(uint32_t i) const [member function]
+    cls.add_method('GetLeft', 
+                   'ns3::Ptr< ns3::Node >', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
+    ## point-to-point-dumbbell-helper.h: ns3::Ipv4Address ns3::PointToPointDumbbellHelper::GetLeftIpv4Address(uint32_t i) const [member function]
+    cls.add_method('GetLeftIpv4Address', 
+                   'ns3::Ipv4Address', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
+    ## point-to-point-dumbbell-helper.h: ns3::Ptr<ns3::Node> ns3::PointToPointDumbbellHelper::GetRight() const [member function]
+    cls.add_method('GetRight', 
+                   'ns3::Ptr< ns3::Node >', 
+                   [], 
+                   is_const=True)
+    ## point-to-point-dumbbell-helper.h: ns3::Ptr<ns3::Node> ns3::PointToPointDumbbellHelper::GetRight(uint32_t i) const [member function]
+    cls.add_method('GetRight', 
+                   'ns3::Ptr< ns3::Node >', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
+    ## point-to-point-dumbbell-helper.h: ns3::Ipv4Address ns3::PointToPointDumbbellHelper::GetRightIpv4Address(uint32_t i) const [member function]
+    cls.add_method('GetRightIpv4Address', 
+                   'ns3::Ipv4Address', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
+    ## point-to-point-dumbbell-helper.h: void ns3::PointToPointDumbbellHelper::InstallStack(ns3::InternetStackHelper stack) [member function]
+    cls.add_method('InstallStack', 
+                   'void', 
+                   [param('ns3::InternetStackHelper', 'stack')])
+    ## point-to-point-dumbbell-helper.h: uint32_t ns3::PointToPointDumbbellHelper::LeftCount() const [member function]
+    cls.add_method('LeftCount', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
+    ## point-to-point-dumbbell-helper.h: uint32_t ns3::PointToPointDumbbellHelper::RightCount() const [member function]
+    cls.add_method('RightCount', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
+    return
+
+def register_Ns3PointToPointGridHelper_methods(root_module, cls):
+    ## point-to-point-grid-helper.h: ns3::PointToPointGridHelper::PointToPointGridHelper(ns3::PointToPointGridHelper const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::PointToPointGridHelper const &', 'arg0')])
+    ## point-to-point-grid-helper.h: ns3::PointToPointGridHelper::PointToPointGridHelper(uint32_t nRows, uint32_t nCols, ns3::PointToPointHelper pointToPoint) [constructor]
+    cls.add_constructor([param('uint32_t', 'nRows'), param('uint32_t', 'nCols'), param('ns3::PointToPointHelper', 'pointToPoint')])
+    ## point-to-point-grid-helper.h: void ns3::PointToPointGridHelper::AssignIpv4Addresses(ns3::Ipv4AddressHelper rowIp, ns3::Ipv4AddressHelper colIp) [member function]
+    cls.add_method('AssignIpv4Addresses', 
+                   'void', 
+                   [param('ns3::Ipv4AddressHelper', 'rowIp'), param('ns3::Ipv4AddressHelper', 'colIp')])
+    ## point-to-point-grid-helper.h: void ns3::PointToPointGridHelper::BoundingBox(double ulx, double uly, double lrx, double lry) [member function]
+    cls.add_method('BoundingBox', 
+                   'void', 
+                   [param('double', 'ulx'), param('double', 'uly'), param('double', 'lrx'), param('double', 'lry')])
+    ## point-to-point-grid-helper.h: ns3::Ipv4Address ns3::PointToPointGridHelper::GetIpv4Address(uint32_t row, uint32_t col) [member function]
+    cls.add_method('GetIpv4Address', 
+                   'ns3::Ipv4Address', 
+                   [param('uint32_t', 'row'), param('uint32_t', 'col')])
+    ## point-to-point-grid-helper.h: ns3::Ptr<ns3::Node> ns3::PointToPointGridHelper::GetNode(uint32_t row, uint32_t col) [member function]
+    cls.add_method('GetNode', 
+                   'ns3::Ptr< ns3::Node >', 
+                   [param('uint32_t', 'row'), param('uint32_t', 'col')])
+    ## point-to-point-grid-helper.h: void ns3::PointToPointGridHelper::InstallStack(ns3::InternetStackHelper stack) [member function]
+    cls.add_method('InstallStack', 
+                   'void', 
+                   [param('ns3::InternetStackHelper', 'stack')])
     return
 
 def register_Ns3PointToPointHelper_methods(root_module, cls):
@@ -1307,14 +1502,6 @@ def register_Ns3PointToPointHelper_methods(root_module, cls):
     cls.add_method('Install', 
                    'ns3::NetDeviceContainer', 
                    [param('std::string', 'aNode'), param('std::string', 'bNode')])
-    ## point-to-point-helper.h: void ns3::PointToPointHelper::InstallStar(ns3::Ptr<ns3::Node> hub, ns3::NodeContainer spokes, ns3::NetDeviceContainer & hubDevices, ns3::NetDeviceContainer & spokeDevices) [member function]
-    cls.add_method('InstallStar', 
-                   'void', 
-                   [param('ns3::Ptr< ns3::Node >', 'hub'), param('ns3::NodeContainer', 'spokes'), param('ns3::NetDeviceContainer &', 'hubDevices'), param('ns3::NetDeviceContainer &', 'spokeDevices')])
-    ## point-to-point-helper.h: void ns3::PointToPointHelper::InstallStar(std::string hubName, ns3::NodeContainer spokes, ns3::NetDeviceContainer & hubDevices, ns3::NetDeviceContainer & spokeDevices) [member function]
-    cls.add_method('InstallStar', 
-                   'void', 
-                   [param('std::string', 'hubName'), param('ns3::NodeContainer', 'spokes'), param('ns3::NetDeviceContainer &', 'hubDevices'), param('ns3::NetDeviceContainer &', 'spokeDevices')])
     ## point-to-point-helper.h: void ns3::PointToPointHelper::SetChannelAttribute(std::string name, ns3::AttributeValue const & value) [member function]
     cls.add_method('SetChannelAttribute', 
                    'void', 
@@ -1329,6 +1516,50 @@ def register_Ns3PointToPointHelper_methods(root_module, cls):
                    [param('std::string', 'type'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue const &', 'v1', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue const &', 'v2', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue const &', 'v3', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue const &', 'v4', default_value='ns3::EmptyAttributeValue()')])
     return
 
+def register_Ns3PointToPointStarHelper_methods(root_module, cls):
+    ## point-to-point-star-helper.h: ns3::PointToPointStarHelper::PointToPointStarHelper(ns3::PointToPointStarHelper const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::PointToPointStarHelper const &', 'arg0')])
+    ## point-to-point-star-helper.h: ns3::PointToPointStarHelper::PointToPointStarHelper(uint32_t numSpokes, ns3::PointToPointHelper p2pHelper) [constructor]
+    cls.add_constructor([param('uint32_t', 'numSpokes'), param('ns3::PointToPointHelper', 'p2pHelper')])
+    ## point-to-point-star-helper.h: void ns3::PointToPointStarHelper::AssignIpv4Addresses(ns3::Ipv4AddressHelper address) [member function]
+    cls.add_method('AssignIpv4Addresses', 
+                   'void', 
+                   [param('ns3::Ipv4AddressHelper', 'address')])
+    ## point-to-point-star-helper.h: void ns3::PointToPointStarHelper::BoundingBox(double ulx, double uly, double lrx, double lry) [member function]
+    cls.add_method('BoundingBox', 
+                   'void', 
+                   [param('double', 'ulx'), param('double', 'uly'), param('double', 'lrx'), param('double', 'lry')])
+    ## point-to-point-star-helper.h: ns3::Ptr<ns3::Node> ns3::PointToPointStarHelper::GetHub() const [member function]
+    cls.add_method('GetHub', 
+                   'ns3::Ptr< ns3::Node >', 
+                   [], 
+                   is_const=True)
+    ## point-to-point-star-helper.h: ns3::Ipv4Address ns3::PointToPointStarHelper::GetHubIpv4Address(uint32_t i) const [member function]
+    cls.add_method('GetHubIpv4Address', 
+                   'ns3::Ipv4Address', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
+    ## point-to-point-star-helper.h: ns3::Ipv4Address ns3::PointToPointStarHelper::GetSpokeIpv4Address(uint32_t i) const [member function]
+    cls.add_method('GetSpokeIpv4Address', 
+                   'ns3::Ipv4Address', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
+    ## point-to-point-star-helper.h: ns3::Ptr<ns3::Node> ns3::PointToPointStarHelper::GetSpokeNode(uint32_t i) const [member function]
+    cls.add_method('GetSpokeNode', 
+                   'ns3::Ptr< ns3::Node >', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
+    ## point-to-point-star-helper.h: void ns3::PointToPointStarHelper::InstallStack(ns3::InternetStackHelper stack) [member function]
+    cls.add_method('InstallStack', 
+                   'void', 
+                   [param('ns3::InternetStackHelper', 'stack')])
+    ## point-to-point-star-helper.h: uint32_t ns3::PointToPointStarHelper::SpokeCount() const [member function]
+    cls.add_method('SpokeCount', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
+    return
+
 def register_Ns3TapBridgeHelper_methods(root_module, cls):
     ## tap-bridge-helper.h: ns3::TapBridgeHelper::TapBridgeHelper(ns3::TapBridgeHelper const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::TapBridgeHelper const &', 'arg0')])
@@ -1362,6 +1593,23 @@ def register_Ns3TapBridgeHelper_methods(root_module, cls):
                    [param('std::string', 'n1'), param('ns3::AttributeValue const &', 'v1')])
     return
 
+def register_Ns3UdpClientHelper_methods(root_module, cls):
+    ## udp-client-server-helper.h: ns3::UdpClientHelper::UdpClientHelper(ns3::UdpClientHelper const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::UdpClientHelper const &', 'arg0')])
+    ## udp-client-server-helper.h: ns3::UdpClientHelper::UdpClientHelper() [constructor]
+    cls.add_constructor([])
+    ## udp-client-server-helper.h: ns3::UdpClientHelper::UdpClientHelper(ns3::Ipv4Address ip, uint16_t port) [constructor]
+    cls.add_constructor([param('ns3::Ipv4Address', 'ip'), param('uint16_t', 'port')])
+    ## udp-client-server-helper.h: ns3::ApplicationContainer ns3::UdpClientHelper::Install(ns3::NodeContainer c) [member function]
+    cls.add_method('Install', 
+                   'ns3::ApplicationContainer', 
+                   [param('ns3::NodeContainer', 'c')])
+    ## udp-client-server-helper.h: void ns3::UdpClientHelper::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function]
+    cls.add_method('SetAttribute', 
+                   'void', 
+                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
+    return
+
 def register_Ns3UdpEchoClientHelper_methods(root_module, cls):
     ## udp-echo-helper.h: ns3::UdpEchoClientHelper::UdpEchoClientHelper(ns3::UdpEchoClientHelper const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::UdpEchoClientHelper const &', 'arg0')])
@@ -1426,6 +1674,44 @@ def register_Ns3UdpEchoServerHelper_methods(root_module, cls):
                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
     return
 
+def register_Ns3UdpServerHelper_methods(root_module, cls):
+    ## udp-client-server-helper.h: ns3::UdpServerHelper::UdpServerHelper(ns3::UdpServerHelper const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::UdpServerHelper const &', 'arg0')])
+    ## udp-client-server-helper.h: ns3::UdpServerHelper::UdpServerHelper() [constructor]
+    cls.add_constructor([])
+    ## udp-client-server-helper.h: ns3::UdpServerHelper::UdpServerHelper(uint16_t port) [constructor]
+    cls.add_constructor([param('uint16_t', 'port')])
+    ## udp-client-server-helper.h: ns3::Ptr<ns3::UdpServer> ns3::UdpServerHelper::GetServer() [member function]
+    cls.add_method('GetServer', 
+                   'ns3::Ptr< ns3::UdpServer >', 
+                   [])
+    ## udp-client-server-helper.h: ns3::ApplicationContainer ns3::UdpServerHelper::Install(ns3::NodeContainer c) [member function]
+    cls.add_method('Install', 
+                   'ns3::ApplicationContainer', 
+                   [param('ns3::NodeContainer', 'c')])
+    ## udp-client-server-helper.h: void ns3::UdpServerHelper::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function]
+    cls.add_method('SetAttribute', 
+                   'void', 
+                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
+    return
+
+def register_Ns3UdpTraceClientHelper_methods(root_module, cls):
+    ## udp-client-server-helper.h: ns3::UdpTraceClientHelper::UdpTraceClientHelper(ns3::UdpTraceClientHelper const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::UdpTraceClientHelper const &', 'arg0')])
+    ## udp-client-server-helper.h: ns3::UdpTraceClientHelper::UdpTraceClientHelper() [constructor]
+    cls.add_constructor([])
+    ## udp-client-server-helper.h: ns3::UdpTraceClientHelper::UdpTraceClientHelper(ns3::Ipv4Address ip, uint16_t port, std::string filename) [constructor]
+    cls.add_constructor([param('ns3::Ipv4Address', 'ip'), param('uint16_t', 'port'), param('std::string', 'filename')])
+    ## udp-client-server-helper.h: ns3::ApplicationContainer ns3::UdpTraceClientHelper::Install(ns3::NodeContainer c) [member function]
+    cls.add_method('Install', 
+                   'ns3::ApplicationContainer', 
+                   [param('ns3::NodeContainer', 'c')])
+    ## udp-client-server-helper.h: void ns3::UdpTraceClientHelper::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function]
+    cls.add_method('SetAttribute', 
+                   'void', 
+                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
+    return
+
 def register_Ns3V4PingHelper_methods(root_module, cls):
     ## v4ping-helper.h: ns3::V4PingHelper::V4PingHelper(ns3::V4PingHelper const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::V4PingHelper const &', 'arg0')])
@@ -1446,6 +1732,10 @@ def register_Ns3V4PingHelper_methods(root_module, cls):
                    'ns3::ApplicationContainer', 
                    [param('std::string', 'nodeName')], 
                    is_const=True)
+    ## v4ping-helper.h: void ns3::V4PingHelper::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function]
+    cls.add_method('SetAttribute', 
+                   'void', 
+                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
     return
 
 def register_Ns3WifiHelper_methods(root_module, cls):
@@ -1618,6 +1908,27 @@ def register_Ns3YansWifiPhyHelper_methods(root_module, cls):
                    is_const=True, visibility='private', is_virtual=True)
     return
 
+def register_Ns3AodvHelper_methods(root_module, cls):
+    ## aodv-helper.h: ns3::AodvHelper::AodvHelper(ns3::AodvHelper const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::AodvHelper const &', 'arg0')])
+    ## aodv-helper.h: ns3::AodvHelper::AodvHelper() [constructor]
+    cls.add_constructor([])
+    ## aodv-helper.h: ns3::AodvHelper * ns3::AodvHelper::Copy() const [member function]
+    cls.add_method('Copy', 
+                   'ns3::AodvHelper *', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## aodv-helper.h: ns3::Ptr<ns3::Ipv4RoutingProtocol> ns3::AodvHelper::Create(ns3::Ptr<ns3::Node> node) const [member function]
+    cls.add_method('Create', 
+                   'ns3::Ptr< ns3::Ipv4RoutingProtocol >', 
+                   [param('ns3::Ptr< ns3::Node >', 'node')], 
+                   is_const=True, is_virtual=True)
+    ## aodv-helper.h: void ns3::AodvHelper::Set(std::string name, ns3::AttributeValue const & value) [member function]
+    cls.add_method('Set', 
+                   'void', 
+                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
+    return
+
 def register_Ns3Ipv4GlobalRoutingHelper_methods(root_module, cls):
     ## ipv4-global-routing-helper.h: ns3::Ipv4GlobalRoutingHelper::Ipv4GlobalRoutingHelper() [constructor]
     cls.add_constructor([])
@@ -1806,6 +2117,27 @@ def register_Ns3AthstatsWifiTraceSink_methods(root_module, cls):
                    [param('std::string', 'context'), param('ns3::Mac48Address', 'address')])
     return
 
+def register_Ns3CanvasLocation_methods(root_module, cls):
+    ## canvas-location.h: ns3::CanvasLocation::CanvasLocation(ns3::CanvasLocation const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::CanvasLocation const &', 'arg0')])
+    ## canvas-location.h: ns3::CanvasLocation::CanvasLocation() [constructor]
+    cls.add_constructor([])
+    ## canvas-location.h: ns3::Vector ns3::CanvasLocation::GetLocation() const [member function]
+    cls.add_method('GetLocation', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True)
+    ## canvas-location.h: static ns3::TypeId ns3::CanvasLocation::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## canvas-location.h: void ns3::CanvasLocation::SetLocation(ns3::Vector const & location) [member function]
+    cls.add_method('SetLocation', 
+                   'void', 
+                   [param('ns3::Vector const &', 'location')])
+    return
+
 def register_Ns3MeshStack_methods(root_module, cls):
     ## mesh-stack-installer.h: ns3::MeshStack::MeshStack() [constructor]
     cls.add_constructor([])
@@ -1897,6 +2229,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -1912,6 +2245,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/ns3_module_list_routing.py

@@ -26,6 +26,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -62,6 +68,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -128,15 +138,15 @@ def register_Ns3Ipv4ListRouting_methods(root_module, cls):
                    'void', 
                    [param('uint32_t', 'interface'), param('ns3::Ipv4InterfaceAddress', 'address')], 
                    is_virtual=True)
-    ## ipv4-list-routing.h: bool ns3::Ipv4ListRouting::RouteInput(ns3::Ptr<ns3::Packet const> p, ns3::Ipv4Header const & header, ns3::Ptr<const ns3::NetDevice> idev, ns3::Callback<void,ns3::Ptr<ns3::Ipv4Route>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ucb, ns3::Callback<void,ns3::Ptr<ns3::Ipv4MulticastRoute>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> mcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,unsigned int,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> lcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::Socket::SocketErrno,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ecb) [member function]
+    ## ipv4-list-routing.h: bool ns3::Ipv4ListRouting::RouteInput(ns3::Ptr<ns3::Packet const> p, ns3::Ipv4Header const & header, ns3::Ptr<const ns3::NetDevice> idev, ns3::Callback<void, ns3::Ptr<ns3::Ipv4Route>, ns3::Ptr<ns3::Packet const>, ns3::Ipv4Header const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ucb, ns3::Callback<void,ns3::Ptr<ns3::Ipv4MulticastRoute>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> mcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,unsigned int,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> lcb, ns3::Callback<void, ns3::Ptr<ns3::Packet const>, ns3::Ipv4Header const&, ns3::Socket::SocketErrno, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ecb) [member function]
     cls.add_method('RouteInput', 
                    'bool', 
                    [param('ns3::Ptr< ns3::Packet const >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice const >', 'idev'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv4Route >, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ucb'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv4MulticastRoute >, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'mcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'lcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::Socket::SocketErrno, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ecb')], 
                    is_virtual=True)
-    ## ipv4-list-routing.h: ns3::Ptr<ns3::Ipv4Route> ns3::Ipv4ListRouting::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Header const & header, uint32_t oif, ns3::Socket::SocketErrno & sockerr) [member function]
+    ## ipv4-list-routing.h: ns3::Ptr<ns3::Ipv4Route> ns3::Ipv4ListRouting::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Header const & header, ns3::Ptr<ns3::NetDevice> oif, ns3::Socket::SocketErrno & sockerr) [member function]
     cls.add_method('RouteOutput', 
                    'ns3::Ptr< ns3::Ipv4Route >', 
-                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('uint32_t', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice >', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
                    is_virtual=True)
     ## ipv4-list-routing.h: void ns3::Ipv4ListRouting::SetIpv4(ns3::Ptr<ns3::Ipv4> ipv4) [member function]
     cls.add_method('SetIpv4', 
@@ -148,6 +158,11 @@ def register_Ns3Ipv4ListRouting_methods(root_module, cls):
                    'void', 
                    [], 
                    visibility='protected', is_virtual=True)
+    ## ipv4-list-routing.h: void ns3::Ipv4ListRouting::DoStart() [member function]
+    cls.add_method('DoStart', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
     return
 
 def register_Ns3Ipv6ListRouting_methods(root_module, cls):
@@ -210,10 +225,10 @@ def register_Ns3Ipv6ListRouting_methods(root_module, cls):
                    'bool', 
                    [param('ns3::Ptr< ns3::Packet const >', 'p'), param('ns3::Ipv6Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice const >', 'idev'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv6Route >, ns3::Ptr< ns3::Packet const >, ns3::Ipv6Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ucb'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv6MulticastRoute >, ns3::Ptr< ns3::Packet const >, ns3::Ipv6Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'mcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv6Header const &, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'lcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv6Header const &, ns3::Socket::SocketErrno, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ecb')], 
                    is_virtual=True)
-    ## ipv6-list-routing.h: ns3::Ptr<ns3::Ipv6Route> ns3::Ipv6ListRouting::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv6Header const & header, uint32_t oif, ns3::Socket::SocketErrno & sockerr) [member function]
+    ## ipv6-list-routing.h: ns3::Ptr<ns3::Ipv6Route> ns3::Ipv6ListRouting::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv6Header const & header, ns3::Ptr<ns3::NetDevice> oif, ns3::Socket::SocketErrno & sockerr) [member function]
     cls.add_method('RouteOutput', 
                    'ns3::Ptr< ns3::Ipv6Route >', 
-                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv6Header const &', 'header'), param('uint32_t', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv6Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice >', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
                    is_virtual=True)
     ## ipv6-list-routing.h: void ns3::Ipv6ListRouting::SetIpv6(ns3::Ptr<ns3::Ipv6> ipv6) [member function]
     cls.add_method('SetIpv6', 
@@ -232,6 +247,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -247,6 +263,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/ns3_module_mesh.py

@@ -7,16 +7,20 @@ def register_types(module):
     module.add_enum('WifiElementId', ['IE11S_MESH_CONFIGURATION', 'IE11S_MESH_ID', 'IE11S_LINK_METRIC_REPORT', 'IE11S_CONGESTION_NOTIFICATION', 'IE11S_PEERING_MANAGEMENT', 'IE11S_SUPP_MBSS_REG_CLASSES_CHANNELS', 'IE11S_MESH_CHANNEL_SWITCH_ANNOUNCEMENT', 'IE11S_MESH_TIM', 'IE11S_AWAKE_WINDOW', 'IE11S_BEACON_TIMING', 'IE11S_MCCAOP_SETUP_REQUEST', 'IE11S_MCCAOP_SETUP_REPLY', 'IE11S_MCCAOP_ADVERTISEMENT', 'IE11S_MCCAOP_RESERVATION_TEARDOWN', 'IE11S_PORTAL_ANNOUNCEMENT', 'IE11S_RANN', 'IE11S_PREQ', 'IE11S_PREP', 'IE11S_PERR', 'IE11S_PROXY_UPDATE', 'IE11S_PROXY_UPDATE_CONFIRMATION', 'IE11S_ABBREVIATED_HANDSHAKE', 'IE11S_MESH_PEERING_PROTOCOL_VERSION'])
     ## mesh-wifi-beacon.h: ns3::MeshWifiBeacon [class]
     module.add_class('MeshWifiBeacon')
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::MeshWifiInterfaceMacPlugin, ns3::empty, ns3::DefaultDeleter<ns3::MeshWifiInterfaceMacPlugin> > [class]
+    module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::MeshWifiInterfaceMacPlugin', 'ns3::empty', 'ns3::DefaultDeleter<ns3::MeshWifiInterfaceMacPlugin>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::WifiInformationElement, ns3::empty, ns3::DefaultDeleter<ns3::WifiInformationElement> > [class]
+    module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::WifiInformationElement', 'ns3::empty', 'ns3::DefaultDeleter<ns3::WifiInformationElement>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
     ## wifi-information-element-vector.h: ns3::WifiInformationElement [class]
-    module.add_class('WifiInformationElement', parent=root_module['ns3::RefCountBase'])
-    ## mesh-wifi-interface-mac-plugin.h: ns3::MeshWifiInterfaceMacPlugin [class]
-    module.add_class('MeshWifiInterfaceMacPlugin', parent=root_module['ns3::RefCountBase'])
+    module.add_class('WifiInformationElement', parent=root_module['ns3::SimpleRefCount< ns3::WifiInformationElement, ns3::empty, ns3::DefaultDeleter<ns3::WifiInformationElement> >'])
     ## wifi-information-element-vector.h: ns3::WifiInformationElementVector [class]
     module.add_class('WifiInformationElementVector', parent=root_module['ns3::Header'])
     ## mesh-l2-routing-protocol.h: ns3::MeshL2RoutingProtocol [class]
     module.add_class('MeshL2RoutingProtocol', parent=root_module['ns3::Object'])
     ## mesh-wifi-interface-mac.h: ns3::MeshWifiInterfaceMac [class]
     module.add_class('MeshWifiInterfaceMac', parent=root_module['ns3::WifiMac'])
+    ## mesh-wifi-interface-mac-plugin.h: ns3::MeshWifiInterfaceMacPlugin [class]
+    module.add_class('MeshWifiInterfaceMacPlugin', parent=root_module['ns3::SimpleRefCount< ns3::MeshWifiInterfaceMacPlugin, ns3::empty, ns3::DefaultDeleter<ns3::MeshWifiInterfaceMacPlugin> >'])
     ## mesh-point-device.h: ns3::MeshPointDevice [class]
     module.add_class('MeshPointDevice', parent=root_module['ns3::NetDevice'])
     
@@ -38,6 +42,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -74,6 +84,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -93,10 +107,10 @@ def register_types_ns3_olsr(module):
 def register_methods(root_module):
     register_Ns3MeshWifiBeacon_methods(root_module, root_module['ns3::MeshWifiBeacon'])
     register_Ns3WifiInformationElement_methods(root_module, root_module['ns3::WifiInformationElement'])
-    register_Ns3MeshWifiInterfaceMacPlugin_methods(root_module, root_module['ns3::MeshWifiInterfaceMacPlugin'])
     register_Ns3WifiInformationElementVector_methods(root_module, root_module['ns3::WifiInformationElementVector'])
     register_Ns3MeshL2RoutingProtocol_methods(root_module, root_module['ns3::MeshL2RoutingProtocol'])
     register_Ns3MeshWifiInterfaceMac_methods(root_module, root_module['ns3::MeshWifiInterfaceMac'])
+    register_Ns3MeshWifiInterfaceMacPlugin_methods(root_module, root_module['ns3::MeshWifiInterfaceMacPlugin'])
     register_Ns3MeshPointDevice_methods(root_module, root_module['ns3::MeshPointDevice'])
     return
 
@@ -122,6 +136,11 @@ def register_Ns3MeshWifiBeacon_methods(root_module, cls):
     cls.add_method('CreatePacket', 
                    'ns3::Ptr< ns3::Packet >', 
                    [])
+    ## mesh-wifi-beacon.h: ns3::Time ns3::MeshWifiBeacon::GetBeaconInterval() const [member function]
+    cls.add_method('GetBeaconInterval', 
+                   'ns3::Time', 
+                   [], 
+                   is_const=True)
     return
 
 def register_Ns3WifiInformationElement_methods(root_module, cls):
@@ -158,33 +177,6 @@ def register_Ns3WifiInformationElement_methods(root_module, cls):
                    is_pure_virtual=True, is_const=True, is_virtual=True)
     return
 
-def register_Ns3MeshWifiInterfaceMacPlugin_methods(root_module, cls):
-    ## mesh-wifi-interface-mac-plugin.h: ns3::MeshWifiInterfaceMacPlugin::MeshWifiInterfaceMacPlugin() [constructor]
-    cls.add_constructor([])
-    ## mesh-wifi-interface-mac-plugin.h: ns3::MeshWifiInterfaceMacPlugin::MeshWifiInterfaceMacPlugin(ns3::MeshWifiInterfaceMacPlugin const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::MeshWifiInterfaceMacPlugin const &', 'arg0')])
-    ## mesh-wifi-interface-mac-plugin.h: bool ns3::MeshWifiInterfaceMacPlugin::Receive(ns3::Ptr<ns3::Packet> packet, ns3::WifiMacHeader const & header) [member function]
-    cls.add_method('Receive', 
-                   'bool', 
-                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::WifiMacHeader const &', 'header')], 
-                   is_pure_virtual=True, is_virtual=True)
-    ## mesh-wifi-interface-mac-plugin.h: void ns3::MeshWifiInterfaceMacPlugin::SetParent(ns3::Ptr<ns3::MeshWifiInterfaceMac> parent) [member function]
-    cls.add_method('SetParent', 
-                   'void', 
-                   [param('ns3::Ptr< ns3::MeshWifiInterfaceMac >', 'parent')], 
-                   is_pure_virtual=True, is_virtual=True)
-    ## mesh-wifi-interface-mac-plugin.h: void ns3::MeshWifiInterfaceMacPlugin::UpdateBeacon(ns3::MeshWifiBeacon & beacon) const [member function]
-    cls.add_method('UpdateBeacon', 
-                   'void', 
-                   [param('ns3::MeshWifiBeacon &', 'beacon')], 
-                   is_pure_virtual=True, is_const=True, is_virtual=True)
-    ## mesh-wifi-interface-mac-plugin.h: bool ns3::MeshWifiInterfaceMacPlugin::UpdateOutcomingFrame(ns3::Ptr<ns3::Packet> packet, ns3::WifiMacHeader & header, ns3::Mac48Address from, ns3::Mac48Address to) [member function]
-    cls.add_method('UpdateOutcomingFrame', 
-                   'bool', 
-                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::WifiMacHeader &', 'header'), param('ns3::Mac48Address', 'from'), param('ns3::Mac48Address', 'to')], 
-                   is_pure_virtual=True, is_virtual=True)
-    return
-
 def register_Ns3WifiInformationElementVector_methods(root_module, cls):
     cls.add_binary_comparison_operator('==')
     ## wifi-information-element-vector.h: ns3::WifiInformationElementVector::WifiInformationElementVector(ns3::WifiInformationElementVector const & arg0) [copy constructor]
@@ -349,6 +341,11 @@ def register_Ns3MeshWifiInterfaceMac_methods(root_module, cls):
                    'ns3::Mac48Address', 
                    [], 
                    is_const=True)
+    ## mesh-wifi-interface-mac.h: ns3::WifiPhyStandard ns3::MeshWifiInterfaceMac::GetPhyStandard() const [member function]
+    cls.add_method('GetPhyStandard', 
+                   'ns3::WifiPhyStandard', 
+                   [], 
+                   is_const=True)
     ## mesh-wifi-interface-mac.h: ns3::Time ns3::MeshWifiInterfaceMac::GetPifs() const [member function]
     cls.add_method('GetPifs', 
                    'ns3::Time', 
@@ -519,6 +516,33 @@ def register_Ns3MeshWifiInterfaceMac_methods(root_module, cls):
                    visibility='private', is_virtual=True)
     return
 
+def register_Ns3MeshWifiInterfaceMacPlugin_methods(root_module, cls):
+    ## mesh-wifi-interface-mac-plugin.h: ns3::MeshWifiInterfaceMacPlugin::MeshWifiInterfaceMacPlugin() [constructor]
+    cls.add_constructor([])
+    ## mesh-wifi-interface-mac-plugin.h: ns3::MeshWifiInterfaceMacPlugin::MeshWifiInterfaceMacPlugin(ns3::MeshWifiInterfaceMacPlugin const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::MeshWifiInterfaceMacPlugin const &', 'arg0')])
+    ## mesh-wifi-interface-mac-plugin.h: bool ns3::MeshWifiInterfaceMacPlugin::Receive(ns3::Ptr<ns3::Packet> packet, ns3::WifiMacHeader const & header) [member function]
+    cls.add_method('Receive', 
+                   'bool', 
+                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::WifiMacHeader const &', 'header')], 
+                   is_pure_virtual=True, is_virtual=True)
+    ## mesh-wifi-interface-mac-plugin.h: void ns3::MeshWifiInterfaceMacPlugin::SetParent(ns3::Ptr<ns3::MeshWifiInterfaceMac> parent) [member function]
+    cls.add_method('SetParent', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::MeshWifiInterfaceMac >', 'parent')], 
+                   is_pure_virtual=True, is_virtual=True)
+    ## mesh-wifi-interface-mac-plugin.h: void ns3::MeshWifiInterfaceMacPlugin::UpdateBeacon(ns3::MeshWifiBeacon & beacon) const [member function]
+    cls.add_method('UpdateBeacon', 
+                   'void', 
+                   [param('ns3::MeshWifiBeacon &', 'beacon')], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
+    ## mesh-wifi-interface-mac-plugin.h: bool ns3::MeshWifiInterfaceMacPlugin::UpdateOutcomingFrame(ns3::Ptr<ns3::Packet> packet, ns3::WifiMacHeader & header, ns3::Mac48Address from, ns3::Mac48Address to) [member function]
+    cls.add_method('UpdateOutcomingFrame', 
+                   'bool', 
+                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::WifiMacHeader &', 'header'), param('ns3::Mac48Address', 'from'), param('ns3::Mac48Address', 'to')], 
+                   is_pure_virtual=True, is_virtual=True)
+    return
+
 def register_Ns3MeshPointDevice_methods(root_module, cls):
     ## mesh-point-device.h: ns3::MeshPointDevice::MeshPointDevice(ns3::MeshPointDevice const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::MeshPointDevice const &', 'arg0')])
@@ -698,6 +722,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -713,6 +738,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/ns3_module_mobility.py

@@ -9,16 +9,16 @@ def register_types(module):
     module.add_class('Rectangle')
     ## rectangle.h: ns3::Rectangle::Side [enumeration]
     module.add_enum('Side', ['RIGHT', 'LEFT', 'TOP', 'BOTTOM'], outer_class=root_module['ns3::Rectangle'])
+    ## waypoint.h: ns3::Waypoint [class]
+    module.add_class('Waypoint')
     ## position-allocator.h: ns3::PositionAllocator [class]
     module.add_class('PositionAllocator', parent=root_module['ns3::Object'])
     ## position-allocator.h: ns3::RandomDiscPositionAllocator [class]
     module.add_class('RandomDiscPositionAllocator', parent=root_module['ns3::PositionAllocator'])
     ## position-allocator.h: ns3::RandomRectanglePositionAllocator [class]
     module.add_class('RandomRectanglePositionAllocator', parent=root_module['ns3::PositionAllocator'])
-    ## rectangle.h: ns3::RectangleChecker [class]
-    module.add_class('RectangleChecker', parent=root_module['ns3::AttributeChecker'])
-    ## rectangle.h: ns3::RectangleValue [class]
-    module.add_class('RectangleValue', parent=root_module['ns3::AttributeValue'])
+    ## position-allocator.h: ns3::UniformDiscPositionAllocator [class]
+    module.add_class('UniformDiscPositionAllocator', parent=root_module['ns3::PositionAllocator'])
     ## position-allocator.h: ns3::GridPositionAllocator [class]
     module.add_class('GridPositionAllocator', parent=root_module['ns3::PositionAllocator'])
     ## position-allocator.h: ns3::GridPositionAllocator::LayoutType [enumeration]
@@ -35,6 +35,16 @@ def register_types(module):
     module.add_enum('Mode', ['MODE_DISTANCE', 'MODE_TIME'], outer_class=root_module['ns3::RandomWalk2dMobilityModel'])
     ## random-waypoint-mobility-model.h: ns3::RandomWaypointMobilityModel [class]
     module.add_class('RandomWaypointMobilityModel', parent=root_module['ns3::MobilityModel'])
+    ## rectangle.h: ns3::RectangleChecker [class]
+    module.add_class('RectangleChecker', parent=root_module['ns3::AttributeChecker'])
+    ## rectangle.h: ns3::RectangleValue [class]
+    module.add_class('RectangleValue', parent=root_module['ns3::AttributeValue'])
+    ## waypoint.h: ns3::WaypointChecker [class]
+    module.add_class('WaypointChecker', parent=root_module['ns3::AttributeChecker'])
+    ## waypoint-mobility-model.h: ns3::WaypointMobilityModel [class]
+    module.add_class('WaypointMobilityModel', parent=root_module['ns3::MobilityModel'])
+    ## waypoint.h: ns3::WaypointValue [class]
+    module.add_class('WaypointValue', parent=root_module['ns3::AttributeValue'])
     ## constant-acceleration-mobility-model.h: ns3::ConstantAccelerationMobilityModel [class]
     module.add_class('ConstantAccelerationMobilityModel', parent=root_module['ns3::MobilityModel'])
     ## constant-position-mobility-model.h: ns3::ConstantPositionMobilityModel [class]
@@ -62,6 +72,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -98,6 +114,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -117,17 +137,22 @@ def register_types_ns3_olsr(module):
 def register_methods(root_module):
     register_Ns3ConstantVelocityHelper_methods(root_module, root_module['ns3::ConstantVelocityHelper'])
     register_Ns3Rectangle_methods(root_module, root_module['ns3::Rectangle'])
+    register_Ns3Waypoint_methods(root_module, root_module['ns3::Waypoint'])
     register_Ns3PositionAllocator_methods(root_module, root_module['ns3::PositionAllocator'])
     register_Ns3RandomDiscPositionAllocator_methods(root_module, root_module['ns3::RandomDiscPositionAllocator'])
     register_Ns3RandomRectanglePositionAllocator_methods(root_module, root_module['ns3::RandomRectanglePositionAllocator'])
-    register_Ns3RectangleChecker_methods(root_module, root_module['ns3::RectangleChecker'])
-    register_Ns3RectangleValue_methods(root_module, root_module['ns3::RectangleValue'])
+    register_Ns3UniformDiscPositionAllocator_methods(root_module, root_module['ns3::UniformDiscPositionAllocator'])
     register_Ns3GridPositionAllocator_methods(root_module, root_module['ns3::GridPositionAllocator'])
     register_Ns3ListPositionAllocator_methods(root_module, root_module['ns3::ListPositionAllocator'])
     register_Ns3MobilityModel_methods(root_module, root_module['ns3::MobilityModel'])
     register_Ns3RandomDirection2dMobilityModel_methods(root_module, root_module['ns3::RandomDirection2dMobilityModel'])
     register_Ns3RandomWalk2dMobilityModel_methods(root_module, root_module['ns3::RandomWalk2dMobilityModel'])
     register_Ns3RandomWaypointMobilityModel_methods(root_module, root_module['ns3::RandomWaypointMobilityModel'])
+    register_Ns3RectangleChecker_methods(root_module, root_module['ns3::RectangleChecker'])
+    register_Ns3RectangleValue_methods(root_module, root_module['ns3::RectangleValue'])
+    register_Ns3WaypointChecker_methods(root_module, root_module['ns3::WaypointChecker'])
+    register_Ns3WaypointMobilityModel_methods(root_module, root_module['ns3::WaypointMobilityModel'])
+    register_Ns3WaypointValue_methods(root_module, root_module['ns3::WaypointValue'])
     register_Ns3ConstantAccelerationMobilityModel_methods(root_module, root_module['ns3::ConstantAccelerationMobilityModel'])
     register_Ns3ConstantPositionMobilityModel_methods(root_module, root_module['ns3::ConstantPositionMobilityModel'])
     register_Ns3ConstantVelocityMobilityModel_methods(root_module, root_module['ns3::ConstantVelocityMobilityModel'])
@@ -214,6 +239,20 @@ def register_Ns3Rectangle_methods(root_module, cls):
     cls.add_instance_attribute('yMin', 'double', is_const=False)
     return
 
+def register_Ns3Waypoint_methods(root_module, cls):
+    cls.add_output_stream_operator()
+    ## waypoint.h: ns3::Waypoint::Waypoint(ns3::Waypoint const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::Waypoint const &', 'arg0')])
+    ## waypoint.h: ns3::Waypoint::Waypoint(ns3::Time const & waypointTime, ns3::Vector const & waypointPosition) [constructor]
+    cls.add_constructor([param('ns3::Time const &', 'waypointTime'), param('ns3::Vector const &', 'waypointPosition')])
+    ## waypoint.h: ns3::Waypoint::Waypoint() [constructor]
+    cls.add_constructor([])
+    ## waypoint.h: ns3::Waypoint::position [variable]
+    cls.add_instance_attribute('position', 'ns3::Vector', is_const=False)
+    ## waypoint.h: ns3::Waypoint::time [variable]
+    cls.add_instance_attribute('time', 'ns3::Time', is_const=False)
+    return
+
 def register_Ns3PositionAllocator_methods(root_module, cls):
     ## position-allocator.h: ns3::PositionAllocator::PositionAllocator(ns3::PositionAllocator const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::PositionAllocator const &', 'arg0')])
@@ -289,44 +328,33 @@ def register_Ns3RandomRectanglePositionAllocator_methods(root_module, cls):
                    [param('ns3::RandomVariable', 'y')])
     return
 
-def register_Ns3RectangleChecker_methods(root_module, cls):
-    ## rectangle.h: ns3::RectangleChecker::RectangleChecker() [constructor]
+def register_Ns3UniformDiscPositionAllocator_methods(root_module, cls):
+    ## position-allocator.h: ns3::UniformDiscPositionAllocator::UniformDiscPositionAllocator(ns3::UniformDiscPositionAllocator const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::UniformDiscPositionAllocator const &', 'arg0')])
+    ## position-allocator.h: ns3::UniformDiscPositionAllocator::UniformDiscPositionAllocator() [constructor]
     cls.add_constructor([])
-    ## rectangle.h: ns3::RectangleChecker::RectangleChecker(ns3::RectangleChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::RectangleChecker const &', 'arg0')])
-    return
-
-def register_Ns3RectangleValue_methods(root_module, cls):
-    ## rectangle.h: ns3::RectangleValue::RectangleValue() [constructor]
-    cls.add_constructor([])
-    ## rectangle.h: ns3::RectangleValue::RectangleValue(ns3::RectangleValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::RectangleValue const &', 'arg0')])
-    ## rectangle.h: ns3::RectangleValue::RectangleValue(ns3::Rectangle const & value) [constructor]
-    cls.add_constructor([param('ns3::Rectangle const &', 'value')])
-    ## rectangle.h: ns3::Ptr<ns3::AttributeValue> ns3::RectangleValue::Copy() const [member function]
-    cls.add_method('Copy', 
-                   'ns3::Ptr< ns3::AttributeValue >', 
+    ## position-allocator.h: ns3::Vector ns3::UniformDiscPositionAllocator::GetNext() const [member function]
+    cls.add_method('GetNext', 
+                   'ns3::Vector', 
                    [], 
                    is_const=True, is_virtual=True)
-    ## rectangle.h: bool ns3::RectangleValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
-    cls.add_method('DeserializeFromString', 
-                   'bool', 
-                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
-                   is_virtual=True)
-    ## rectangle.h: ns3::Rectangle ns3::RectangleValue::Get() const [member function]
-    cls.add_method('Get', 
-                   'ns3::Rectangle', 
+    ## position-allocator.h: static ns3::TypeId ns3::UniformDiscPositionAllocator::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
                    [], 
-                   is_const=True)
-    ## rectangle.h: std::string ns3::RectangleValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
-    cls.add_method('SerializeToString', 
-                   'std::string', 
-                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
-                   is_const=True, is_virtual=True)
-    ## rectangle.h: void ns3::RectangleValue::Set(ns3::Rectangle const & value) [member function]
-    cls.add_method('Set', 
+                   is_static=True)
+    ## position-allocator.h: void ns3::UniformDiscPositionAllocator::SetRho(double rho) [member function]
+    cls.add_method('SetRho', 
                    'void', 
-                   [param('ns3::Rectangle const &', 'value')])
+                   [param('double', 'rho')])
+    ## position-allocator.h: void ns3::UniformDiscPositionAllocator::SetX(double x) [member function]
+    cls.add_method('SetX', 
+                   'void', 
+                   [param('double', 'x')])
+    ## position-allocator.h: void ns3::UniformDiscPositionAllocator::SetY(double y) [member function]
+    cls.add_method('SetY', 
+                   'void', 
+                   [param('double', 'y')])
     return
 
 def register_Ns3GridPositionAllocator_methods(root_module, cls):
@@ -473,10 +501,10 @@ def register_Ns3MobilityModel_methods(root_module, cls):
     return
 
 def register_Ns3RandomDirection2dMobilityModel_methods(root_module, cls):
-    ## random-direction-2d-mobility-model.h: ns3::RandomDirection2dMobilityModel::RandomDirection2dMobilityModel(ns3::RandomDirection2dMobilityModel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::RandomDirection2dMobilityModel const &', 'arg0')])
     ## random-direction-2d-mobility-model.h: ns3::RandomDirection2dMobilityModel::RandomDirection2dMobilityModel() [constructor]
     cls.add_constructor([])
+    ## random-direction-2d-mobility-model.h: ns3::RandomDirection2dMobilityModel::RandomDirection2dMobilityModel(ns3::RandomDirection2dMobilityModel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::RandomDirection2dMobilityModel const &', 'arg0')])
     ## random-direction-2d-mobility-model.h: static ns3::TypeId ns3::RandomDirection2dMobilityModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -502,13 +530,18 @@ def register_Ns3RandomDirection2dMobilityModel_methods(root_module, cls):
                    'void', 
                    [param('ns3::Vector const &', 'position')], 
                    visibility='private', is_virtual=True)
+    ## random-direction-2d-mobility-model.h: void ns3::RandomDirection2dMobilityModel::DoStart() [member function]
+    cls.add_method('DoStart', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
     return
 
 def register_Ns3RandomWalk2dMobilityModel_methods(root_module, cls):
-    ## random-walk-2d-mobility-model.h: ns3::RandomWalk2dMobilityModel::RandomWalk2dMobilityModel(ns3::RandomWalk2dMobilityModel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::RandomWalk2dMobilityModel const &', 'arg0')])
     ## random-walk-2d-mobility-model.h: ns3::RandomWalk2dMobilityModel::RandomWalk2dMobilityModel() [constructor]
     cls.add_constructor([])
+    ## random-walk-2d-mobility-model.h: ns3::RandomWalk2dMobilityModel::RandomWalk2dMobilityModel(ns3::RandomWalk2dMobilityModel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::RandomWalk2dMobilityModel const &', 'arg0')])
     ## random-walk-2d-mobility-model.h: static ns3::TypeId ns3::RandomWalk2dMobilityModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -534,18 +567,28 @@ def register_Ns3RandomWalk2dMobilityModel_methods(root_module, cls):
                    'void', 
                    [param('ns3::Vector const &', 'position')], 
                    visibility='private', is_virtual=True)
+    ## random-walk-2d-mobility-model.h: void ns3::RandomWalk2dMobilityModel::DoStart() [member function]
+    cls.add_method('DoStart', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
     return
 
 def register_Ns3RandomWaypointMobilityModel_methods(root_module, cls):
-    ## random-waypoint-mobility-model.h: ns3::RandomWaypointMobilityModel::RandomWaypointMobilityModel(ns3::RandomWaypointMobilityModel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::RandomWaypointMobilityModel const &', 'arg0')])
     ## random-waypoint-mobility-model.h: ns3::RandomWaypointMobilityModel::RandomWaypointMobilityModel() [constructor]
     cls.add_constructor([])
+    ## random-waypoint-mobility-model.h: ns3::RandomWaypointMobilityModel::RandomWaypointMobilityModel(ns3::RandomWaypointMobilityModel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::RandomWaypointMobilityModel const &', 'arg0')])
     ## random-waypoint-mobility-model.h: static ns3::TypeId ns3::RandomWaypointMobilityModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
                    [], 
                    is_static=True)
+    ## random-waypoint-mobility-model.h: void ns3::RandomWaypointMobilityModel::DoStart() [member function]
+    cls.add_method('DoStart', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
     ## random-waypoint-mobility-model.h: ns3::Vector ns3::RandomWaypointMobilityModel::DoGetPosition() const [member function]
     cls.add_method('DoGetPosition', 
                    'ns3::Vector', 
@@ -563,6 +606,136 @@ def register_Ns3RandomWaypointMobilityModel_methods(root_module, cls):
                    visibility='private', is_virtual=True)
     return
 
+def register_Ns3RectangleChecker_methods(root_module, cls):
+    ## rectangle.h: ns3::RectangleChecker::RectangleChecker() [constructor]
+    cls.add_constructor([])
+    ## rectangle.h: ns3::RectangleChecker::RectangleChecker(ns3::RectangleChecker const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::RectangleChecker const &', 'arg0')])
+    return
+
+def register_Ns3RectangleValue_methods(root_module, cls):
+    ## rectangle.h: ns3::RectangleValue::RectangleValue() [constructor]
+    cls.add_constructor([])
+    ## rectangle.h: ns3::RectangleValue::RectangleValue(ns3::RectangleValue const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::RectangleValue const &', 'arg0')])
+    ## rectangle.h: ns3::RectangleValue::RectangleValue(ns3::Rectangle const & value) [constructor]
+    cls.add_constructor([param('ns3::Rectangle const &', 'value')])
+    ## rectangle.h: ns3::Ptr<ns3::AttributeValue> ns3::RectangleValue::Copy() const [member function]
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## rectangle.h: bool ns3::RectangleValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_virtual=True)
+    ## rectangle.h: ns3::Rectangle ns3::RectangleValue::Get() const [member function]
+    cls.add_method('Get', 
+                   'ns3::Rectangle', 
+                   [], 
+                   is_const=True)
+    ## rectangle.h: std::string ns3::RectangleValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, is_virtual=True)
+    ## rectangle.h: void ns3::RectangleValue::Set(ns3::Rectangle const & value) [member function]
+    cls.add_method('Set', 
+                   'void', 
+                   [param('ns3::Rectangle const &', 'value')])
+    return
+
+def register_Ns3WaypointChecker_methods(root_module, cls):
+    ## waypoint.h: ns3::WaypointChecker::WaypointChecker() [constructor]
+    cls.add_constructor([])
+    ## waypoint.h: ns3::WaypointChecker::WaypointChecker(ns3::WaypointChecker const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::WaypointChecker const &', 'arg0')])
+    return
+
+def register_Ns3WaypointMobilityModel_methods(root_module, cls):
+    ## waypoint-mobility-model.h: ns3::WaypointMobilityModel::WaypointMobilityModel(ns3::WaypointMobilityModel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::WaypointMobilityModel const &', 'arg0')])
+    ## waypoint-mobility-model.h: ns3::WaypointMobilityModel::WaypointMobilityModel() [constructor]
+    cls.add_constructor([])
+    ## waypoint-mobility-model.h: void ns3::WaypointMobilityModel::AddWaypoint(ns3::Waypoint const & waypoint) [member function]
+    cls.add_method('AddWaypoint', 
+                   'void', 
+                   [param('ns3::Waypoint const &', 'waypoint')])
+    ## waypoint-mobility-model.h: void ns3::WaypointMobilityModel::EndMobility() [member function]
+    cls.add_method('EndMobility', 
+                   'void', 
+                   [])
+    ## waypoint-mobility-model.h: ns3::Waypoint ns3::WaypointMobilityModel::GetNextWaypoint() const [member function]
+    cls.add_method('GetNextWaypoint', 
+                   'ns3::Waypoint', 
+                   [], 
+                   is_const=True)
+    ## waypoint-mobility-model.h: static ns3::TypeId ns3::WaypointMobilityModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## waypoint-mobility-model.h: uint32_t ns3::WaypointMobilityModel::WaypointsLeft() const [member function]
+    cls.add_method('WaypointsLeft', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
+    ## waypoint-mobility-model.h: void ns3::WaypointMobilityModel::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
+    ## waypoint-mobility-model.h: ns3::Vector ns3::WaypointMobilityModel::DoGetPosition() const [member function]
+    cls.add_method('DoGetPosition', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, visibility='private', is_virtual=True)
+    ## waypoint-mobility-model.h: ns3::Vector ns3::WaypointMobilityModel::DoGetVelocity() const [member function]
+    cls.add_method('DoGetVelocity', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, visibility='private', is_virtual=True)
+    ## waypoint-mobility-model.h: void ns3::WaypointMobilityModel::DoSetPosition(ns3::Vector const & position) [member function]
+    cls.add_method('DoSetPosition', 
+                   'void', 
+                   [param('ns3::Vector const &', 'position')], 
+                   visibility='private', is_virtual=True)
+    return
+
+def register_Ns3WaypointValue_methods(root_module, cls):
+    ## waypoint.h: ns3::WaypointValue::WaypointValue() [constructor]
+    cls.add_constructor([])
+    ## waypoint.h: ns3::WaypointValue::WaypointValue(ns3::WaypointValue const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::WaypointValue const &', 'arg0')])
+    ## waypoint.h: ns3::WaypointValue::WaypointValue(ns3::Waypoint const & value) [constructor]
+    cls.add_constructor([param('ns3::Waypoint const &', 'value')])
+    ## waypoint.h: ns3::Ptr<ns3::AttributeValue> ns3::WaypointValue::Copy() const [member function]
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## waypoint.h: bool ns3::WaypointValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_virtual=True)
+    ## waypoint.h: ns3::Waypoint ns3::WaypointValue::Get() const [member function]
+    cls.add_method('Get', 
+                   'ns3::Waypoint', 
+                   [], 
+                   is_const=True)
+    ## waypoint.h: std::string ns3::WaypointValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, is_virtual=True)
+    ## waypoint.h: void ns3::WaypointValue::Set(ns3::Waypoint const & value) [member function]
+    cls.add_method('Set', 
+                   'void', 
+                   [param('ns3::Waypoint const &', 'value')])
+    return
+
 def register_Ns3ConstantAccelerationMobilityModel_methods(root_module, cls):
     ## constant-acceleration-mobility-model.h: ns3::ConstantAccelerationMobilityModel::ConstantAccelerationMobilityModel(ns3::ConstantAccelerationMobilityModel const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::ConstantAccelerationMobilityModel const &', 'arg0')])
@@ -703,9 +876,14 @@ def register_functions(root_module):
     module.add_function('MakeRectangleChecker', 
                         'ns3::Ptr< ns3::AttributeChecker const >', 
                         [])
+    ## waypoint.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeWaypointChecker() [free function]
+    module.add_function('MakeWaypointChecker', 
+                        'ns3::Ptr< ns3::AttributeChecker const >', 
+                        [])
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -721,6 +899,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/ns3_module_nix_vector_routing.py

@@ -30,6 +30,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -66,6 +72,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -129,15 +139,15 @@ def register_Ns3Ipv4NixVectorRouting_methods(root_module, cls):
                    'void', 
                    [param('uint32_t', 'interface'), param('ns3::Ipv4InterfaceAddress', 'address')], 
                    visibility='private', is_virtual=True)
-    ## ipv4-nix-vector-routing.h: bool ns3::Ipv4NixVectorRouting::RouteInput(ns3::Ptr<ns3::Packet const> p, ns3::Ipv4Header const & header, ns3::Ptr<const ns3::NetDevice> idev, ns3::Callback<void,ns3::Ptr<ns3::Ipv4Route>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ucb, ns3::Callback<void,ns3::Ptr<ns3::Ipv4MulticastRoute>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> mcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,unsigned int,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> lcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::Socket::SocketErrno,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ecb) [member function]
+    ## ipv4-nix-vector-routing.h: bool ns3::Ipv4NixVectorRouting::RouteInput(ns3::Ptr<ns3::Packet const> p, ns3::Ipv4Header const & header, ns3::Ptr<const ns3::NetDevice> idev, ns3::Callback<void, ns3::Ptr<ns3::Ipv4Route>, ns3::Ptr<ns3::Packet const>, ns3::Ipv4Header const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ucb, ns3::Callback<void,ns3::Ptr<ns3::Ipv4MulticastRoute>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> mcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,unsigned int,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> lcb, ns3::Callback<void, ns3::Ptr<ns3::Packet const>, ns3::Ipv4Header const&, ns3::Socket::SocketErrno, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ecb) [member function]
     cls.add_method('RouteInput', 
                    'bool', 
                    [param('ns3::Ptr< ns3::Packet const >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice const >', 'idev'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv4Route >, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ucb'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv4MulticastRoute >, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'mcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'lcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::Socket::SocketErrno, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ecb')], 
                    visibility='private', is_virtual=True)
-    ## ipv4-nix-vector-routing.h: ns3::Ptr<ns3::Ipv4Route> ns3::Ipv4NixVectorRouting::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Header const & header, uint32_t oif, ns3::Socket::SocketErrno & sockerr) [member function]
+    ## ipv4-nix-vector-routing.h: ns3::Ptr<ns3::Ipv4Route> ns3::Ipv4NixVectorRouting::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Header const & header, ns3::Ptr<ns3::NetDevice> oif, ns3::Socket::SocketErrno & sockerr) [member function]
     cls.add_method('RouteOutput', 
                    'ns3::Ptr< ns3::Ipv4Route >', 
-                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('uint32_t', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice >', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
                    visibility='private', is_virtual=True)
     ## ipv4-nix-vector-routing.h: void ns3::Ipv4NixVectorRouting::SetIpv4(ns3::Ptr<ns3::Ipv4> ipv4) [member function]
     cls.add_method('SetIpv4', 
@@ -151,6 +161,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -166,6 +177,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/ns3_module_olsr.py

@@ -30,6 +30,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -66,6 +72,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -109,6 +119,8 @@ def register_types_ns3_olsr(module):
     module.add_class('NeighborTuple')
     ## olsr-repositories.h: ns3::olsr::NeighborTuple::Status [enumeration]
     module.add_enum('Status', ['STATUS_NOT_SYM', 'STATUS_SYM'], outer_class=root_module['ns3::olsr::NeighborTuple'])
+    ## olsr-routing-protocol.h: ns3::olsr::OlsrMprTestCase [class]
+    module.add_class('OlsrMprTestCase', parent=root_module['ns3::TestCase'])
     ## olsr-header.h: ns3::olsr::PacketHeader [class]
     module.add_class('PacketHeader', parent=root_module['ns3::Header'])
     ## olsr-routing-protocol.h: ns3::olsr::RoutingProtocol [class]
@@ -127,6 +139,9 @@ def register_types_ns3_olsr(module):
     typehandlers.add_type_alias('std::vector< ns3::olsr::NeighborTuple, std::allocator< ns3::olsr::NeighborTuple > >', 'ns3::olsr::NeighborSet')
     typehandlers.add_type_alias('std::vector< ns3::olsr::NeighborTuple, std::allocator< ns3::olsr::NeighborTuple > >*', 'ns3::olsr::NeighborSet*')
     typehandlers.add_type_alias('std::vector< ns3::olsr::NeighborTuple, std::allocator< ns3::olsr::NeighborTuple > >&', 'ns3::olsr::NeighborSet&')
+    typehandlers.add_type_alias('std::vector< ns3::olsr::LinkTuple, std::allocator< ns3::olsr::LinkTuple > >', 'ns3::olsr::LinkSet')
+    typehandlers.add_type_alias('std::vector< ns3::olsr::LinkTuple, std::allocator< ns3::olsr::LinkTuple > >*', 'ns3::olsr::LinkSet*')
+    typehandlers.add_type_alias('std::vector< ns3::olsr::LinkTuple, std::allocator< ns3::olsr::LinkTuple > >&', 'ns3::olsr::LinkSet&')
     typehandlers.add_type_alias('std::set< ns3::Ipv4Address, std::less< ns3::Ipv4Address >, std::allocator< ns3::Ipv4Address > >', 'ns3::olsr::MprSet')
     typehandlers.add_type_alias('std::set< ns3::Ipv4Address, std::less< ns3::Ipv4Address >, std::allocator< ns3::Ipv4Address > >*', 'ns3::olsr::MprSet*')
     typehandlers.add_type_alias('std::set< ns3::Ipv4Address, std::less< ns3::Ipv4Address >, std::allocator< ns3::Ipv4Address > >&', 'ns3::olsr::MprSet&')
@@ -145,9 +160,6 @@ def register_types_ns3_olsr(module):
     typehandlers.add_type_alias('std::vector< ns3::olsr::TwoHopNeighborTuple, std::allocator< ns3::olsr::TwoHopNeighborTuple > >', 'ns3::olsr::TwoHopNeighborSet')
     typehandlers.add_type_alias('std::vector< ns3::olsr::TwoHopNeighborTuple, std::allocator< ns3::olsr::TwoHopNeighborTuple > >*', 'ns3::olsr::TwoHopNeighborSet*')
     typehandlers.add_type_alias('std::vector< ns3::olsr::TwoHopNeighborTuple, std::allocator< ns3::olsr::TwoHopNeighborTuple > >&', 'ns3::olsr::TwoHopNeighborSet&')
-    typehandlers.add_type_alias('std::vector< ns3::olsr::LinkTuple, std::allocator< ns3::olsr::LinkTuple > >', 'ns3::olsr::LinkSet')
-    typehandlers.add_type_alias('std::vector< ns3::olsr::LinkTuple, std::allocator< ns3::olsr::LinkTuple > >*', 'ns3::olsr::LinkSet*')
-    typehandlers.add_type_alias('std::vector< ns3::olsr::LinkTuple, std::allocator< ns3::olsr::LinkTuple > >&', 'ns3::olsr::LinkSet&')
 
 def register_methods(root_module):
     register_Ns3OlsrState_methods(root_module, root_module['ns3::OlsrState'])
@@ -163,6 +175,7 @@ def register_methods(root_module):
     register_Ns3OlsrMessageHeaderTc_methods(root_module, root_module['ns3::olsr::MessageHeader::Tc'])
     register_Ns3OlsrMprSelectorTuple_methods(root_module, root_module['ns3::olsr::MprSelectorTuple'])
     register_Ns3OlsrNeighborTuple_methods(root_module, root_module['ns3::olsr::NeighborTuple'])
+    register_Ns3OlsrOlsrMprTestCase_methods(root_module, root_module['ns3::olsr::OlsrMprTestCase'])
     register_Ns3OlsrPacketHeader_methods(root_module, root_module['ns3::olsr::PacketHeader'])
     register_Ns3OlsrRoutingProtocol_methods(root_module, root_module['ns3::olsr::RoutingProtocol'])
     register_Ns3OlsrRoutingTableEntry_methods(root_module, root_module['ns3::olsr::RoutingTableEntry'])
@@ -301,6 +314,11 @@ def register_Ns3OlsrState_methods(root_module, cls):
                    'ns3::olsr::MprSelectorSet const &', 
                    [], 
                    is_const=True)
+    ## olsr-state.h: ns3::olsr::MprSet ns3::OlsrState::GetMprSet() const [member function]
+    cls.add_method('GetMprSet', 
+                   'ns3::olsr::MprSet', 
+                   [], 
+                   is_const=True)
     ## olsr-state.h: ns3::olsr::NeighborSet const & ns3::OlsrState::GetNeighbors() const [member function]
     cls.add_method('GetNeighbors', 
                    'ns3::olsr::NeighborSet const &', 
@@ -719,6 +737,16 @@ def register_Ns3OlsrNeighborTuple_methods(root_module, cls):
     cls.add_instance_attribute('willingness', 'uint8_t', is_const=False)
     return
 
+def register_Ns3OlsrOlsrMprTestCase_methods(root_module, cls):
+    ## olsr-routing-protocol.h: ns3::olsr::OlsrMprTestCase::OlsrMprTestCase() [constructor]
+    cls.add_constructor([])
+    ## olsr-routing-protocol.h: bool ns3::olsr::OlsrMprTestCase::DoRun() [member function]
+    cls.add_method('DoRun', 
+                   'bool', 
+                   [], 
+                   is_virtual=True)
+    return
+
 def register_Ns3OlsrPacketHeader_methods(root_module, cls):
     cls.add_output_stream_operator()
     ## olsr-header.h: ns3::olsr::PacketHeader::PacketHeader(ns3::olsr::PacketHeader const & arg0) [copy constructor]
@@ -780,6 +808,10 @@ def register_Ns3OlsrRoutingProtocol_methods(root_module, cls):
     cls.add_constructor([param('ns3::olsr::RoutingProtocol const &', 'arg0')])
     ## olsr-routing-protocol.h: ns3::olsr::RoutingProtocol::RoutingProtocol() [constructor]
     cls.add_constructor([])
+    ## olsr-routing-protocol.h: void ns3::olsr::RoutingProtocol::Dump() [member function]
+    cls.add_method('Dump', 
+                   'void', 
+                   [])
     ## olsr-routing-protocol.h: static ns3::TypeId ns3::olsr::RoutingProtocol::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -789,6 +821,11 @@ def register_Ns3OlsrRoutingProtocol_methods(root_module, cls):
     cls.add_method('SetMainInterface', 
                    'void', 
                    [param('uint32_t', 'interface')])
+    ## olsr-routing-protocol.h: void ns3::olsr::RoutingProtocol::DoStart() [member function]
+    cls.add_method('DoStart', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
     ## olsr-routing-protocol.h: void ns3::olsr::RoutingProtocol::DoDispose() [member function]
     cls.add_method('DoDispose', 
                    'void', 
@@ -814,15 +851,15 @@ def register_Ns3OlsrRoutingProtocol_methods(root_module, cls):
                    'void', 
                    [param('uint32_t', 'interface'), param('ns3::Ipv4InterfaceAddress', 'address')], 
                    visibility='private', is_virtual=True)
-    ## olsr-routing-protocol.h: bool ns3::olsr::RoutingProtocol::RouteInput(ns3::Ptr<ns3::Packet const> p, ns3::Ipv4Header const & header, ns3::Ptr<const ns3::NetDevice> idev, ns3::Callback<void,ns3::Ptr<ns3::Ipv4Route>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ucb, ns3::Callback<void,ns3::Ptr<ns3::Ipv4MulticastRoute>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> mcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,unsigned int,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> lcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::Socket::SocketErrno,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ecb) [member function]
+    ## olsr-routing-protocol.h: bool ns3::olsr::RoutingProtocol::RouteInput(ns3::Ptr<ns3::Packet const> p, ns3::Ipv4Header const & header, ns3::Ptr<const ns3::NetDevice> idev, ns3::Callback<void, ns3::Ptr<ns3::Ipv4Route>, ns3::Ptr<ns3::Packet const>, ns3::Ipv4Header const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ucb, ns3::Callback<void,ns3::Ptr<ns3::Ipv4MulticastRoute>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> mcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,unsigned int,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> lcb, ns3::Callback<void, ns3::Ptr<ns3::Packet const>, ns3::Ipv4Header const&, ns3::Socket::SocketErrno, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ecb) [member function]
     cls.add_method('RouteInput', 
                    'bool', 
                    [param('ns3::Ptr< ns3::Packet const >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice const >', 'idev'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv4Route >, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ucb'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv4MulticastRoute >, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'mcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'lcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::Socket::SocketErrno, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ecb')], 
                    visibility='private', is_virtual=True)
-    ## olsr-routing-protocol.h: ns3::Ptr<ns3::Ipv4Route> ns3::olsr::RoutingProtocol::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Header const & header, uint32_t oif, ns3::Socket::SocketErrno & sockerr) [member function]
+    ## olsr-routing-protocol.h: ns3::Ptr<ns3::Ipv4Route> ns3::olsr::RoutingProtocol::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Header const & header, ns3::Ptr<ns3::NetDevice> oif, ns3::Socket::SocketErrno & sockerr) [member function]
     cls.add_method('RouteOutput', 
                    'ns3::Ptr< ns3::Ipv4Route >', 
-                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('uint32_t', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice >', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
                    visibility='private', is_virtual=True)
     ## olsr-routing-protocol.h: void ns3::olsr::RoutingProtocol::SetIpv4(ns3::Ptr<ns3::Ipv4> ipv4) [member function]
     cls.add_method('SetIpv4', 
@@ -883,6 +920,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -898,6 +936,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/ns3_module_onoff.py

@@ -24,6 +24,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -60,6 +66,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -116,6 +126,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -131,6 +142,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/ns3_module_packet_sink.py

@@ -24,6 +24,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -60,6 +66,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -117,6 +127,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -132,6 +143,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/ns3_module_ping6.py

@@ -24,6 +24,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -60,6 +66,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -102,6 +112,10 @@ def register_Ns3Ping6_methods(root_module, cls):
     cls.add_method('SetRemote', 
                    'void', 
                    [param('ns3::Ipv6Address', 'ipv6')])
+    ## ping6.h: void ns3::Ping6::SetRouters(std::vector<ns3::Ipv6Address, std::allocator<ns3::Ipv6Address> > routers) [member function]
+    cls.add_method('SetRouters', 
+                   'void', 
+                   [param('std::vector< ns3::Ipv6Address >', 'routers')])
     ## ping6.h: void ns3::Ping6::DoDispose() [member function]
     cls.add_method('DoDispose', 
                    'void', 
@@ -124,6 +138,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -139,6 +154,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/ns3_module_point_to_point.py

@@ -28,6 +28,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -64,6 +70,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -101,6 +111,10 @@ def register_Ns3PppHeader_methods(root_module, cls):
                    'ns3::TypeId', 
                    [], 
                    is_const=True, is_virtual=True)
+    ## ppp-header.h: uint16_t ns3::PppHeader::GetProtocol() [member function]
+    cls.add_method('GetProtocol', 
+                   'uint16_t', 
+                   [])
     ## ppp-header.h: uint32_t ns3::PppHeader::GetSerializedSize() const [member function]
     cls.add_method('GetSerializedSize', 
                    'uint32_t', 
@@ -121,6 +135,10 @@ def register_Ns3PppHeader_methods(root_module, cls):
                    'void', 
                    [param('ns3::Buffer::Iterator', 'start')], 
                    is_const=True, is_virtual=True)
+    ## ppp-header.h: void ns3::PppHeader::SetProtocol(uint16_t protocol) [member function]
+    cls.add_method('SetProtocol', 
+                   'void', 
+                   [param('uint16_t', 'protocol')])
     return
 
 def register_Ns3PointToPointChannel_methods(root_module, cls):
@@ -333,6 +351,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -348,6 +367,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/ns3_module_radvd.py

@@ -3,12 +3,16 @@ from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandler
 def register_types(module):
     root_module = module.get_root()
     
-    ## radvd-interface.h: ns3::RadvdInterface [class]
-    module.add_class('RadvdInterface', parent=root_module['ns3::RefCountBase'])
-    ## radvd-prefix.h: ns3::RadvdPrefix [class]
-    module.add_class('RadvdPrefix', parent=root_module['ns3::RefCountBase'])
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::RadvdInterface, ns3::empty, ns3::DefaultDeleter<ns3::RadvdInterface> > [class]
+    module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::RadvdInterface', 'ns3::empty', 'ns3::DefaultDeleter<ns3::RadvdInterface>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::RadvdPrefix, ns3::empty, ns3::DefaultDeleter<ns3::RadvdPrefix> > [class]
+    module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::RadvdPrefix', 'ns3::empty', 'ns3::DefaultDeleter<ns3::RadvdPrefix>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
     ## radvd.h: ns3::Radvd [class]
     module.add_class('Radvd', parent=root_module['ns3::Application'])
+    ## radvd-interface.h: ns3::RadvdInterface [class]
+    module.add_class('RadvdInterface', parent=root_module['ns3::SimpleRefCount< ns3::RadvdInterface, ns3::empty, ns3::DefaultDeleter<ns3::RadvdInterface> >'])
+    ## radvd-prefix.h: ns3::RadvdPrefix [class]
+    module.add_class('RadvdPrefix', parent=root_module['ns3::SimpleRefCount< ns3::RadvdPrefix, ns3::empty, ns3::DefaultDeleter<ns3::RadvdPrefix> >'])
     
     ## Register a nested module for the namespace Config
     
@@ -28,6 +32,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -64,6 +74,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -81,9 +95,42 @@ def register_types_ns3_olsr(module):
     
 
 def register_methods(root_module):
+    register_Ns3Radvd_methods(root_module, root_module['ns3::Radvd'])
     register_Ns3RadvdInterface_methods(root_module, root_module['ns3::RadvdInterface'])
     register_Ns3RadvdPrefix_methods(root_module, root_module['ns3::RadvdPrefix'])
-    register_Ns3Radvd_methods(root_module, root_module['ns3::Radvd'])
+    return
+
+def register_Ns3Radvd_methods(root_module, cls):
+    ## radvd.h: ns3::Radvd::Radvd(ns3::Radvd const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::Radvd const &', 'arg0')])
+    ## radvd.h: ns3::Radvd::Radvd() [constructor]
+    cls.add_constructor([])
+    ## radvd.h: void ns3::Radvd::AddConfiguration(ns3::Ptr<ns3::RadvdInterface> routerInterface) [member function]
+    cls.add_method('AddConfiguration', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::RadvdInterface >', 'routerInterface')])
+    ## radvd.h: static ns3::TypeId ns3::Radvd::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## radvd.h: ns3::Radvd::MAX_RA_DELAY_TIME [variable]
+    cls.add_static_attribute('MAX_RA_DELAY_TIME', 'uint32_t const', is_const=True)
+    ## radvd.h: void ns3::Radvd::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
+    ## radvd.h: void ns3::Radvd::StartApplication() [member function]
+    cls.add_method('StartApplication', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
+    ## radvd.h: void ns3::Radvd::StopApplication() [member function]
+    cls.add_method('StopApplication', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
     return
 
 def register_Ns3RadvdInterface_methods(root_module, cls):
@@ -350,44 +397,12 @@ def register_Ns3RadvdPrefix_methods(root_module, cls):
                    [param('uint32_t', 'validLifeTime')])
     return
 
-def register_Ns3Radvd_methods(root_module, cls):
-    ## radvd.h: ns3::Radvd::Radvd(ns3::Radvd const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Radvd const &', 'arg0')])
-    ## radvd.h: ns3::Radvd::Radvd() [constructor]
-    cls.add_constructor([])
-    ## radvd.h: void ns3::Radvd::AddConfiguration(ns3::Ptr<ns3::RadvdInterface> routerInterface) [member function]
-    cls.add_method('AddConfiguration', 
-                   'void', 
-                   [param('ns3::Ptr< ns3::RadvdInterface >', 'routerInterface')])
-    ## radvd.h: static ns3::TypeId ns3::Radvd::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 
-                   'ns3::TypeId', 
-                   [], 
-                   is_static=True)
-    ## radvd.h: ns3::Radvd::MAX_RA_DELAY_TIME [variable]
-    cls.add_static_attribute('MAX_RA_DELAY_TIME', 'uint32_t const', is_const=True)
-    ## radvd.h: void ns3::Radvd::DoDispose() [member function]
-    cls.add_method('DoDispose', 
-                   'void', 
-                   [], 
-                   visibility='protected', is_virtual=True)
-    ## radvd.h: void ns3::Radvd::StartApplication() [member function]
-    cls.add_method('StartApplication', 
-                   'void', 
-                   [], 
-                   visibility='private', is_virtual=True)
-    ## radvd.h: void ns3::Radvd::StopApplication() [member function]
-    cls.add_method('StopApplication', 
-                   'void', 
-                   [], 
-                   visibility='private', is_virtual=True)
-    return
-
 def register_functions(root_module):
     module = root_module
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -403,6 +418,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/ns3_module_simulator.py

@@ -5,8 +5,6 @@ def register_types(module):
     
     ## event-id.h: ns3::EventId [class]
     module.add_class('EventId')
-    ## event-impl.h: ns3::EventImpl [class]
-    module.add_class('EventImpl', allow_subclassing=True)
     ## high-precision-128.h: ns3::HighPrecision [class]
     module.add_class('HighPrecision')
     ## simulator.h: ns3::Simulator [class]
@@ -35,20 +33,20 @@ def register_types(module):
     module.add_class('Event', outer_class=root_module['ns3::Scheduler'])
     ## scheduler.h: ns3::Scheduler::EventKey [struct]
     module.add_class('EventKey', outer_class=root_module['ns3::Scheduler'])
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::EventImpl, ns3::empty, ns3::DefaultDeleter<ns3::EventImpl> > [class]
+    module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::EventImpl', 'ns3::empty', 'ns3::DefaultDeleter<ns3::EventImpl>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
     ## simulator-impl.h: ns3::SimulatorImpl [class]
     module.add_class('SimulatorImpl', parent=root_module['ns3::Object'])
     ## synchronizer.h: ns3::Synchronizer [class]
     module.add_class('Synchronizer', parent=root_module['ns3::Object'])
-    ## nstime.h: ns3::TimeChecker [class]
-    module.add_class('TimeChecker', parent=root_module['ns3::AttributeChecker'])
-    ## nstime.h: ns3::TimeValue [class]
-    module.add_class('TimeValue', parent=root_module['ns3::AttributeValue'])
     ## wall-clock-synchronizer.h: ns3::WallClockSynchronizer [class]
     module.add_class('WallClockSynchronizer', parent=root_module['ns3::Synchronizer'])
     ## calendar-scheduler.h: ns3::CalendarScheduler [class]
     module.add_class('CalendarScheduler', parent=root_module['ns3::Scheduler'])
     ## default-simulator-impl.h: ns3::DefaultSimulatorImpl [class]
     module.add_class('DefaultSimulatorImpl', parent=root_module['ns3::SimulatorImpl'])
+    ## event-impl.h: ns3::EventImpl [class]
+    module.add_class('EventImpl', parent=root_module['ns3::SimpleRefCount< ns3::EventImpl, ns3::empty, ns3::DefaultDeleter<ns3::EventImpl> >'])
     ## heap-scheduler.h: ns3::HeapScheduler [class]
     module.add_class('HeapScheduler', parent=root_module['ns3::Scheduler'])
     ## list-scheduler.h: ns3::ListScheduler [class]
@@ -61,6 +59,10 @@ def register_types(module):
     module.add_class('RealtimeSimulatorImpl', parent=root_module['ns3::SimulatorImpl'])
     ## realtime-simulator-impl.h: ns3::RealtimeSimulatorImpl::SynchronizationMode [enumeration]
     module.add_enum('SynchronizationMode', ['SYNC_BEST_EFFORT', 'SYNC_HARD_LIMIT'], outer_class=root_module['ns3::RealtimeSimulatorImpl'])
+    ## nstime.h: ns3::TimeChecker [class]
+    module.add_class('TimeChecker', parent=root_module['ns3::AttributeChecker'])
+    ## nstime.h: ns3::TimeValue [class]
+    module.add_class('TimeValue', parent=root_module['ns3::AttributeValue'])
     typehandlers.add_type_alias('ns3::TimeUnit< 2 >', 'ns3::TimeSquare')
     typehandlers.add_type_alias('ns3::TimeUnit< 2 >*', 'ns3::TimeSquare*')
     typehandlers.add_type_alias('ns3::TimeUnit< 2 >&', 'ns3::TimeSquare&')
@@ -92,6 +94,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -130,6 +138,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -148,7 +160,6 @@ def register_types_ns3_olsr(module):
 
 def register_methods(root_module):
     register_Ns3EventId_methods(root_module, root_module['ns3::EventId'])
-    register_Ns3EventImpl_methods(root_module, root_module['ns3::EventImpl'])
     register_Ns3HighPrecision_methods(root_module, root_module['ns3::HighPrecision'])
     register_Ns3Simulator_methods(root_module, root_module['ns3::Simulator'])
     register_Ns3TimeInvert_methods(root_module, root_module['ns3::TimeInvert'])
@@ -163,16 +174,17 @@ def register_methods(root_module):
     register_Ns3SchedulerEventKey_methods(root_module, root_module['ns3::Scheduler::EventKey'])
     register_Ns3SimulatorImpl_methods(root_module, root_module['ns3::SimulatorImpl'])
     register_Ns3Synchronizer_methods(root_module, root_module['ns3::Synchronizer'])
-    register_Ns3TimeChecker_methods(root_module, root_module['ns3::TimeChecker'])
-    register_Ns3TimeValue_methods(root_module, root_module['ns3::TimeValue'])
     register_Ns3WallClockSynchronizer_methods(root_module, root_module['ns3::WallClockSynchronizer'])
     register_Ns3CalendarScheduler_methods(root_module, root_module['ns3::CalendarScheduler'])
     register_Ns3DefaultSimulatorImpl_methods(root_module, root_module['ns3::DefaultSimulatorImpl'])
+    register_Ns3EventImpl_methods(root_module, root_module['ns3::EventImpl'])
     register_Ns3HeapScheduler_methods(root_module, root_module['ns3::HeapScheduler'])
     register_Ns3ListScheduler_methods(root_module, root_module['ns3::ListScheduler'])
     register_Ns3MapScheduler_methods(root_module, root_module['ns3::MapScheduler'])
     register_Ns3Ns2CalendarScheduler_methods(root_module, root_module['ns3::Ns2CalendarScheduler'])
     register_Ns3RealtimeSimulatorImpl_methods(root_module, root_module['ns3::RealtimeSimulatorImpl'])
+    register_Ns3TimeChecker_methods(root_module, root_module['ns3::TimeChecker'])
+    register_Ns3TimeValue_methods(root_module, root_module['ns3::TimeValue'])
     return
 
 def register_Ns3EventId_methods(root_module, cls):
@@ -182,12 +194,17 @@ def register_Ns3EventId_methods(root_module, cls):
     cls.add_constructor([param('ns3::EventId const &', 'arg0')])
     ## event-id.h: ns3::EventId::EventId() [constructor]
     cls.add_constructor([])
-    ## event-id.h: ns3::EventId::EventId(ns3::Ptr<ns3::EventImpl> const & impl, uint64_t ts, uint32_t uid) [constructor]
-    cls.add_constructor([param('ns3::Ptr< ns3::EventImpl > const &', 'impl'), param('uint64_t', 'ts'), param('uint32_t', 'uid')])
+    ## event-id.h: ns3::EventId::EventId(ns3::Ptr<ns3::EventImpl> const & impl, uint64_t ts, uint32_t context, uint32_t uid) [constructor]
+    cls.add_constructor([param('ns3::Ptr< ns3::EventImpl > const &', 'impl'), param('uint64_t', 'ts'), param('uint32_t', 'context'), param('uint32_t', 'uid')])
     ## event-id.h: void ns3::EventId::Cancel() [member function]
     cls.add_method('Cancel', 
                    'void', 
                    [])
+    ## event-id.h: uint32_t ns3::EventId::GetContext() const [member function]
+    cls.add_method('GetContext', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## event-id.h: uint64_t ns3::EventId::GetTs() const [member function]
     cls.add_method('GetTs', 
                    'uint64_t', 
@@ -215,40 +232,6 @@ def register_Ns3EventId_methods(root_module, cls):
                    is_const=True)
     return
 
-def register_Ns3EventImpl_methods(root_module, cls):
-    ## event-impl.h: ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::EventImpl const &', 'arg0')])
-    ## event-impl.h: ns3::EventImpl::EventImpl() [constructor]
-    cls.add_constructor([])
-    ## event-impl.h: void ns3::EventImpl::Cancel() [member function]
-    cls.add_method('Cancel', 
-                   'void', 
-                   [])
-    ## event-impl.h: void ns3::EventImpl::Invoke() [member function]
-    cls.add_method('Invoke', 
-                   'void', 
-                   [])
-    ## event-impl.h: bool ns3::EventImpl::IsCancelled() [member function]
-    cls.add_method('IsCancelled', 
-                   'bool', 
-                   [])
-    ## event-impl.h: void ns3::EventImpl::Ref() const [member function]
-    cls.add_method('Ref', 
-                   'void', 
-                   [], 
-                   is_const=True)
-    ## event-impl.h: void ns3::EventImpl::Unref() const [member function]
-    cls.add_method('Unref', 
-                   'void', 
-                   [], 
-                   is_const=True)
-    ## event-impl.h: void ns3::EventImpl::Notify() [member function]
-    cls.add_method('Notify', 
-                   'void', 
-                   [], 
-                   is_pure_virtual=True, visibility='protected', is_virtual=True)
-    return
-
 def register_Ns3HighPrecision_methods(root_module, cls):
     ## high-precision-128.h: ns3::HighPrecision::HighPrecision(ns3::HighPrecision const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::HighPrecision const &', 'arg0')])
@@ -314,6 +297,11 @@ def register_Ns3Simulator_methods(root_module, cls):
                    'void', 
                    [], 
                    is_static=True)
+    ## simulator.h: static uint32_t ns3::Simulator::GetContext() [member function]
+    cls.add_method('GetContext', 
+                   'uint32_t', 
+                   [], 
+                   is_static=True)
     ## simulator.h: static ns3::Time ns3::Simulator::GetDelayLeft(ns3::EventId const & id) [member function]
     cls.add_method('GetDelayLeft', 
                    'ns3::Time', 
@@ -364,10 +352,10 @@ def register_Ns3Simulator_methods(root_module, cls):
                    'void', 
                    [param('ns3::Ptr< ns3::SimulatorImpl >', 'impl')], 
                    is_static=True)
-    ## simulator.h: static void ns3::Simulator::SetScheduler(ns3::Ptr<ns3::Scheduler> scheduler) [member function]
+    ## simulator.h: static void ns3::Simulator::SetScheduler(ns3::ObjectFactory schedulerFactory) [member function]
     cls.add_method('SetScheduler', 
                    'void', 
-                   [param('ns3::Ptr< ns3::Scheduler >', 'scheduler')], 
+                   [param('ns3::ObjectFactory', 'schedulerFactory')], 
                    is_static=True)
     ## simulator.h: static void ns3::Simulator::Stop() [member function]
     cls.add_method('Stop', 
@@ -769,6 +757,8 @@ def register_Ns3SchedulerEventKey_methods(root_module, cls):
     cls.add_constructor([])
     ## scheduler.h: ns3::Scheduler::EventKey::EventKey(ns3::Scheduler::EventKey const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::Scheduler::EventKey const &', 'arg0')])
+    ## scheduler.h: ns3::Scheduler::EventKey::m_context [variable]
+    cls.add_instance_attribute('m_context', 'uint32_t', is_const=False)
     ## scheduler.h: ns3::Scheduler::EventKey::m_ts [variable]
     cls.add_instance_attribute('m_ts', 'uint64_t', is_const=False)
     ## scheduler.h: ns3::Scheduler::EventKey::m_uid [variable]
@@ -790,6 +780,11 @@ def register_Ns3SimulatorImpl_methods(root_module, cls):
                    'void', 
                    [], 
                    is_pure_virtual=True, is_virtual=True)
+    ## simulator-impl.h: uint32_t ns3::SimulatorImpl::GetContext() const [member function]
+    cls.add_method('GetContext', 
+                   'uint32_t', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     ## simulator-impl.h: ns3::Time ns3::SimulatorImpl::GetDelayLeft(ns3::EventId const & id) const [member function]
     cls.add_method('GetDelayLeft', 
                    'ns3::Time', 
@@ -850,16 +845,26 @@ def register_Ns3SimulatorImpl_methods(root_module, cls):
                    'ns3::EventId', 
                    [param('ns3::EventImpl *', 'event')], 
                    is_pure_virtual=True, is_virtual=True)
-    ## simulator-impl.h: void ns3::SimulatorImpl::SetScheduler(ns3::Ptr<ns3::Scheduler> scheduler) [member function]
+    ## simulator-impl.h: void ns3::SimulatorImpl::ScheduleWithContext(uint32_t context, ns3::Time const & time, ns3::EventImpl * event) [member function]
+    cls.add_method('ScheduleWithContext', 
+                   'void', 
+                   [param('uint32_t', 'context'), param('ns3::Time const &', 'time'), param('ns3::EventImpl *', 'event')], 
+                   is_pure_virtual=True, is_virtual=True)
+    ## simulator-impl.h: void ns3::SimulatorImpl::SetScheduler(ns3::ObjectFactory schedulerFactory) [member function]
     cls.add_method('SetScheduler', 
                    'void', 
-                   [param('ns3::Ptr< ns3::Scheduler >', 'scheduler')], 
+                   [param('ns3::ObjectFactory', 'schedulerFactory')], 
                    is_pure_virtual=True, is_virtual=True)
     ## simulator-impl.h: void ns3::SimulatorImpl::Stop() [member function]
     cls.add_method('Stop', 
                    'void', 
                    [], 
                    is_pure_virtual=True, is_virtual=True)
+    ## simulator-impl.h: void ns3::SimulatorImpl::Stop(ns3::Time const & time) [member function]
+    cls.add_method('Stop', 
+                   'void', 
+                   [param('ns3::Time const &', 'time')], 
+                   is_pure_virtual=True, is_virtual=True)
     return
 
 def register_Ns3Synchronizer_methods(root_module, cls):
@@ -959,46 +964,6 @@ def register_Ns3Synchronizer_methods(root_module, cls):
                    is_pure_virtual=True, visibility='protected', is_virtual=True)
     return
 
-def register_Ns3TimeChecker_methods(root_module, cls):
-    ## nstime.h: ns3::TimeChecker::TimeChecker() [constructor]
-    cls.add_constructor([])
-    ## nstime.h: ns3::TimeChecker::TimeChecker(ns3::TimeChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::TimeChecker const &', 'arg0')])
-    return
-
-def register_Ns3TimeValue_methods(root_module, cls):
-    ## nstime.h: ns3::TimeValue::TimeValue() [constructor]
-    cls.add_constructor([])
-    ## nstime.h: ns3::TimeValue::TimeValue(ns3::TimeValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::TimeValue const &', 'arg0')])
-    ## nstime.h: ns3::TimeValue::TimeValue(ns3::Time const & value) [constructor]
-    cls.add_constructor([param('ns3::Time const &', 'value')])
-    ## nstime.h: ns3::Ptr<ns3::AttributeValue> ns3::TimeValue::Copy() const [member function]
-    cls.add_method('Copy', 
-                   'ns3::Ptr< ns3::AttributeValue >', 
-                   [], 
-                   is_const=True, is_virtual=True)
-    ## nstime.h: bool ns3::TimeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
-    cls.add_method('DeserializeFromString', 
-                   'bool', 
-                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
-                   is_virtual=True)
-    ## nstime.h: ns3::Time ns3::TimeValue::Get() const [member function]
-    cls.add_method('Get', 
-                   'ns3::Time', 
-                   [], 
-                   is_const=True)
-    ## nstime.h: std::string ns3::TimeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
-    cls.add_method('SerializeToString', 
-                   'std::string', 
-                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
-                   is_const=True, is_virtual=True)
-    ## nstime.h: void ns3::TimeValue::Set(ns3::Time const & value) [member function]
-    cls.add_method('Set', 
-                   'void', 
-                   [param('ns3::Time const &', 'value')])
-    return
-
 def register_Ns3WallClockSynchronizer_methods(root_module, cls):
     ## wall-clock-synchronizer.h: ns3::WallClockSynchronizer::WallClockSynchronizer(ns3::WallClockSynchronizer const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::WallClockSynchronizer const &', 'arg0')])
@@ -1149,6 +1114,11 @@ def register_Ns3DefaultSimulatorImpl_methods(root_module, cls):
                    'void', 
                    [], 
                    is_virtual=True)
+    ## default-simulator-impl.h: uint32_t ns3::DefaultSimulatorImpl::GetContext() const [member function]
+    cls.add_method('GetContext', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## default-simulator-impl.h: ns3::Time ns3::DefaultSimulatorImpl::GetDelayLeft(ns3::EventId const & id) const [member function]
     cls.add_method('GetDelayLeft', 
                    'ns3::Time', 
@@ -1214,16 +1184,55 @@ def register_Ns3DefaultSimulatorImpl_methods(root_module, cls):
                    'ns3::EventId', 
                    [param('ns3::EventImpl *', 'event')], 
                    is_virtual=True)
-    ## default-simulator-impl.h: void ns3::DefaultSimulatorImpl::SetScheduler(ns3::Ptr<ns3::Scheduler> scheduler) [member function]
+    ## default-simulator-impl.h: void ns3::DefaultSimulatorImpl::ScheduleWithContext(uint32_t context, ns3::Time const & time, ns3::EventImpl * event) [member function]
+    cls.add_method('ScheduleWithContext', 
+                   'void', 
+                   [param('uint32_t', 'context'), param('ns3::Time const &', 'time'), param('ns3::EventImpl *', 'event')], 
+                   is_virtual=True)
+    ## default-simulator-impl.h: void ns3::DefaultSimulatorImpl::SetScheduler(ns3::ObjectFactory schedulerFactory) [member function]
     cls.add_method('SetScheduler', 
                    'void', 
-                   [param('ns3::Ptr< ns3::Scheduler >', 'scheduler')], 
+                   [param('ns3::ObjectFactory', 'schedulerFactory')], 
                    is_virtual=True)
     ## default-simulator-impl.h: void ns3::DefaultSimulatorImpl::Stop() [member function]
     cls.add_method('Stop', 
                    'void', 
                    [], 
                    is_virtual=True)
+    ## default-simulator-impl.h: void ns3::DefaultSimulatorImpl::Stop(ns3::Time const & time) [member function]
+    cls.add_method('Stop', 
+                   'void', 
+                   [param('ns3::Time const &', 'time')], 
+                   is_virtual=True)
+    ## default-simulator-impl.h: void ns3::DefaultSimulatorImpl::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
+    return
+
+def register_Ns3EventImpl_methods(root_module, cls):
+    ## event-impl.h: ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::EventImpl const &', 'arg0')])
+    ## event-impl.h: ns3::EventImpl::EventImpl() [constructor]
+    cls.add_constructor([])
+    ## event-impl.h: void ns3::EventImpl::Cancel() [member function]
+    cls.add_method('Cancel', 
+                   'void', 
+                   [])
+    ## event-impl.h: void ns3::EventImpl::Invoke() [member function]
+    cls.add_method('Invoke', 
+                   'void', 
+                   [])
+    ## event-impl.h: bool ns3::EventImpl::IsCancelled() [member function]
+    cls.add_method('IsCancelled', 
+                   'bool', 
+                   [])
+    ## event-impl.h: void ns3::EventImpl::Notify() [member function]
+    cls.add_method('Notify', 
+                   'void', 
+                   [], 
+                   is_pure_virtual=True, visibility='protected', is_virtual=True)
     return
 
 def register_Ns3HeapScheduler_methods(root_module, cls):
@@ -1389,6 +1398,11 @@ def register_Ns3RealtimeSimulatorImpl_methods(root_module, cls):
                    'void', 
                    [], 
                    is_virtual=True)
+    ## realtime-simulator-impl.h: uint32_t ns3::RealtimeSimulatorImpl::GetContext() const [member function]
+    cls.add_method('GetContext', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## realtime-simulator-impl.h: ns3::Time ns3::RealtimeSimulatorImpl::GetDelayLeft(ns3::EventId const & id) const [member function]
     cls.add_method('GetDelayLeft', 
                    'ns3::Time', 
@@ -1477,14 +1491,27 @@ def register_Ns3RealtimeSimulatorImpl_methods(root_module, cls):
     cls.add_method('ScheduleRealtimeNow', 
                    'void', 
                    [param('ns3::EventImpl *', 'event')])
+    ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::ScheduleRealtimeNowWithContext(uint32_t context, ns3::EventImpl * event) [member function]
+    cls.add_method('ScheduleRealtimeNowWithContext', 
+                   'void', 
+                   [param('uint32_t', 'context'), param('ns3::EventImpl *', 'event')])
+    ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::ScheduleRealtimeWithContext(uint32_t context, ns3::Time const & time, ns3::EventImpl * event) [member function]
+    cls.add_method('ScheduleRealtimeWithContext', 
+                   'void', 
+                   [param('uint32_t', 'context'), param('ns3::Time const &', 'time'), param('ns3::EventImpl *', 'event')])
+    ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::ScheduleWithContext(uint32_t context, ns3::Time const & time, ns3::EventImpl * event) [member function]
+    cls.add_method('ScheduleWithContext', 
+                   'void', 
+                   [param('uint32_t', 'context'), param('ns3::Time const &', 'time'), param('ns3::EventImpl *', 'event')], 
+                   is_virtual=True)
     ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::SetHardLimit(ns3::Time limit) [member function]
     cls.add_method('SetHardLimit', 
                    'void', 
                    [param('ns3::Time', 'limit')])
-    ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::SetScheduler(ns3::Ptr<ns3::Scheduler> scheduler) [member function]
+    ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::SetScheduler(ns3::ObjectFactory schedulerFactory) [member function]
     cls.add_method('SetScheduler', 
                    'void', 
-                   [param('ns3::Ptr< ns3::Scheduler >', 'scheduler')], 
+                   [param('ns3::ObjectFactory', 'schedulerFactory')], 
                    is_virtual=True)
     ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::SetSynchronizationMode(ns3::RealtimeSimulatorImpl::SynchronizationMode mode) [member function]
     cls.add_method('SetSynchronizationMode', 
@@ -1495,6 +1522,56 @@ def register_Ns3RealtimeSimulatorImpl_methods(root_module, cls):
                    'void', 
                    [], 
                    is_virtual=True)
+    ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::Stop(ns3::Time const & time) [member function]
+    cls.add_method('Stop', 
+                   'void', 
+                   [param('ns3::Time const &', 'time')], 
+                   is_virtual=True)
+    ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
+    return
+
+def register_Ns3TimeChecker_methods(root_module, cls):
+    ## nstime.h: ns3::TimeChecker::TimeChecker() [constructor]
+    cls.add_constructor([])
+    ## nstime.h: ns3::TimeChecker::TimeChecker(ns3::TimeChecker const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::TimeChecker const &', 'arg0')])
+    return
+
+def register_Ns3TimeValue_methods(root_module, cls):
+    ## nstime.h: ns3::TimeValue::TimeValue() [constructor]
+    cls.add_constructor([])
+    ## nstime.h: ns3::TimeValue::TimeValue(ns3::TimeValue const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::TimeValue const &', 'arg0')])
+    ## nstime.h: ns3::TimeValue::TimeValue(ns3::Time const & value) [constructor]
+    cls.add_constructor([param('ns3::Time const &', 'value')])
+    ## nstime.h: ns3::Ptr<ns3::AttributeValue> ns3::TimeValue::Copy() const [member function]
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## nstime.h: bool ns3::TimeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_virtual=True)
+    ## nstime.h: ns3::Time ns3::TimeValue::Get() const [member function]
+    cls.add_method('Get', 
+                   'ns3::Time', 
+                   [], 
+                   is_const=True)
+    ## nstime.h: std::string ns3::TimeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, is_virtual=True)
+    ## nstime.h: void ns3::TimeValue::Set(ns3::Time const & value) [member function]
+    cls.add_method('Set', 
+                   'void', 
+                   [param('ns3::Time const &', 'value')])
     return
 
 def register_functions(root_module):
@@ -1515,7 +1592,7 @@ def register_functions(root_module):
     module.add_function('MakeTimeChecker', 
                         'ns3::Ptr< ns3::AttributeChecker const >', 
                         [])
-    ## high-precision.h: extern ns3::HighPrecision ns3::Max(ns3::HighPrecision const & a, ns3::HighPrecision const & b) [free function]
+    ## high-precision.h: ns3::HighPrecision ns3::Max(ns3::HighPrecision const & a, ns3::HighPrecision const & b) [free function]
     module.add_function('Max', 
                         'ns3::HighPrecision', 
                         [param('ns3::HighPrecision const &', 'a'), param('ns3::HighPrecision const &', 'b')])
@@ -1527,7 +1604,7 @@ def register_functions(root_module):
     module.add_function('MilliSeconds', 
                         'ns3::Time', 
                         [param('uint64_t', 'ms')])
-    ## high-precision.h: extern ns3::HighPrecision ns3::Min(ns3::HighPrecision const & a, ns3::HighPrecision const & b) [free function]
+    ## high-precision.h: ns3::HighPrecision ns3::Min(ns3::HighPrecision const & a, ns3::HighPrecision const & b) [free function]
     module.add_function('Min', 
                         'ns3::HighPrecision', 
                         [param('ns3::HighPrecision const &', 'a'), param('ns3::HighPrecision const &', 'b')])
@@ -1554,6 +1631,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -1577,6 +1655,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/ns3_module_static_routing.py

@@ -34,6 +34,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -70,6 +76,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -447,15 +457,15 @@ def register_Ns3Ipv4StaticRouting_methods(root_module, cls):
     cls.add_method('RemoveRoute', 
                    'void', 
                    [param('uint32_t', 'i')])
-    ## ipv4-static-routing.h: bool ns3::Ipv4StaticRouting::RouteInput(ns3::Ptr<ns3::Packet const> p, ns3::Ipv4Header const & header, ns3::Ptr<const ns3::NetDevice> idev, ns3::Callback<void,ns3::Ptr<ns3::Ipv4Route>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ucb, ns3::Callback<void,ns3::Ptr<ns3::Ipv4MulticastRoute>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> mcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,unsigned int,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> lcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::Socket::SocketErrno,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ecb) [member function]
+    ## ipv4-static-routing.h: bool ns3::Ipv4StaticRouting::RouteInput(ns3::Ptr<ns3::Packet const> p, ns3::Ipv4Header const & header, ns3::Ptr<const ns3::NetDevice> idev, ns3::Callback<void, ns3::Ptr<ns3::Ipv4Route>, ns3::Ptr<ns3::Packet const>, ns3::Ipv4Header const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ucb, ns3::Callback<void,ns3::Ptr<ns3::Ipv4MulticastRoute>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> mcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,unsigned int,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> lcb, ns3::Callback<void, ns3::Ptr<ns3::Packet const>, ns3::Ipv4Header const&, ns3::Socket::SocketErrno, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ecb) [member function]
     cls.add_method('RouteInput', 
                    'bool', 
                    [param('ns3::Ptr< ns3::Packet const >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice const >', 'idev'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv4Route >, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ucb'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv4MulticastRoute >, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'mcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'lcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::Socket::SocketErrno, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ecb')], 
                    is_virtual=True)
-    ## ipv4-static-routing.h: ns3::Ptr<ns3::Ipv4Route> ns3::Ipv4StaticRouting::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Header const & header, uint32_t oif, ns3::Socket::SocketErrno & sockerr) [member function]
+    ## ipv4-static-routing.h: ns3::Ptr<ns3::Ipv4Route> ns3::Ipv4StaticRouting::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Header const & header, ns3::Ptr<ns3::NetDevice> oif, ns3::Socket::SocketErrno & sockerr) [member function]
     cls.add_method('RouteOutput', 
                    'ns3::Ptr< ns3::Ipv4Route >', 
-                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('uint32_t', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice >', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
                    is_virtual=True)
     ## ipv4-static-routing.h: void ns3::Ipv4StaticRouting::SetDefaultMulticastRoute(uint32_t outputInterface) [member function]
     cls.add_method('SetDefaultMulticastRoute', 
@@ -592,10 +602,10 @@ def register_Ns3Ipv6StaticRouting_methods(root_module, cls):
                    'bool', 
                    [param('ns3::Ptr< ns3::Packet const >', 'p'), param('ns3::Ipv6Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice const >', 'idev'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv6Route >, ns3::Ptr< ns3::Packet const >, ns3::Ipv6Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ucb'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv6MulticastRoute >, ns3::Ptr< ns3::Packet const >, ns3::Ipv6Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'mcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv6Header const &, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'lcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv6Header const &, ns3::Socket::SocketErrno, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ecb')], 
                    is_virtual=True)
-    ## ipv6-static-routing.h: ns3::Ptr<ns3::Ipv6Route> ns3::Ipv6StaticRouting::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv6Header const & header, uint32_t oif, ns3::Socket::SocketErrno & sockerr) [member function]
+    ## ipv6-static-routing.h: ns3::Ptr<ns3::Ipv6Route> ns3::Ipv6StaticRouting::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv6Header const & header, ns3::Ptr<ns3::NetDevice> oif, ns3::Socket::SocketErrno & sockerr) [member function]
     cls.add_method('RouteOutput', 
                    'ns3::Ptr< ns3::Ipv6Route >', 
-                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv6Header const &', 'header'), param('uint32_t', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv6Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice >', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')], 
                    is_virtual=True)
     ## ipv6-static-routing.h: void ns3::Ipv6StaticRouting::SetDefaultMulticastRoute(uint32_t outputInterface) [member function]
     cls.add_method('SetDefaultMulticastRoute', 
@@ -622,6 +632,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -637,6 +648,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/ns3_module_stats.py

@@ -5,18 +5,16 @@ def register_types(module):
     
     ## data-output-interface.h: ns3::DataOutputCallback [class]
     module.add_class('DataOutputCallback', allow_subclassing=True)
+    ## data-calculator.h: ns3::StatisticalSummary [class]
+    module.add_class('StatisticalSummary', allow_subclassing=True)
     ## data-calculator.h: ns3::DataCalculator [class]
     module.add_class('DataCalculator', parent=root_module['ns3::Object'])
     ## data-collector.h: ns3::DataCollector [class]
     module.add_class('DataCollector', parent=root_module['ns3::Object'])
     ## data-output-interface.h: ns3::DataOutputInterface [class]
     module.add_class('DataOutputInterface', parent=root_module['ns3::Object'])
-    ## basic-data-calculators.h: ns3::MinMaxAvgTotalCalculator<unsigned int> [class]
-    module.add_class('MinMaxAvgTotalCalculator', template_parameters=['unsigned int'], parent=root_module['ns3::DataCalculator'])
     ## omnet-data-output.h: ns3::OmnetDataOutput [class]
     module.add_class('OmnetDataOutput', parent=root_module['ns3::DataOutputInterface'])
-    ## packet-data-calculators.h: ns3::PacketSizeMinMaxAvgTotalCalculator [class]
-    module.add_class('PacketSizeMinMaxAvgTotalCalculator', parent=root_module['ns3::MinMaxAvgTotalCalculator< unsigned int >'])
     ## sqlite-data-output.h: ns3::SqliteDataOutput [class]
     module.add_class('SqliteDataOutput', parent=root_module['ns3::DataOutputInterface'])
     ## time-data-calculators.h: ns3::TimeMinMaxAvgTotalCalculator [class]
@@ -50,6 +48,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -86,6 +90,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -104,12 +112,11 @@ def register_types_ns3_olsr(module):
 
 def register_methods(root_module):
     register_Ns3DataOutputCallback_methods(root_module, root_module['ns3::DataOutputCallback'])
+    register_Ns3StatisticalSummary_methods(root_module, root_module['ns3::StatisticalSummary'])
     register_Ns3DataCalculator_methods(root_module, root_module['ns3::DataCalculator'])
     register_Ns3DataCollector_methods(root_module, root_module['ns3::DataCollector'])
     register_Ns3DataOutputInterface_methods(root_module, root_module['ns3::DataOutputInterface'])
-    register_Ns3MinMaxAvgTotalCalculator__Unsigned_int_methods(root_module, root_module['ns3::MinMaxAvgTotalCalculator< unsigned int >'])
     register_Ns3OmnetDataOutput_methods(root_module, root_module['ns3::OmnetDataOutput'])
-    register_Ns3PacketSizeMinMaxAvgTotalCalculator_methods(root_module, root_module['ns3::PacketSizeMinMaxAvgTotalCalculator'])
     register_Ns3SqliteDataOutput_methods(root_module, root_module['ns3::SqliteDataOutput'])
     register_Ns3TimeMinMaxAvgTotalCalculator_methods(root_module, root_module['ns3::TimeMinMaxAvgTotalCalculator'])
     register_Ns3CounterCalculator__Unsigned_int_methods(root_module, root_module['ns3::CounterCalculator< unsigned int >'])
@@ -146,6 +153,58 @@ def register_Ns3DataOutputCallback_methods(root_module, cls):
                    'void', 
                    [param('std::string', 'key'), param('std::string', 'variable'), param('ns3::Time', 'val')], 
                    is_pure_virtual=True, is_virtual=True)
+    ## data-output-interface.h: void ns3::DataOutputCallback::OutputStatistic(std::string key, std::string variable, ns3::StatisticalSummary const * statSum) [member function]
+    cls.add_method('OutputStatistic', 
+                   'void', 
+                   [param('std::string', 'key'), param('std::string', 'variable'), param('ns3::StatisticalSummary const *', 'statSum')], 
+                   is_pure_virtual=True, is_virtual=True)
+    return
+
+def register_Ns3StatisticalSummary_methods(root_module, cls):
+    ## data-calculator.h: ns3::StatisticalSummary::StatisticalSummary() [constructor]
+    cls.add_constructor([])
+    ## data-calculator.h: ns3::StatisticalSummary::StatisticalSummary(ns3::StatisticalSummary const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::StatisticalSummary const &', 'arg0')])
+    ## data-calculator.h: long int ns3::StatisticalSummary::getCount() const [member function]
+    cls.add_method('getCount', 
+                   'long int', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
+    ## data-calculator.h: double ns3::StatisticalSummary::getMax() const [member function]
+    cls.add_method('getMax', 
+                   'double', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
+    ## data-calculator.h: double ns3::StatisticalSummary::getMean() const [member function]
+    cls.add_method('getMean', 
+                   'double', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
+    ## data-calculator.h: double ns3::StatisticalSummary::getMin() const [member function]
+    cls.add_method('getMin', 
+                   'double', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
+    ## data-calculator.h: double ns3::StatisticalSummary::getSqrSum() const [member function]
+    cls.add_method('getSqrSum', 
+                   'double', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
+    ## data-calculator.h: double ns3::StatisticalSummary::getStddev() const [member function]
+    cls.add_method('getStddev', 
+                   'double', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
+    ## data-calculator.h: double ns3::StatisticalSummary::getSum() const [member function]
+    cls.add_method('getSum', 
+                   'double', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
+    ## data-calculator.h: double ns3::StatisticalSummary::getVariance() const [member function]
+    cls.add_method('getVariance', 
+                   'double', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     return
 
 def register_Ns3DataCalculator_methods(root_module, cls):
@@ -161,6 +220,11 @@ def register_Ns3DataCalculator_methods(root_module, cls):
     cls.add_method('Enable', 
                    'void', 
                    [])
+    ## data-calculator.h: std::string ns3::DataCalculator::GetContext() const [member function]
+    cls.add_method('GetContext', 
+                   'std::string', 
+                   [], 
+                   is_const=True)
     ## data-calculator.h: bool ns3::DataCalculator::GetEnabled() const [member function]
     cls.add_method('GetEnabled', 
                    'bool', 
@@ -176,6 +240,10 @@ def register_Ns3DataCalculator_methods(root_module, cls):
                    'void', 
                    [param('ns3::DataOutputCallback &', 'callback')], 
                    is_pure_virtual=True, is_const=True, is_virtual=True)
+    ## data-calculator.h: void ns3::DataCalculator::SetContext(std::string const context) [member function]
+    cls.add_method('SetContext', 
+                   'void', 
+                   [param('std::string const', 'context')])
     ## data-calculator.h: void ns3::DataCalculator::SetKey(std::string const key) [member function]
     cls.add_method('SetKey', 
                    'void', 
@@ -296,27 +364,6 @@ def register_Ns3DataOutputInterface_methods(root_module, cls):
                    visibility='protected', is_virtual=True)
     return
 
-def register_Ns3MinMaxAvgTotalCalculator__Unsigned_int_methods(root_module, cls):
-    ## basic-data-calculators.h: ns3::MinMaxAvgTotalCalculator<unsigned int>::MinMaxAvgTotalCalculator(ns3::MinMaxAvgTotalCalculator<unsigned int> const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::MinMaxAvgTotalCalculator< unsigned int > const &', 'arg0')])
-    ## basic-data-calculators.h: ns3::MinMaxAvgTotalCalculator<unsigned int>::MinMaxAvgTotalCalculator() [constructor]
-    cls.add_constructor([])
-    ## basic-data-calculators.h: void ns3::MinMaxAvgTotalCalculator<unsigned int>::Output(ns3::DataOutputCallback & callback) const [member function]
-    cls.add_method('Output', 
-                   'void', 
-                   [param('ns3::DataOutputCallback &', 'callback')], 
-                   is_const=True, is_virtual=True)
-    ## basic-data-calculators.h: void ns3::MinMaxAvgTotalCalculator<unsigned int>::Update(unsigned int const i) [member function]
-    cls.add_method('Update', 
-                   'void', 
-                   [param('unsigned int const', 'i')])
-    ## basic-data-calculators.h: void ns3::MinMaxAvgTotalCalculator<unsigned int>::DoDispose() [member function]
-    cls.add_method('DoDispose', 
-                   'void', 
-                   [], 
-                   visibility='protected', is_virtual=True)
-    return
-
 def register_Ns3OmnetDataOutput_methods(root_module, cls):
     ## omnet-data-output.h: ns3::OmnetDataOutput::OmnetDataOutput(ns3::OmnetDataOutput const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::OmnetDataOutput const &', 'arg0')])
@@ -334,26 +381,6 @@ def register_Ns3OmnetDataOutput_methods(root_module, cls):
                    visibility='protected', is_virtual=True)
     return
 
-def register_Ns3PacketSizeMinMaxAvgTotalCalculator_methods(root_module, cls):
-    ## packet-data-calculators.h: ns3::PacketSizeMinMaxAvgTotalCalculator::PacketSizeMinMaxAvgTotalCalculator(ns3::PacketSizeMinMaxAvgTotalCalculator const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::PacketSizeMinMaxAvgTotalCalculator const &', 'arg0')])
-    ## packet-data-calculators.h: ns3::PacketSizeMinMaxAvgTotalCalculator::PacketSizeMinMaxAvgTotalCalculator() [constructor]
-    cls.add_constructor([])
-    ## packet-data-calculators.h: void ns3::PacketSizeMinMaxAvgTotalCalculator::FrameUpdate(std::string path, ns3::Ptr<ns3::Packet const> packet, ns3::Mac48Address realto) [member function]
-    cls.add_method('FrameUpdate', 
-                   'void', 
-                   [param('std::string', 'path'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::Mac48Address', 'realto')])
-    ## packet-data-calculators.h: void ns3::PacketSizeMinMaxAvgTotalCalculator::PacketUpdate(std::string path, ns3::Ptr<ns3::Packet const> packet) [member function]
-    cls.add_method('PacketUpdate', 
-                   'void', 
-                   [param('std::string', 'path'), param('ns3::Ptr< ns3::Packet const >', 'packet')])
-    ## packet-data-calculators.h: void ns3::PacketSizeMinMaxAvgTotalCalculator::DoDispose() [member function]
-    cls.add_method('DoDispose', 
-                   'void', 
-                   [], 
-                   visibility='protected', is_virtual=True)
-    return
-
 def register_Ns3SqliteDataOutput_methods(root_module, cls):
     ## sqlite-data-output.h: ns3::SqliteDataOutput::SqliteDataOutput(ns3::SqliteDataOutput const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::SqliteDataOutput const &', 'arg0')])
@@ -444,9 +471,14 @@ def register_Ns3PacketCounterCalculator_methods(root_module, cls):
 
 def register_functions(root_module):
     module = root_module
+    ## data-calculator.h: bool ns3::isNaN(double x) [free function]
+    module.add_function('isNaN', 
+                        'bool', 
+                        [param('double', 'x')])
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -462,6 +494,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/ns3_module_tap_bridge.py

@@ -26,6 +26,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -62,6 +68,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -258,6 +268,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -273,6 +284,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/ns3_module_test.py

@@ -22,6 +22,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -58,6 +64,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -82,6 +92,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -97,6 +108,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/ns3_module_udp_client_server.py

@@ -0,0 +1,284 @@
+from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandlers
+
+def register_types(module):
+    root_module = module.get_root()
+    
+    ## packet-loss-counter.h: ns3::PacketLossCounter [class]
+    module.add_class('PacketLossCounter')
+    ## udp-client.h: ns3::UdpClient [class]
+    module.add_class('UdpClient', parent=root_module['ns3::Application'])
+    ## udp-server.h: ns3::UdpServer [class]
+    module.add_class('UdpServer', parent=root_module['ns3::Application'])
+    ## udp-trace-client.h: ns3::UdpTraceClient [class]
+    module.add_class('UdpTraceClient', parent=root_module['ns3::Application'])
+    
+    ## Register a nested module for the namespace Config
+    
+    nested_module = module.add_cpp_namespace('Config')
+    register_types_ns3_Config(nested_module)
+    
+    
+    ## Register a nested module for the namespace TimeStepPrecision
+    
+    nested_module = module.add_cpp_namespace('TimeStepPrecision')
+    register_types_ns3_TimeStepPrecision(nested_module)
+    
+    
+    ## Register a nested module for the namespace addressUtils
+    
+    nested_module = module.add_cpp_namespace('addressUtils')
+    register_types_ns3_addressUtils(nested_module)
+    
+    
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
+    ## Register a nested module for the namespace dot11s
+    
+    nested_module = module.add_cpp_namespace('dot11s')
+    register_types_ns3_dot11s(nested_module)
+    
+    
+    ## Register a nested module for the namespace flame
+    
+    nested_module = module.add_cpp_namespace('flame')
+    register_types_ns3_flame(nested_module)
+    
+    
+    ## Register a nested module for the namespace internal
+    
+    nested_module = module.add_cpp_namespace('internal')
+    register_types_ns3_internal(nested_module)
+    
+    
+    ## Register a nested module for the namespace olsr
+    
+    nested_module = module.add_cpp_namespace('olsr')
+    register_types_ns3_olsr(nested_module)
+    
+
+def register_types_ns3_Config(module):
+    root_module = module.get_root()
+    
+
+def register_types_ns3_TimeStepPrecision(module):
+    root_module = module.get_root()
+    
+
+def register_types_ns3_addressUtils(module):
+    root_module = module.get_root()
+    
+
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
+def register_types_ns3_dot11s(module):
+    root_module = module.get_root()
+    
+
+def register_types_ns3_flame(module):
+    root_module = module.get_root()
+    
+
+def register_types_ns3_internal(module):
+    root_module = module.get_root()
+    
+
+def register_types_ns3_olsr(module):
+    root_module = module.get_root()
+    
+
+def register_methods(root_module):
+    register_Ns3PacketLossCounter_methods(root_module, root_module['ns3::PacketLossCounter'])
+    register_Ns3UdpClient_methods(root_module, root_module['ns3::UdpClient'])
+    register_Ns3UdpServer_methods(root_module, root_module['ns3::UdpServer'])
+    register_Ns3UdpTraceClient_methods(root_module, root_module['ns3::UdpTraceClient'])
+    return
+
+def register_Ns3PacketLossCounter_methods(root_module, cls):
+    ## packet-loss-counter.h: ns3::PacketLossCounter::PacketLossCounter(ns3::PacketLossCounter const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::PacketLossCounter const &', 'arg0')])
+    ## packet-loss-counter.h: ns3::PacketLossCounter::PacketLossCounter(uint8_t bitmapSize) [constructor]
+    cls.add_constructor([param('uint8_t', 'bitmapSize')])
+    ## packet-loss-counter.h: uint16_t ns3::PacketLossCounter::GetBitMapSize() const [member function]
+    cls.add_method('GetBitMapSize', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
+    ## packet-loss-counter.h: uint32_t ns3::PacketLossCounter::GetLost() const [member function]
+    cls.add_method('GetLost', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
+    ## packet-loss-counter.h: void ns3::PacketLossCounter::NotifyReceived(uint32_t seq) [member function]
+    cls.add_method('NotifyReceived', 
+                   'void', 
+                   [param('uint32_t', 'seq')])
+    ## packet-loss-counter.h: void ns3::PacketLossCounter::SetBitMapSize(uint16_t size) [member function]
+    cls.add_method('SetBitMapSize', 
+                   'void', 
+                   [param('uint16_t', 'size')])
+    return
+
+def register_Ns3UdpClient_methods(root_module, cls):
+    ## udp-client.h: ns3::UdpClient::UdpClient(ns3::UdpClient const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::UdpClient const &', 'arg0')])
+    ## udp-client.h: ns3::UdpClient::UdpClient() [constructor]
+    cls.add_constructor([])
+    ## udp-client.h: static ns3::TypeId ns3::UdpClient::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## udp-client.h: void ns3::UdpClient::SetRemote(ns3::Ipv4Address ip, uint16_t port) [member function]
+    cls.add_method('SetRemote', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'ip'), param('uint16_t', 'port')])
+    ## udp-client.h: void ns3::UdpClient::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
+    ## udp-client.h: void ns3::UdpClient::StartApplication() [member function]
+    cls.add_method('StartApplication', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
+    ## udp-client.h: void ns3::UdpClient::StopApplication() [member function]
+    cls.add_method('StopApplication', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
+    return
+
+def register_Ns3UdpServer_methods(root_module, cls):
+    ## udp-server.h: ns3::UdpServer::UdpServer(ns3::UdpServer const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::UdpServer const &', 'arg0')])
+    ## udp-server.h: ns3::UdpServer::UdpServer() [constructor]
+    cls.add_constructor([])
+    ## udp-server.h: uint32_t ns3::UdpServer::GetLost() const [member function]
+    cls.add_method('GetLost', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
+    ## udp-server.h: uint16_t ns3::UdpServer::GetPacketWindowSize() const [member function]
+    cls.add_method('GetPacketWindowSize', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
+    ## udp-server.h: uint32_t ns3::UdpServer::GetReceived() const [member function]
+    cls.add_method('GetReceived', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
+    ## udp-server.h: static ns3::TypeId ns3::UdpServer::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## udp-server.h: void ns3::UdpServer::SetPacketWindowSize(uint16_t size) [member function]
+    cls.add_method('SetPacketWindowSize', 
+                   'void', 
+                   [param('uint16_t', 'size')])
+    ## udp-server.h: void ns3::UdpServer::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
+    ## udp-server.h: void ns3::UdpServer::StartApplication() [member function]
+    cls.add_method('StartApplication', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
+    ## udp-server.h: void ns3::UdpServer::StopApplication() [member function]
+    cls.add_method('StopApplication', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
+    return
+
+def register_Ns3UdpTraceClient_methods(root_module, cls):
+    ## udp-trace-client.h: ns3::UdpTraceClient::UdpTraceClient(ns3::UdpTraceClient const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::UdpTraceClient const &', 'arg0')])
+    ## udp-trace-client.h: ns3::UdpTraceClient::UdpTraceClient() [constructor]
+    cls.add_constructor([])
+    ## udp-trace-client.h: ns3::UdpTraceClient::UdpTraceClient(ns3::Ipv4Address ip, uint16_t port, char * traceFile) [constructor]
+    cls.add_constructor([param('ns3::Ipv4Address', 'ip'), param('uint16_t', 'port'), param('char *', 'traceFile')])
+    ## udp-trace-client.h: uint16_t ns3::UdpTraceClient::GetMaxPacketSize() [member function]
+    cls.add_method('GetMaxPacketSize', 
+                   'uint16_t', 
+                   [])
+    ## udp-trace-client.h: static ns3::TypeId ns3::UdpTraceClient::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## udp-trace-client.h: void ns3::UdpTraceClient::SetMaxPacketSize(uint16_t maxPacketSize) [member function]
+    cls.add_method('SetMaxPacketSize', 
+                   'void', 
+                   [param('uint16_t', 'maxPacketSize')])
+    ## udp-trace-client.h: void ns3::UdpTraceClient::SetRemote(ns3::Ipv4Address ip, uint16_t port) [member function]
+    cls.add_method('SetRemote', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'ip'), param('uint16_t', 'port')])
+    ## udp-trace-client.h: void ns3::UdpTraceClient::SetTraceFile(std::string filename) [member function]
+    cls.add_method('SetTraceFile', 
+                   'void', 
+                   [param('std::string', 'filename')])
+    ## udp-trace-client.h: void ns3::UdpTraceClient::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
+    ## udp-trace-client.h: void ns3::UdpTraceClient::StartApplication() [member function]
+    cls.add_method('StartApplication', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
+    ## udp-trace-client.h: void ns3::UdpTraceClient::StopApplication() [member function]
+    cls.add_method('StopApplication', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
+    return
+
+def register_functions(root_module):
+    module = root_module
+    register_functions_ns3_Config(module.get_submodule('Config'), root_module)
+    register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
+    register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
+    register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
+    register_functions_ns3_flame(module.get_submodule('flame'), root_module)
+    register_functions_ns3_internal(module.get_submodule('internal'), root_module)
+    register_functions_ns3_olsr(module.get_submodule('olsr'), root_module)
+    return
+
+def register_functions_ns3_Config(module, root_module):
+    return
+
+def register_functions_ns3_TimeStepPrecision(module, root_module):
+    return
+
+def register_functions_ns3_addressUtils(module, root_module):
+    return
+
+def register_functions_ns3_aodv(module, root_module):
+    return
+
+def register_functions_ns3_dot11s(module, root_module):
+    return
+
+def register_functions_ns3_flame(module, root_module):
+    return
+
+def register_functions_ns3_internal(module, root_module):
+    return
+
+def register_functions_ns3_olsr(module, root_module):
+    return
+

bindings/python/apidefs/gcc-LP64/ns3_module_udp_echo.py

@@ -26,6 +26,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -62,6 +68,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -167,6 +177,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -182,6 +193,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/ns3_module_v4ping.py

@@ -24,6 +24,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -60,6 +66,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -112,6 +122,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -127,6 +138,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/ns3_module_virtual_net_device.py

@@ -24,6 +24,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -60,6 +66,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -242,6 +252,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -257,6 +268,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/apidefs/gcc-LP64/ns3_module_wifi.py

@@ -8,7 +8,9 @@ def register_types(module):
     ## wifi-preamble.h: ns3::WifiPreamble [enumeration]
     module.add_enum('WifiPreamble', ['WIFI_PREAMBLE_LONG', 'WIFI_PREAMBLE_SHORT'])
     ## wifi-phy-standard.h: ns3::WifiPhyStandard [enumeration]
-    module.add_enum('WifiPhyStandard', ['WIFI_PHY_STANDARD_80211a', 'WIFI_PHY_STANDARD_80211b', 'WIFI_PHY_STANDARD_80211_10Mhz', 'WIFI_PHY_STANDARD_80211_5Mhz', 'WIFI_PHY_STANDARD_holland', 'WIFI_PHY_UNKNOWN'])
+    module.add_enum('WifiPhyStandard', ['WIFI_PHY_STANDARD_80211a', 'WIFI_PHY_STANDARD_80211b', 'WIFI_PHY_STANDARD_80211_10Mhz', 'WIFI_PHY_STANDARD_80211_5Mhz', 'WIFI_PHY_STANDARD_holland', 'WIFI_PHY_STANDARD_80211p_CCH', 'WIFI_PHY_STANDARD_80211p_SCH', 'WIFI_PHY_UNKNOWN'])
+    ## qos-tag.h: ns3::UserPriority [enumeration]
+    module.add_enum('UserPriority', ['UP_BK', 'UP_BE', 'UP_EE', 'UP_CL', 'UP_VI', 'UP_VO', 'UP_NC'])
     ## qos-utils.h: ns3::AccessClass [enumeration]
     module.add_enum('AccessClass', ['AC_VO', 'AC_VI', 'AC_BE', 'AC_BK', 'AC_BE_NQOS', 'AC_UNDEF'])
     ## edca-txop-n.h: ns3::TypeOfStation [enumeration]
@@ -83,12 +85,26 @@ def register_types(module):
     module.add_class('RandomPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
     ## rraa-wifi-manager.h: ns3::RraaWifiRemoteStation [class]
     module.add_class('RraaWifiRemoteStation', parent=root_module['ns3::WifiRemoteStation'])
-    ## ssid.h: ns3::SsidChecker [class]
-    module.add_class('SsidChecker', parent=root_module['ns3::AttributeChecker'])
-    ## ssid.h: ns3::SsidValue [class]
-    module.add_class('SsidValue', parent=root_module['ns3::AttributeValue'])
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::InterferenceHelper::Event, ns3::empty, ns3::DefaultDeleter<ns3::InterferenceHelper::Event> > [class]
+    module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::InterferenceHelper::Event', 'ns3::empty', 'ns3::DefaultDeleter<ns3::InterferenceHelper::Event>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
     ## propagation-loss-model.h: ns3::ThreeLogDistancePropagationLossModel [class]
     module.add_class('ThreeLogDistancePropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
+    ## mgt-headers.h: ns3::WifiActionHeader [class]
+    module.add_class('WifiActionHeader', parent=root_module['ns3::Header'])
+    ## mgt-headers.h: ns3::WifiActionHeader::CategoryValue [enumeration]
+    module.add_enum('CategoryValue', ['MESH_PEERING_MGT', 'MESH_LINK_METRIC', 'MESH_PATH_SELECTION', 'MESH_INTERWORKING', 'MESH_RESOURCE_COORDINATION', 'MESH_PROXY_FORWARDING'], outer_class=root_module['ns3::WifiActionHeader'])
+    ## mgt-headers.h: ns3::WifiActionHeader::PeerLinkMgtActionValue [enumeration]
+    module.add_enum('PeerLinkMgtActionValue', ['PEER_LINK_OPEN', 'PEER_LINK_CONFIRM', 'PEER_LINK_CLOSE'], outer_class=root_module['ns3::WifiActionHeader'])
+    ## mgt-headers.h: ns3::WifiActionHeader::LinkMetricActionValue [enumeration]
+    module.add_enum('LinkMetricActionValue', ['LINK_METRIC_REQUEST', 'LINK_METRIC_REPORT'], outer_class=root_module['ns3::WifiActionHeader'])
+    ## mgt-headers.h: ns3::WifiActionHeader::PathSelectionActionValue [enumeration]
+    module.add_enum('PathSelectionActionValue', ['PATH_SELECTION'], outer_class=root_module['ns3::WifiActionHeader'])
+    ## mgt-headers.h: ns3::WifiActionHeader::InterworkActionValue [enumeration]
+    module.add_enum('InterworkActionValue', ['PORTAL_ANNOUNCEMENT'], outer_class=root_module['ns3::WifiActionHeader'])
+    ## mgt-headers.h: ns3::WifiActionHeader::ResourceCoordinationActionValue [enumeration]
+    module.add_enum('ResourceCoordinationActionValue', ['CONGESTION_CONTROL_NOTIFICATION', 'MDA_SETUP_REQUEST', 'MDA_SETUP_REPLY', 'MDAOP_ADVERTISMENT_REQUEST', 'MDAOP_ADVERTISMENTS', 'MDAOP_SET_TEARDOWN', 'BEACON_TIMING_REQUEST', 'BEACON_TIMING_RESPONSE', 'TBTT_ADJUSTMENT_REQUEST', 'MESH_CHANNEL_SWITCH_ANNOUNCEMENT'], outer_class=root_module['ns3::WifiActionHeader'])
+    ## mgt-headers.h: ns3::WifiActionHeader::ActionValue [union]
+    module.add_class('ActionValue', outer_class=root_module['ns3::WifiActionHeader'])
     ## wifi-mac.h: ns3::WifiMac [class]
     module.add_class('WifiMac', parent=root_module['ns3::Object'])
     ## wifi-mac-header.h: ns3::WifiMacHeader [class]
@@ -97,14 +113,10 @@ def register_types(module):
     module.add_enum('QosAckPolicy', ['NORMAL_ACK', 'NO_ACK', 'NO_EXPLICIT_ACK', 'BLOCK_ACK'], outer_class=root_module['ns3::WifiMacHeader'])
     ## wifi-mac-header.h: ns3::WifiMacHeader::AddressType [enumeration]
     module.add_enum('AddressType', ['ADDR1', 'ADDR2', 'ADDR3', 'ADDR4'], outer_class=root_module['ns3::WifiMacHeader'])
-    ## wifi-mode.h: ns3::WifiModeChecker [class]
-    module.add_class('WifiModeChecker', parent=root_module['ns3::AttributeChecker'])
-    ## wifi-mode.h: ns3::WifiModeValue [class]
-    module.add_class('WifiModeValue', parent=root_module['ns3::AttributeValue'])
     ## wifi-phy.h: ns3::WifiPhy [class]
     module.add_class('WifiPhy', parent=root_module['ns3::Object'])
     ## wifi-phy.h: ns3::WifiPhy::State [enumeration]
-    module.add_enum('State', ['SYNC', 'TX', 'CCA_BUSY', 'IDLE', 'SWITCHING'], outer_class=root_module['ns3::WifiPhy'])
+    module.add_enum('State', ['IDLE', 'CCA_BUSY', 'TX', 'RX', 'SWITCHING'], outer_class=root_module['ns3::WifiPhy'])
     ## wifi-remote-station-manager.h: ns3::WifiRemoteStationManager [class]
     module.add_class('WifiRemoteStationManager', parent=root_module['ns3::Object'])
     ## yans-wifi-phy.h: ns3::YansWifiPhy [class]
@@ -163,8 +175,16 @@ def register_types(module):
     module.add_class('QstaWifiMac', parent=root_module['ns3::WifiMac'])
     ## rraa-wifi-manager.h: ns3::RraaWifiManager [class]
     module.add_class('RraaWifiManager', parent=root_module['ns3::WifiRemoteStationManager'])
+    ## ssid.h: ns3::SsidChecker [class]
+    module.add_class('SsidChecker', parent=root_module['ns3::AttributeChecker'])
+    ## ssid.h: ns3::SsidValue [class]
+    module.add_class('SsidValue', parent=root_module['ns3::AttributeValue'])
     ## wifi-channel.h: ns3::WifiChannel [class]
     module.add_class('WifiChannel', parent=root_module['ns3::Channel'])
+    ## wifi-mode.h: ns3::WifiModeChecker [class]
+    module.add_class('WifiModeChecker', parent=root_module['ns3::AttributeChecker'])
+    ## wifi-mode.h: ns3::WifiModeValue [class]
+    module.add_class('WifiModeValue', parent=root_module['ns3::AttributeValue'])
     ## wifi-net-device.h: ns3::WifiNetDevice [class]
     module.add_class('WifiNetDevice', parent=root_module['ns3::NetDevice'])
     ## yans-error-rate-model.h: ns3::YansErrorRateModel [class]
@@ -203,6 +223,12 @@ def register_types(module):
     register_types_ns3_addressUtils(nested_module)
     
     
+    ## Register a nested module for the namespace aodv
+    
+    nested_module = module.add_cpp_namespace('aodv')
+    register_types_ns3_aodv(nested_module)
+    
+    
     ## Register a nested module for the namespace dot11s
     
     nested_module = module.add_cpp_namespace('dot11s')
@@ -239,6 +265,10 @@ def register_types_ns3_addressUtils(module):
     root_module = module.get_root()
     
 
+def register_types_ns3_aodv(module):
+    root_module = module.get_root()
+    
+
 def register_types_ns3_dot11s(module):
     root_module = module.get_root()
     
@@ -290,13 +320,11 @@ def register_methods(root_module):
     register_Ns3RandomPropagationDelayModel_methods(root_module, root_module['ns3::RandomPropagationDelayModel'])
     register_Ns3RandomPropagationLossModel_methods(root_module, root_module['ns3::RandomPropagationLossModel'])
     register_Ns3RraaWifiRemoteStation_methods(root_module, root_module['ns3::RraaWifiRemoteStation'])
-    register_Ns3SsidChecker_methods(root_module, root_module['ns3::SsidChecker'])
-    register_Ns3SsidValue_methods(root_module, root_module['ns3::SsidValue'])
     register_Ns3ThreeLogDistancePropagationLossModel_methods(root_module, root_module['ns3::ThreeLogDistancePropagationLossModel'])
+    register_Ns3WifiActionHeader_methods(root_module, root_module['ns3::WifiActionHeader'])
+    register_Ns3WifiActionHeaderActionValue_methods(root_module, root_module['ns3::WifiActionHeader::ActionValue'])
     register_Ns3WifiMac_methods(root_module, root_module['ns3::WifiMac'])
     register_Ns3WifiMacHeader_methods(root_module, root_module['ns3::WifiMacHeader'])
-    register_Ns3WifiModeChecker_methods(root_module, root_module['ns3::WifiModeChecker'])
-    register_Ns3WifiModeValue_methods(root_module, root_module['ns3::WifiModeValue'])
     register_Ns3WifiPhy_methods(root_module, root_module['ns3::WifiPhy'])
     register_Ns3WifiRemoteStationManager_methods(root_module, root_module['ns3::WifiRemoteStationManager'])
     register_Ns3YansWifiPhy_methods(root_module, root_module['ns3::YansWifiPhy'])
@@ -327,7 +355,11 @@ def register_methods(root_module):
     register_Ns3QapWifiMac_methods(root_module, root_module['ns3::QapWifiMac'])
     register_Ns3QstaWifiMac_methods(root_module, root_module['ns3::QstaWifiMac'])
     register_Ns3RraaWifiManager_methods(root_module, root_module['ns3::RraaWifiManager'])
+    register_Ns3SsidChecker_methods(root_module, root_module['ns3::SsidChecker'])
+    register_Ns3SsidValue_methods(root_module, root_module['ns3::SsidValue'])
     register_Ns3WifiChannel_methods(root_module, root_module['ns3::WifiChannel'])
+    register_Ns3WifiModeChecker_methods(root_module, root_module['ns3::WifiModeChecker'])
+    register_Ns3WifiModeValue_methods(root_module, root_module['ns3::WifiModeValue'])
     register_Ns3WifiNetDevice_methods(root_module, root_module['ns3::WifiNetDevice'])
     register_Ns3YansErrorRateModel_methods(root_module, root_module['ns3::YansErrorRateModel'])
     register_Ns3YansWifiChannel_methods(root_module, root_module['ns3::YansWifiChannel'])
@@ -1982,11 +2014,6 @@ def register_Ns3QosTag_methods(root_module, cls):
                    'void', 
                    [param('ns3::TagBuffer', 'i')], 
                    is_virtual=True)
-    ## qos-tag.h: uint8_t ns3::QosTag::Get() const [member function]
-    cls.add_method('Get', 
-                   'uint8_t', 
-                   [], 
-                   is_const=True)
     ## qos-tag.h: ns3::TypeId ns3::QosTag::GetInstanceTypeId() const [member function]
     cls.add_method('GetInstanceTypeId', 
                    'ns3::TypeId', 
@@ -1997,6 +2024,11 @@ def register_Ns3QosTag_methods(root_module, cls):
                    'uint32_t', 
                    [], 
                    is_const=True, is_virtual=True)
+    ## qos-tag.h: uint8_t ns3::QosTag::GetTid() const [member function]
+    cls.add_method('GetTid', 
+                   'uint8_t', 
+                   [], 
+                   is_const=True)
     ## qos-tag.h: static ns3::TypeId ns3::QosTag::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2012,10 +2044,14 @@ def register_Ns3QosTag_methods(root_module, cls):
                    'void', 
                    [param('ns3::TagBuffer', 'i')], 
                    is_const=True, is_virtual=True)
-    ## qos-tag.h: void ns3::QosTag::Set(uint8_t tid) [member function]
-    cls.add_method('Set', 
+    ## qos-tag.h: void ns3::QosTag::SetTid(uint8_t tid) [member function]
+    cls.add_method('SetTid', 
                    'void', 
                    [param('uint8_t', 'tid')])
+    ## qos-tag.h: void ns3::QosTag::SetUserPriority(ns3::UserPriority up) [member function]
+    cls.add_method('SetUserPriority', 
+                   'void', 
+                   [param('ns3::UserPriority', 'up')])
     return
 
 def register_Ns3RandomPropagationDelayModel_methods(root_module, cls):
@@ -2112,46 +2148,6 @@ def register_Ns3RraaWifiRemoteStation_methods(root_module, cls):
                    is_const=True, visibility='private', is_virtual=True)
     return
 
-def register_Ns3SsidChecker_methods(root_module, cls):
-    ## ssid.h: ns3::SsidChecker::SsidChecker() [constructor]
-    cls.add_constructor([])
-    ## ssid.h: ns3::SsidChecker::SsidChecker(ns3::SsidChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::SsidChecker const &', 'arg0')])
-    return
-
-def register_Ns3SsidValue_methods(root_module, cls):
-    ## ssid.h: ns3::SsidValue::SsidValue() [constructor]
-    cls.add_constructor([])
-    ## ssid.h: ns3::SsidValue::SsidValue(ns3::SsidValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::SsidValue const &', 'arg0')])
-    ## ssid.h: ns3::SsidValue::SsidValue(ns3::Ssid const & value) [constructor]
-    cls.add_constructor([param('ns3::Ssid const &', 'value')])
-    ## ssid.h: ns3::Ptr<ns3::AttributeValue> ns3::SsidValue::Copy() const [member function]
-    cls.add_method('Copy', 
-                   'ns3::Ptr< ns3::AttributeValue >', 
-                   [], 
-                   is_const=True, is_virtual=True)
-    ## ssid.h: bool ns3::SsidValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
-    cls.add_method('DeserializeFromString', 
-                   'bool', 
-                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
-                   is_virtual=True)
-    ## ssid.h: ns3::Ssid ns3::SsidValue::Get() const [member function]
-    cls.add_method('Get', 
-                   'ns3::Ssid', 
-                   [], 
-                   is_const=True)
-    ## ssid.h: std::string ns3::SsidValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
-    cls.add_method('SerializeToString', 
-                   'std::string', 
-                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
-                   is_const=True, is_virtual=True)
-    ## ssid.h: void ns3::SsidValue::Set(ns3::Ssid const & value) [member function]
-    cls.add_method('Set', 
-                   'void', 
-                   [param('ns3::Ssid const &', 'value')])
-    return
-
 def register_Ns3ThreeLogDistancePropagationLossModel_methods(root_module, cls):
     ## propagation-loss-model.h: static ns3::TypeId ns3::ThreeLogDistancePropagationLossModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
@@ -2167,6 +2163,72 @@ def register_Ns3ThreeLogDistancePropagationLossModel_methods(root_module, cls):
                    is_const=True, visibility='private', is_virtual=True)
     return
 
+def register_Ns3WifiActionHeader_methods(root_module, cls):
+    ## mgt-headers.h: ns3::WifiActionHeader::WifiActionHeader(ns3::WifiActionHeader const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::WifiActionHeader const &', 'arg0')])
+    ## mgt-headers.h: ns3::WifiActionHeader::WifiActionHeader() [constructor]
+    cls.add_constructor([])
+    ## mgt-headers.h: uint32_t ns3::WifiActionHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
+    cls.add_method('Deserialize', 
+                   'uint32_t', 
+                   [param('ns3::Buffer::Iterator', 'start')], 
+                   is_virtual=True)
+    ## mgt-headers.h: ns3::WifiActionHeader::ActionValue ns3::WifiActionHeader::GetAction() [member function]
+    cls.add_method('GetAction', 
+                   'ns3::WifiActionHeader::ActionValue', 
+                   [])
+    ## mgt-headers.h: ns3::WifiActionHeader::CategoryValue ns3::WifiActionHeader::GetCategory() [member function]
+    cls.add_method('GetCategory', 
+                   'ns3::WifiActionHeader::CategoryValue', 
+                   [])
+    ## mgt-headers.h: ns3::TypeId ns3::WifiActionHeader::GetInstanceTypeId() const [member function]
+    cls.add_method('GetInstanceTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## mgt-headers.h: uint32_t ns3::WifiActionHeader::GetSerializedSize() const [member function]
+    cls.add_method('GetSerializedSize', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## mgt-headers.h: static ns3::TypeId ns3::WifiActionHeader::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## mgt-headers.h: void ns3::WifiActionHeader::Print(std::ostream & os) const [member function]
+    cls.add_method('Print', 
+                   'void', 
+                   [param('std::ostream &', 'os')], 
+                   is_const=True, is_virtual=True)
+    ## mgt-headers.h: void ns3::WifiActionHeader::Serialize(ns3::Buffer::Iterator start) const [member function]
+    cls.add_method('Serialize', 
+                   'void', 
+                   [param('ns3::Buffer::Iterator', 'start')], 
+                   is_const=True, is_virtual=True)
+    ## mgt-headers.h: void ns3::WifiActionHeader::SetAction(ns3::WifiActionHeader::CategoryValue type, ns3::WifiActionHeader::ActionValue action) [member function]
+    cls.add_method('SetAction', 
+                   'void', 
+                   [param('ns3::WifiActionHeader::CategoryValue', 'type'), param('ns3::WifiActionHeader::ActionValue', 'action')])
+    return
+
+def register_Ns3WifiActionHeaderActionValue_methods(root_module, cls):
+    ## mgt-headers.h: ns3::WifiActionHeader::ActionValue::ActionValue() [constructor]
+    cls.add_constructor([])
+    ## mgt-headers.h: ns3::WifiActionHeader::ActionValue::ActionValue(ns3::WifiActionHeader::ActionValue const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::WifiActionHeader::ActionValue const &', 'arg0')])
+    ## mgt-headers.h: ns3::WifiActionHeader::ActionValue::interwork [variable]
+    cls.add_instance_attribute('interwork', 'ns3::WifiActionHeader::InterworkActionValue', is_const=False)
+    ## mgt-headers.h: ns3::WifiActionHeader::ActionValue::linkMetrtic [variable]
+    cls.add_instance_attribute('linkMetrtic', 'ns3::WifiActionHeader::LinkMetricActionValue', is_const=False)
+    ## mgt-headers.h: ns3::WifiActionHeader::ActionValue::pathSelection [variable]
+    cls.add_instance_attribute('pathSelection', 'ns3::WifiActionHeader::PathSelectionActionValue', is_const=False)
+    ## mgt-headers.h: ns3::WifiActionHeader::ActionValue::peerLink [variable]
+    cls.add_instance_attribute('peerLink', 'ns3::WifiActionHeader::PeerLinkMgtActionValue', is_const=False)
+    ## mgt-headers.h: ns3::WifiActionHeader::ActionValue::resourceCoordination [variable]
+    cls.add_instance_attribute('resourceCoordination', 'ns3::WifiActionHeader::ResourceCoordinationActionValue', is_const=False)
+    return
+
 def register_Ns3WifiMac_methods(root_module, cls):
     ## wifi-mac.h: ns3::WifiMac::WifiMac() [constructor]
     cls.add_constructor([])
@@ -2345,6 +2407,11 @@ def register_Ns3WifiMac_methods(root_module, cls):
                    'bool', 
                    [], 
                    is_pure_virtual=True, is_const=True, is_virtual=True)
+    ## wifi-mac.h: void ns3::WifiMac::ConfigureCCHDcf(ns3::Ptr<ns3::Dcf> dcf, uint32_t cwmin, uint32_t cwmax, ns3::AccessClass ac) [member function]
+    cls.add_method('ConfigureCCHDcf', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Dcf >', 'dcf'), param('uint32_t', 'cwmin'), param('uint32_t', 'cwmax'), param('ns3::AccessClass', 'ac')], 
+                   visibility='protected')
     ## wifi-mac.h: void ns3::WifiMac::ConfigureDcf(ns3::Ptr<ns3::Dcf> dcf, uint32_t cwmin, uint32_t cwmax, ns3::AccessClass ac) [member function]
     cls.add_method('ConfigureDcf', 
                    'void', 
@@ -2746,46 +2813,6 @@ def register_Ns3WifiMacHeader_methods(root_module, cls):
                    [])
     return
 
-def register_Ns3WifiModeChecker_methods(root_module, cls):
-    ## wifi-mode.h: ns3::WifiModeChecker::WifiModeChecker() [constructor]
-    cls.add_constructor([])
-    ## wifi-mode.h: ns3::WifiModeChecker::WifiModeChecker(ns3::WifiModeChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::WifiModeChecker const &', 'arg0')])
-    return
-
-def register_Ns3WifiModeValue_methods(root_module, cls):
-    ## wifi-mode.h: ns3::WifiModeValue::WifiModeValue() [constructor]
-    cls.add_constructor([])
-    ## wifi-mode.h: ns3::WifiModeValue::WifiModeValue(ns3::WifiModeValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::WifiModeValue const &', 'arg0')])
-    ## wifi-mode.h: ns3::WifiModeValue::WifiModeValue(ns3::WifiMode const & value) [constructor]
-    cls.add_constructor([param('ns3::WifiMode const &', 'value')])
-    ## wifi-mode.h: ns3::Ptr<ns3::AttributeValue> ns3::WifiModeValue::Copy() const [member function]
-    cls.add_method('Copy', 
-                   'ns3::Ptr< ns3::AttributeValue >', 
-                   [], 
-                   is_const=True, is_virtual=True)
-    ## wifi-mode.h: bool ns3::WifiModeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
-    cls.add_method('DeserializeFromString', 
-                   'bool', 
-                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
-                   is_virtual=True)
-    ## wifi-mode.h: ns3::WifiMode ns3::WifiModeValue::Get() const [member function]
-    cls.add_method('Get', 
-                   'ns3::WifiMode', 
-                   [], 
-                   is_const=True)
-    ## wifi-mode.h: std::string ns3::WifiModeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
-    cls.add_method('SerializeToString', 
-                   'std::string', 
-                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
-                   is_const=True, is_virtual=True)
-    ## wifi-mode.h: void ns3::WifiModeValue::Set(ns3::WifiMode const & value) [member function]
-    cls.add_method('Set', 
-                   'void', 
-                   [param('ns3::WifiMode const &', 'value')])
-    return
-
 def register_Ns3WifiPhy_methods(root_module, cls):
     ## wifi-phy.h: ns3::WifiPhy::WifiPhy(ns3::WifiPhy const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::WifiPhy const &', 'arg0')])
@@ -3016,8 +3043,13 @@ def register_Ns3WifiPhy_methods(root_module, cls):
                    'bool', 
                    [], 
                    is_pure_virtual=True, is_virtual=True)
-    ## wifi-phy.h: bool ns3::WifiPhy::IsStateSync() [member function]
-    cls.add_method('IsStateSync', 
+    ## wifi-phy.h: bool ns3::WifiPhy::IsStateRx() [member function]
+    cls.add_method('IsStateRx', 
+                   'bool', 
+                   [], 
+                   is_pure_virtual=True, is_virtual=True)
+    ## wifi-phy.h: bool ns3::WifiPhy::IsStateSwitching() [member function]
+    cls.add_method('IsStateSwitching', 
                    'bool', 
                    [], 
                    is_pure_virtual=True, is_virtual=True)
@@ -3363,8 +3395,8 @@ def register_Ns3YansWifiPhy_methods(root_module, cls):
                    'bool', 
                    [], 
                    is_virtual=True)
-    ## yans-wifi-phy.h: bool ns3::YansWifiPhy::IsStateSync() [member function]
-    cls.add_method('IsStateSync', 
+    ## yans-wifi-phy.h: bool ns3::YansWifiPhy::IsStateRx() [member function]
+    cls.add_method('IsStateRx', 
                    'bool', 
                    [], 
                    is_virtual=True)
@@ -4510,6 +4542,11 @@ def register_Ns3NqapWifiMac_methods(root_module, cls):
                    'void', 
                    [], 
                    visibility='private', is_virtual=True)
+    ## nqap-wifi-mac.h: void ns3::NqapWifiMac::DoStart() [member function]
+    cls.add_method('DoStart', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
     ## nqap-wifi-mac.h: void ns3::NqapWifiMac::FinishConfigureStandard(ns3::WifiPhyStandard standard) [member function]
     cls.add_method('FinishConfigureStandard', 
                    'void', 
@@ -4991,6 +5028,11 @@ def register_Ns3QapWifiMac_methods(root_module, cls):
                    'void', 
                    [], 
                    visibility='private', is_virtual=True)
+    ## qap-wifi-mac.h: void ns3::QapWifiMac::DoStart() [member function]
+    cls.add_method('DoStart', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
     ## qap-wifi-mac.h: void ns3::QapWifiMac::FinishConfigureStandard(ns3::WifiPhyStandard standard) [member function]
     cls.add_method('FinishConfigureStandard', 
                    'void', 
@@ -5190,6 +5232,46 @@ def register_Ns3RraaWifiManager_methods(root_module, cls):
                    visibility='private', is_virtual=True)
     return
 
+def register_Ns3SsidChecker_methods(root_module, cls):
+    ## ssid.h: ns3::SsidChecker::SsidChecker() [constructor]
+    cls.add_constructor([])
+    ## ssid.h: ns3::SsidChecker::SsidChecker(ns3::SsidChecker const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::SsidChecker const &', 'arg0')])
+    return
+
+def register_Ns3SsidValue_methods(root_module, cls):
+    ## ssid.h: ns3::SsidValue::SsidValue() [constructor]
+    cls.add_constructor([])
+    ## ssid.h: ns3::SsidValue::SsidValue(ns3::SsidValue const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::SsidValue const &', 'arg0')])
+    ## ssid.h: ns3::SsidValue::SsidValue(ns3::Ssid const & value) [constructor]
+    cls.add_constructor([param('ns3::Ssid const &', 'value')])
+    ## ssid.h: ns3::Ptr<ns3::AttributeValue> ns3::SsidValue::Copy() const [member function]
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## ssid.h: bool ns3::SsidValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_virtual=True)
+    ## ssid.h: ns3::Ssid ns3::SsidValue::Get() const [member function]
+    cls.add_method('Get', 
+                   'ns3::Ssid', 
+                   [], 
+                   is_const=True)
+    ## ssid.h: std::string ns3::SsidValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, is_virtual=True)
+    ## ssid.h: void ns3::SsidValue::Set(ns3::Ssid const & value) [member function]
+    cls.add_method('Set', 
+                   'void', 
+                   [param('ns3::Ssid const &', 'value')])
+    return
+
 def register_Ns3WifiChannel_methods(root_module, cls):
     ## wifi-channel.h: ns3::WifiChannel::WifiChannel() [constructor]
     cls.add_constructor([])
@@ -5202,6 +5284,46 @@ def register_Ns3WifiChannel_methods(root_module, cls):
                    is_static=True)
     return
 
+def register_Ns3WifiModeChecker_methods(root_module, cls):
+    ## wifi-mode.h: ns3::WifiModeChecker::WifiModeChecker() [constructor]
+    cls.add_constructor([])
+    ## wifi-mode.h: ns3::WifiModeChecker::WifiModeChecker(ns3::WifiModeChecker const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::WifiModeChecker const &', 'arg0')])
+    return
+
+def register_Ns3WifiModeValue_methods(root_module, cls):
+    ## wifi-mode.h: ns3::WifiModeValue::WifiModeValue() [constructor]
+    cls.add_constructor([])
+    ## wifi-mode.h: ns3::WifiModeValue::WifiModeValue(ns3::WifiModeValue const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::WifiModeValue const &', 'arg0')])
+    ## wifi-mode.h: ns3::WifiModeValue::WifiModeValue(ns3::WifiMode const & value) [constructor]
+    cls.add_constructor([param('ns3::WifiMode const &', 'value')])
+    ## wifi-mode.h: ns3::Ptr<ns3::AttributeValue> ns3::WifiModeValue::Copy() const [member function]
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## wifi-mode.h: bool ns3::WifiModeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_virtual=True)
+    ## wifi-mode.h: ns3::WifiMode ns3::WifiModeValue::Get() const [member function]
+    cls.add_method('Get', 
+                   'ns3::WifiMode', 
+                   [], 
+                   is_const=True)
+    ## wifi-mode.h: std::string ns3::WifiModeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, is_virtual=True)
+    ## wifi-mode.h: void ns3::WifiModeValue::Set(ns3::WifiMode const & value) [member function]
+    cls.add_method('Set', 
+                   'void', 
+                   [param('ns3::WifiMode const &', 'value')])
+    return
+
 def register_Ns3WifiNetDevice_methods(root_module, cls):
     ## wifi-net-device.h: ns3::WifiNetDevice::WifiNetDevice(ns3::WifiNetDevice const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::WifiNetDevice const &', 'arg0')])
@@ -5364,6 +5486,11 @@ def register_Ns3WifiNetDevice_methods(root_module, cls):
                    'void', 
                    [], 
                    visibility='private', is_virtual=True)
+    ## wifi-net-device.h: void ns3::WifiNetDevice::DoStart() [member function]
+    cls.add_method('DoStart', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
     return
 
 def register_Ns3YansErrorRateModel_methods(root_module, cls):
@@ -5537,6 +5664,7 @@ def register_functions(root_module):
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
+    register_functions_ns3_aodv(module.get_submodule('aodv'), root_module)
     register_functions_ns3_dot11s(module.get_submodule('dot11s'), root_module)
     register_functions_ns3_flame(module.get_submodule('flame'), root_module)
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
@@ -5552,6 +5680,9 @@ def register_functions_ns3_TimeStepPrecision(module, root_module):
 def register_functions_ns3_addressUtils(module, root_module):
     return
 
+def register_functions_ns3_aodv(module, root_module):
+    return
+
 def register_functions_ns3_dot11s(module, root_module):
     return
 

bindings/python/ns3modulegen.py

@@ -17,11 +17,17 @@ import pybindgen.settings
 from ns3modulegen_generated import module_init, register_types, register_methods, register_functions
 import ns3modulegen_core_customizations
 import callbacks_list
+import traceback
 
 this_script_dir = os.path.dirname(os.path.abspath(sys.argv[0]))
 
 class ErrorHandler(pybindgen.settings.ErrorHandler):
     def handle_error(self, wrapper, exception, traceback_):
+        print >> sys.stderr
+        print >> sys.stderr, "---- location:"
+        traceback.print_stack()
+        print >> sys.stderr, "---- error:"
+        traceback.print_tb(traceback_)
         try:
             stack = wrapper.stack_where_defined
         except AttributeError:
@@ -31,7 +37,7 @@ class ErrorHandler(pybindgen.settings.ErrorHandler):
             stack.reverse()
             for (filename, line_number, function_name, text) in stack:
                 file_dir = os.path.dirname(os.path.abspath(filename))
-                if file_dir == this_script_dir:
+                if file_dir.startswith(this_script_dir):
                     print >> sys.stderr, "%s:%i: %r" % (os.path.join("..", "bindings", "python", os.path.basename(filename)),
                                                         line_number, exception)
                     break
@@ -131,13 +137,13 @@ def main():
             pass
 
     if 'Threading' not in enabled_features:
-        for clsname in ['SystemThread', 'SystemMutex', 'SystemCondition', 'CriticalSection']:
+        for clsname in ['SystemThread', 'SystemMutex', 'SystemCondition', 'CriticalSection', 'SimpleRefCount< ns3::SystemThread, ns3::empty >']:
             root_module.classes.remove(root_module['ns3::%s' % clsname])
 
-
     if 'EmuNetDevice' not in enabled_features:
         for clsname in ['EmuNetDevice', 'EmuHelper']:
             root_module.classes.remove(root_module['ns3::%s' % clsname])
+        root_module.enums.remove(root_module['ns3::EmuNetDevice::EncapsulationMode'])
 
     if 'RealTime' not in enabled_features:
         for clsname in ['WallClockSynchronizer', 'RealtimeSimulatorImpl']:

bindings/python/ns3modulegen_core_customizations.py

@@ -246,18 +246,43 @@ public:
                 "parses python args to get C++ value"
                 assert isinstance(wrapper, typehandlers.ForwardWrapperBase)
 
-                py_callback = wrapper.declarations.declare_variable('PyObject*', self.name)
-                wrapper.parse_params.add_parameter('O', ['&'+py_callback], self.name)
-                wrapper.before_call.write_error_check(
-                    '!PyCallable_Check(%s)' % py_callback,
-                    'PyErr_SetString(PyExc_TypeError, "parameter \'%s\' must be callbale");' % self.name)
-                callback_impl = wrapper.declarations.declare_variable(
-                    'ns3::Ptr<%s>' % self.PYTHON_CALLBACK_IMPL_NAME,
-                    '%s_cb_impl' % self.name)
-                wrapper.before_call.write_code("%s = ns3::Create<%s> (%s);"
-                                               % (callback_impl, self.PYTHON_CALLBACK_IMPL_NAME, py_callback))
-                wrapper.call_params.append(
-                    'ns3::Callback<%s> (%s)' % (', '.join(self.TEMPLATE_ARGS), callback_impl))
+                if self.default_value is None:
+                    py_callback = wrapper.declarations.declare_variable('PyObject*', self.name)
+                    wrapper.parse_params.add_parameter('O', ['&'+py_callback], self.name)
+                    wrapper.before_call.write_error_check(
+                        '!PyCallable_Check(%s)' % py_callback,
+                        'PyErr_SetString(PyExc_TypeError, "parameter \'%s\' must be callbale");' % self.name)
+                    callback_impl = wrapper.declarations.declare_variable(
+                        'ns3::Ptr<%s>' % self.PYTHON_CALLBACK_IMPL_NAME,
+                        '%s_cb_impl' % self.name)
+                    wrapper.before_call.write_code("%s = ns3::Create<%s> (%s);"
+                                                   % (callback_impl, self.PYTHON_CALLBACK_IMPL_NAME, py_callback))
+                    wrapper.call_params.append(
+                        'ns3::Callback<%s> (%s)' % (', '.join(self.TEMPLATE_ARGS), callback_impl))
+                else:
+                    py_callback = wrapper.declarations.declare_variable('PyObject*', self.name, 'NULL')
+                    wrapper.parse_params.add_parameter('O', ['&'+py_callback], self.name, optional=True)
+                    value = wrapper.declarations.declare_variable(
+                        'ns3::Callback<%s>' % ', '.join(self.TEMPLATE_ARGS),
+                        self.name+'_value',
+                        self.default_value)
+
+                    wrapper.before_call.write_code("if (%s) {" % (py_callback,))
+                    wrapper.before_call.indent()
+
+                    wrapper.before_call.write_error_check(
+                        '!PyCallable_Check(%s)' % py_callback,
+                        'PyErr_SetString(PyExc_TypeError, "parameter \'%s\' must be callbale");' % self.name)
+
+                    wrapper.before_call.write_code("%s = ns3::Callback<%s> (ns3::Create<%s> (%s));"
+                                                   % (value, ', '.join(self.TEMPLATE_ARGS),
+                                                      self.PYTHON_CALLBACK_IMPL_NAME, py_callback))
+
+                    wrapper.before_call.unindent()
+                    wrapper.before_call.write_code("}") # closes: if (py_callback) {
+                                        
+                    wrapper.call_params.append(value)
+                    
 
             def convert_c_to_python(self, wrapper):
                 raise typehandlers.NotSupportedError("Reverse wrappers for ns3::Callback<...> types "

bindings/python/ns3modulescan.py

@@ -8,7 +8,7 @@ from pybindgen.gccxmlparser import ModuleParser, PygenClassifier, PygenSection,
 from pybindgen.typehandlers.codesink import FileCodeSink
 from pygccxml.declarations import templates
 from pygccxml.declarations.class_declaration import class_t
-from pygccxml.declarations.calldef import free_function_t, member_function_t, constructor_t
+from pygccxml.declarations.calldef import free_function_t, member_function_t, constructor_t, calldef_t
 
 
 ## we need the smart pointer type transformation to be active even
@@ -26,28 +26,6 @@ import warnings
 warnings.filterwarnings(category=WrapperWarning, action='ignore')
 
 type_annotations = {
-    '::ns3::RefCountBase': {
-        'incref_method': 'Ref',
-        'decref_method': 'Unref',
-        'peekref_method': 'GetReferenceCount',
-        'automatic_type_narrowing': 'true',
-        },
-    '::ns3::Object': {
-        'incref_method': 'Ref',
-        'decref_method': 'Unref',
-        'peekref_method': 'GetReferenceCount',
-        'automatic_type_narrowing': 'true',
-        },
-    '::ns3::Packet': {
-        'incref_method': 'Ref',
-        'decref_method': 'Unref',
-        'peekref_method': 'GetReferenceCount',
-        },
-    '::ns3::CallbackImplBase': {
-        'incref_method': 'Ref',
-        'decref_method': 'Unref',
-        'peekref_method': 'GetReferenceCount',
-        },
     '::ns3::AttributeChecker': {
         'automatic_type_narrowing': 'true',
         'allow_subclassing': 'false',
@@ -161,6 +139,13 @@ def pre_scan_hook(dummy_module_parser,
             and pygccxml_definition.name == 'Run':
         global_annotations['ignore'] = True
 
+    ## http://www.gccxml.org/Bug/view.php?id=9915
+    if isinstance(pygccxml_definition, calldef_t):
+        for arg in pygccxml_definition.arguments:
+            if arg.default_value is None:
+                continue
+            if "ns3::MilliSeconds( )" == arg.default_value:
+                arg.default_value = "ns3::MilliSeconds(0)"
 
     ## classes
     if isinstance(pygccxml_definition, class_t):
@@ -168,6 +153,13 @@ def pre_scan_hook(dummy_module_parser,
         if pygccxml_definition.name.endswith('Helper'):
             global_annotations['allow_subclassing'] = 'false'
 
+        if pygccxml_definition.decl_string.startswith('::ns3::SimpleRefCount<'):
+            global_annotations['incref_method'] = 'Ref'
+            global_annotations['decref_method'] = 'Unref'
+            global_annotations['peekref_method'] = 'GetReferenceCount'
+            global_annotations['automatic_type_narrowing'] = 'true'
+            return
+
         if pygccxml_definition.decl_string.startswith('::ns3::Callback<'):
             # manually handled in ns3modulegen_core_customizations.py
             global_annotations['ignore'] = None
@@ -231,8 +223,9 @@ def scan_callback_classes(module_parser, callback_classes_file):
 
 
 class MyPygenClassifier(PygenClassifier):
-    def __init__(self, headers_map):
+    def __init__(self, headers_map, section_precendences):
         self.headers_map = headers_map
+        self.section_precendences = section_precendences
 
     def classify(self, pygccxml_definition):
         name = os.path.basename(pygccxml_definition.location.file_name)
@@ -241,6 +234,11 @@ class MyPygenClassifier(PygenClassifier):
         except KeyError:
             return '__main__'
 
+    def get_section_precedence(self, section_name):
+        if section_name == '__main__':
+            return -1
+        return self.section_precendences[section_name]
+
 
 def ns3_module_scan(top_builddir, pygen_file_name, everything_h, cflags):
 
@@ -249,7 +247,11 @@ def ns3_module_scan(top_builddir, pygen_file_name, everything_h, cflags):
     ## do a topological sort on the modules graph
     from topsort import topsort
     graph = []
-    for ns3_module_name, (ns3_module_deps, dummy) in ns3_modules.iteritems():
+    module_names = ns3_modules.keys()
+    module_names.sort()
+    for ns3_module_name in module_names:
+        ns3_module_deps = list(ns3_modules[ns3_module_name][0])
+        ns3_module_deps.sort()
         for dep in ns3_module_deps:
             graph.append((dep, ns3_module_name))
     sorted_ns3_modules = topsort(graph)
@@ -257,13 +259,15 @@ def ns3_module_scan(top_builddir, pygen_file_name, everything_h, cflags):
 
     sections = [PygenSection('__main__', FileCodeSink(open(pygen_file_name, "wt")))]
     headers_map = {} # header_name -> section_name
-    for ns3_module in sorted_ns3_modules:
+    section_precendences = {} # section_name -> precedence
+    for prec, ns3_module in enumerate(sorted_ns3_modules):
         section_name = "ns3_module_%s" % ns3_module.replace('-', '_')
         file_name = os.path.join(os.path.dirname(pygen_file_name), "%s.py" % section_name)
         sections.append(PygenSection(section_name, FileCodeSink(open(file_name, "wt")),
                                      section_name + "__local"))
         for header in ns3_modules[ns3_module][1]:
             headers_map[header] = section_name
+        section_precendences[section_name] = prec
 
     module_parser = ModuleParser('ns3', 'ns3')
 
@@ -283,7 +287,7 @@ def ns3_module_scan(top_builddir, pygen_file_name, everything_h, cflags):
                              None, whitelist_paths=[top_builddir, os.path.dirname(everything_h)],
                              #includes=['"ns3/everything.h"'],
                              pygen_sink=sections,
-                             pygen_classifier=MyPygenClassifier(headers_map),
+                             pygen_classifier=MyPygenClassifier(headers_map, section_precendences),
                              gccxml_options=gccxml_options)
     module_parser.scan_types()
 

bindings/python/wscript

@@ -15,7 +15,7 @@ import Build
 import Utils
 
 ## https://launchpad.net/pybindgen/
-REQUIRED_PYBINDGEN_VERSION = (0, 12, 0, 700)
+REQUIRED_PYBINDGEN_VERSION = (0, 12, 0, 710)
 REQUIRED_PYGCCXML_VERSION = (0, 9, 5)
 
 
@@ -119,10 +119,55 @@ def configure(conf):
                                          "PyBindGen version not correct and newer version could not be retrieved")
             return
 
+
+    def test(t1, t2):
+        test_program = '''
+#include <stdint.h>
+#include <vector>
+
+int main ()
+{
+   std::vector< %(type1)s > t = std::vector< %(type2)s > ();
+   return 0;
+}
+''' % dict(type1=t1, type2=t2)
+
+        try:
+            ret = conf.run_c_code(code=test_program,
+                                  env=conf.env.copy(), compile_filename='test.cc',
+                                  compile_mode='cxx',type='cprogram', execute=False)
+        except Configure.ConfigurationError:
+            ret = 1
+        conf.check_message_custom('types %s and %s' % (t1, t2), 'equivalency', (ret and 'no' or 'yes'))
+        return not ret
+
+    uint64_is_long = test("uint64_t", "unsigned long")
+    uint64_is_long_long = test("uint64_t", "unsigned long long")
+
+    if uint64_is_long:
+        conf.env['PYTHON_BINDINGS_APIDEFS'] = 'gcc-LP64'
+    elif uint64_is_long_long:
+        conf.env['PYTHON_BINDINGS_APIDEFS'] = 'gcc-ILP32'
+    else:
+        conf.env['PYTHON_BINDINGS_APIDEFS'] = None
+    if conf.env['PYTHON_BINDINGS_APIDEFS'] is None:
+        msg = 'none available'
+    else:
+        msg = conf.env['PYTHON_BINDINGS_APIDEFS']
+
+    conf.check_message_custom('the apidefs that can be used for Python bindings', '', msg)
+
+    if conf.env['PYTHON_BINDINGS_APIDEFS'] is None:
+        conf.report_optional_feature("python", "Python Bindings", False,
+                                     "No apidefs are available that can be used in this system")
+        return
+
     ## If all has gone well, we finally enable the Python bindings
     conf.env['ENABLE_PYTHON_BINDINGS'] = True
     conf.report_optional_feature("python", "Python Bindings", True, None)
 
+    
+
     ## Check for pygccxml
     try:
         conf.check_python_module('pygccxml')
@@ -427,18 +472,7 @@ def build(bld):
         return
 
     if env['ENABLE_PYTHON_BINDINGS']:
-        if sys.platform == 'cygwin':
-            apidefs = 'gcc-cygwin'
-        else:
-            import struct
-            if struct.calcsize('I') == 4 and struct.calcsize('L') == 8 and struct.calcsize('P') == 8:
-                apidefs = 'gcc-LP64'
-            elif struct.calcsize('I') == 4 and struct.calcsize('L') == 4 and struct.calcsize('P') == 4:
-                apidefs = 'gcc-ILP32'
-            else:
-                print "Cannot build python bindings for unsupported data model"
-                return
-        #print "Will build python bindings for target:", apidefs
+        apidefs = env['PYTHON_BINDINGS_APIDEFS']
 
         ## Get a list of scanned modules; the set of scanned modules
         ## may be smaller than the set of all modules, in case a new

doc/build.txt

@@ -7,10 +7,10 @@ http://www.nsnam.org/wiki/index.php/Installation
 
 === Installing Waf ===
 
-The top-level ns-3 directory should contain a current waf script.
-
-Note: we're using a WAF version based on WAF 1.5.x.  The source code
-can be retrieved from the followin URL:
+The top-level ns-3 directory should contain a current waf script, so
+there is no need to have WAF installed in the system.  We are using
+some extensions to WAF, which can be found in the 'waf-tools'
+directory. The upstream location for these WAF extensions is:
 
     https://code.launchpad.net/~gjc/waf/cmd
 

doc/doxygen.conf

@@ -260,7 +260,7 @@ EXTRACT_ALL            = NO
 # If the EXTRACT_PRIVATE tag is set to YES all private members of a class 
 # will be included in the documentation.
 
-EXTRACT_PRIVATE        = YES
+EXTRACT_PRIVATE        = NO
 
 # If the EXTRACT_STATIC tag is set to YES all static members of a file 
 # will be included in the documentation.
@@ -293,14 +293,14 @@ EXTRACT_ANON_NSPACES   = NO
 # various overviews, but no documentation section is generated. 
 # This option has no effect if EXTRACT_ALL is enabled.
 
-HIDE_UNDOC_MEMBERS     = YES
+HIDE_UNDOC_MEMBERS     = NO 
 
 # If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all 
 # undocumented classes that are normally visible in the class hierarchy. 
 # If set to NO (the default) these classes will be included in the various 
 # overviews. This option has no effect if EXTRACT_ALL is enabled.
 
-HIDE_UNDOC_CLASSES     = YES
+HIDE_UNDOC_CLASSES     = NO 
 
 # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all 
 # friend (class|struct|union) declarations. 
@@ -467,7 +467,7 @@ WARN_IF_DOC_ERROR      = YES
 # wrong or incomplete parameter documentation, but not about the absence of 
 # documentation.
 
-WARN_NO_PARAMDOC       = NO
+WARN_NO_PARAMDOC       = YES 
 
 # The WARN_FORMAT tag determines the format of the warning messages that 
 # doxygen can produce. The string should contain the $file, $line, and $text 
@@ -496,7 +496,6 @@ WARN_LOGFILE           =
 INPUT                  = doc/modules \
                          doc/main.h \
                          doc/introspected-doxygen.h \
-                         doc/howtos/ \ 
                          src
 
 # This tag can be used to specify the character encoding of the source files that 
@@ -528,8 +527,7 @@ RECURSIVE              = YES
 # subdirectory from a directory tree whose root is specified with the INPUT tag.
 
 EXCLUDE                = src/routing/olsr/olsr-state.h \
-                         src/routing/olsr/repositories.h \
-                         src/routing/olsr/routing-table.h \
+                         src/routing/olsr/olsr-repositories.h \
                          src/simulator/high-precision.h \
                          src/simulator/high-precision-128.h \
                          src/simulator/high-precision-double.h
@@ -546,7 +544,7 @@ EXCLUDE_SYMLINKS       = NO
 # against the file with absolute path, so to exclude all test directories 
 # for example use the pattern */test/*
 
-EXCLUDE_PATTERNS       = 
+EXCLUDE_PATTERNS       = */test/*
 
 # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names 
 # (namespaces, classes, functions, etc.) that should be excluded from the output. 

doc/howtos/howtos-application.h

@@ -1,203 +0,0 @@
-/*!
-  \page application How to create a traffic generator ?
-  \anchor howtos-application
-
-  <b>Question:</b> How do I create a new traffic generator ?
-
-  <b>Answer:</b> It is possible to instanciate \ref ns3::Packet "Packet"
-  objects, schedule events, and call functions from any piece of code
-  in ns-3 so, technically, there is no single answer to the question of
-  how we can write a new traffic generator. However, the 
-  \ref ns3::Socket "Socket" API was really designed to be the single 
-  point of entry for traffic generators or traffic analysers and the
-  \ref ns3::Application "Application" class was designed to hold
-  together any number of sockets.
-
-  Implementing a new traffic generator thus boils down to:
-- implementing a new subclass of the \ref ns3::Application "Application"
-  base class
-- instanciate one or many sockets within that application
-- start scheduling events when \ref ns3::Application::StartApplication "StartApplication"
-  is called
-- stop scheduling events when \ref ns3::Application::StopApplication "StopApplication" 
-  is called
-- create packets and send them over one or many sockets in each event
-
-The following "random" generator generates packets separated by a random
-delay and with a random size.
-
-\code
-class RandomGenerator : public Application
-{
-public:
-  RandomGenerator ();
-  void SetDelay (RandomVariable delay);
-  void SetSize (RandomVariable size);
-  void SetRemote (std::string socketType, 
-                  Address remote);
-private:
-  virtual void StartApplication (void);
-  virtual void StopApplication (void);
-  void DoGenerate (void);
-
-  RandomVariable m_delay;
-  RandomVariable m_size;
-  Ptr<Socket> m_socket;
-};
-\endcode
-
-The socket is created in the SetRemote method:
-\code
-void 
-RandomGenerator::SetRemote (std::string socketType, 
-                            Address remote)
-{
-  TypeId tid = TypeId::LookupByName (socketType);
-  m_socket = Socket::CreateSocket (GetNode (), tid);
-  m_socket->Bind ();
-  m_socket->ShutdownRecv ();
-  m_socket->Connect (remote);
-}
-\endcode
-While the the crux of the logic is located in the DoGenerate method
-which is called from within StartApplication:
-\code
-void
-RandomGenerator::DoGenerate (void)
-{
-  m_next = Simulator::Schedule (Seconds (m_delay.GetValue ()), 
-				&RandomGenerator::DoGenerate, this);
-  Ptr<Packet> p = Create<Packet> (m_size.GetIntValue ());
-  m_socket->Send (p);
-}
-\endcode
-
-To make that application more integrated in ns-3, it needs an associated 
-helper class:
-\code
-class RandomAppHelper
-{
-public:
-  RandomAppHelper (std::string protocol, Address remote);
-  void SetPacketSize (RandomVariable packetSize);
-  void SetDelay (RandomVariable delay);
-  ApplicationContainer Install (NodeContainer nodes);
-private:
-  std::string m_protocol;
-  Address m_remote;
-  RandomVariable m_packetSize;
-  RandomVariable m_delay;
-};
-\endcode
-
-which could be trivially implemented as:
-\code
-ApplicationContainer 
-RandomAppHelper::Install (NodeContainer nodes)
-{
-  ApplicationContainer applications;
-  for (NodeContainer::Iterator i = nodes.Begin (); i != nodes.End (); ++i)
-    {
-      Ptr<RandomAppHelper> app = CreateObject<RandomAppHelper> ();
-      app->SetSize (m_packetSize);
-      app->SetDelay (m_delay);
-      app->SetRemote (m_protocol, m_remote);
-      (*i)->AddApplication (app);
-      applications.Add (app);
-    }
-  return applications;
-}
-\endcode
-
-Despite being functional, this API is not very consistant with the style of 
-the other helper classes, all of which allow you to control the parameters
-of the underlying class through attributes and not explicit setters. The
-following API thus replaces the pair SetPacketSize/SetDelay with a single
-method SetAttribute:
-\code
-class RandomAppHelper
-{
-public:
-  RandomAppHelper (std::string protocol, Address remote);
-  void SetAttribute (std::string name, const AttributeValue &value);
-  ApplicationContainer Install (NodeContainer c);
-private:
-  std::string m_protocol;
-  Address m_remote;
-  ObjectFactory m_factory;
-};
-\endcode
-
-And which can be used as follows:
-\code
-RandomAppHelper app = RandomAppHelper ("ns3::TcpSocketFactory", 
-				       InetSocketAddress (Ipv4Address ("192.168.1.10"), 10));
-app.SetAttribute ("Delay", StringValue ("Constant:2.5"));
-app.SetAttribute ("Size", StringValue ("Constant:2100"));
-app.Install (nodes);
-\endcode
-
-The implementation, in this case, is not necessarily longer but its 
-simplicity hides a lot of behind-the-scenes complexity:
-
-\code
-void 
-RandomAppHelper::SetAttribute (std::string name, const AttributeValue &value)
-{
-  m_factory.Set (name, value);
-}
-ApplicationContainer 
-RandomAppHelper::Install (NodeContainer nodes)
-{
-  ApplicationContainer applications;
-  for (NodeContainer::Iterator i = nodes.Begin (); i != nodes.End (); ++i)
-    {
-      Ptr<RandomAppHelper> app = m_factory.Create<RandomAppHelper> ();
-      app->SetRemote (m_socketType, m_remote);
-      (*i)->AddApplication (app);
-      applications.Add (app);
-    }
-  return applications;
-}
-\endcode
-
-The key difference between this implementation and the previous one
-is that this helper does not handle explicitely the attributes
-delay and packet size. Instead, it stores them in an 
-\ref ns3::ObjectFactory "ObjectFactory" object. This, of course,
-does not work magically, and requires extra support from the
-underlying RandomGenerator class. Specifically, it requires
-that the underlying RandomGenerator defines its attributes
-in its \ref ns3::TypeId "TypeId" in a new public static method:
-
-\code
-class RandomGenerator
-{
-public:
-  static TypeId GetTypeId (void);
-};
-\endcode
-
-The corresponding implementation is shown below:
-
-\code
-TypeId
-RandomGenerator::GetTypeId (void)
-{
-  static TypeId tid = TypeId ("RandomGenerator")
-    .SetParent<Application> ()
-    .AddConstructor<RandomGenerator> ()
-    .AddAttribute ("Delay", "The delay between two packets (s)",
-		   RandomVariableValue (ConstantVariable (1.0)),
-		   MakeRandomVariableAccessor (&RandomGenerator::m_delay),
-		   MakeRandomVariableChecker ())
-    .AddAttribute ("PacketSize", "The size of each packet (bytes)",
-		   RandomVariableValue (ConstantVariable (2000)),
-		   MakeRandomVariableAccessor (&RandomGenerator::m_size),
-		   MakeRandomVariableChecker ())
-    ;
-  return tid;
-}   
-\endcode
-
-*/

doc/howtos/howtos-callbacks.h

@@ -1,38 +0,0 @@
-/*!
-\page callbacks Using ns-3 callbacks
-\anchor howtos-callbacks
-
-\section null_callbacks Null Callbacks
-
-<b>Question:</b> The API I am using calls for using a callback (in the 
-function signature), but I do not
-want to provide one.  Is there a way to provide a null callback?
-
-<b>Answer:</b> Use the ns3::MakeNullCallback construct:
-\code
-template<typename R>
-Callback< R, T1, T2, T3, T4, T5, T6 > ns3::MakeNullCallback (void)
-\endcode
-
-Example usage:  The ns3::Socket class uses callbacks to indicate completion
-of events such as a successful TCP connect().  These callbacks are set
-in the following function:
-\code
-  void Socket::SetConnectCallback (Callback<void, Ptr<Socket> > connectionSucceeded,
-                        Callback<void, Ptr<Socket> > connectionFailed,
-                        Callback<void, Ptr<Socket> > halfClose);
-
-\endcode
-But suppose you do not care about registering a callback for the 
-halfClose event (but you want to register one for the 
-connectionSucceeded and connectionFailed cases).  In that case, you
-can pass a null callback as the third argument.  You just need to
-pass a callback with the matching signature, as follows:
-\code
-  localSocket->SetConnectCallback (
-  MakeCallback (&ConnectionSucceededCallback),
-  MakeCallback (&ConnectionFailedCallback),
-  MakeNullCallback<void, Ptr<Socket> > () );
-\endcode
-
-*/

doc/howtos/howtos-net-device.h

@@ -1,162 +0,0 @@
-/*!
-  \page net-device How to create a new OSI layer 1 + 2 implementation ?
-  \anchor howtos-net-device
-
-  <b>Question:</b> How do I integrate a new OSI layer 1 + 2 implementation ?
-
-  <b>Answer:</b> The OSI layers 1 and 2 are represented by the ns3::NetDevice
-  and ns3::Channel classes. To plug transparently in ns-3, a new layer 1+2 model
-  thus simply needs to provide two new subclasses of these two base classes.
-
-  To make that subclassing process easy, two skeleton classes are provided in
-  the src/node directory: simple-net-device.h (ns3::SimpleNetDevice) and 
-  simple-channel.h (ns3::SimpleChannel) implement a broadcast passthru medium 
-  using 48bit MAC addresses without any kind of MAC access algorithm or PHY 
-  layer modeling.
-
-  The ns3::SimpleChannel class is really very simple: it provides
-  an implementation for the ns3::Channel::GetNDevices and ns3::Channel::GetDevice
-  methods defined in the Channel base class and, then defines the channel-specific
-  send and add methods:
-- The Add method is used by SimpleNetDevice::SetChannel to register a new 
-  SimpleNetDevice with its associated channel.
-- The Send method is used by SimpleNetDevice::Send to send a packet over the
-  broadcast medium and ensure that it gets delivered to all associated devices
-  (except the sender).
-
-\code
-class SimpleChannel : public Channel
-{
-public:
-  static TypeId GetTypeId (void);
-  SimpleChannel ();
-
-  void Send (Ptr<Packet> p, uint16_t protocol, Mac48Address to, Mac48Address from,
-	     Ptr<SimpleNetDevice> sender);
-
-  void Add (Ptr<SimpleNetDevice> device);
-
-  // inherited from ns3::Channel
-  virtual uint32_t GetNDevices (void) const;
-  virtual Ptr<NetDevice> GetDevice (uint32_t i) const;
-
-private:
-  std::vector<Ptr<SimpleNetDevice> > m_devices;
-};
-\endcode
-
-The SimpleNetDevice class is also trivial since it implements no special
-MAC-layer processing:
-\code
-class SimpleNetDevice : public NetDevice
-{
-public:
-  static TypeId GetTypeId (void);
-  SimpleNetDevice ();
-
-  void Receive (Ptr<Packet> packet, uint16_t protocol, Mac48Address to, Mac48Address from);
-  void SetChannel (Ptr<SimpleChannel> channel);
-  void SetAddress (Mac48Address address);
-
-  // inherited from NetDevice base class.
-  virtual void SetName(const std::string name);
-  ...
-};
-\endcode
-
-The code below illustrates how the three model-specific methods defined above are
-implemented:
-
-\code
-void 
-SimpleNetDevice::Receive (Ptr<Packet> packet, uint16_t protocol, 
-			  Mac48Address to, Mac48Address from)
-{
-  if (to == m_address || to == Mac48Address::GetBroadcast ())
-    {
-      m_rxCallback (this, packet, protocol, from);
-    }
-}
-void 
-SimpleNetDevice::SetChannel (Ptr<SimpleChannel> channel)
-{
-  m_channel = channel;
-  m_channel->Add (this);
-}
-void 
-SimpleNetDevice::SetAddress (Mac48Address address)
-{
-  m_address = address;
-}
-\endcode
-
-Building a topology with such a device is then a matter of
-instanciating a set of SimpleNetDevice objects connected on a shared
-SimpleChannel:
-\code
-NodeContainer nodes;
-nodes.Create (10);
-Ptr<SimpleChannel> channel = CreateObject<SimpleChannel> ();
-for (uint32_t i = 0; i < nodes.GetN (); ++i)
-  {
-    CreateSimpleDevice (nodes.Get (i), channel);
-  }
-\endcode
-
-With the following CreateSimpleDevice function:
-\code
-static Ptr<SimpleNetDevice>
-CreateSimpleDevice (Ptr<Node> node, Ptr<SimpleChannel> channel)
-{
-  Ptr<SimpleNetDevice> device = CreateObject<SimpleNetDevice> ();
-  device->SetAddress (Mac48Address:Allocate ());
-  device->SetChannel (channel);
-  node->AddDevice (device);
-  return device;
-}
-\endcode
-
-Of course, ultimately, you need to provide a helper class for this new device and channel
-to save each user from having to re-implement their own CreateSimpleDevice helper 
-function:
-
-\code
-class SimpleHelper
-{
-public:
-  NetDeviceContainer Install (NodeContainer nodes, Ptr<SimpleChannel> channel);
-  NetDeviceContainer Install (NodeContainer nodes);
-};
-\endcode
-
-with the following straightforward implementation, inspired by the CreateSimpleDevice 
-function defined above:
-
-\code
-NetDeviceContainer
-SimpleHelper::Install (NodeContainer nodes, Ptr<SimpleChannel> channel)
-{
-  NetDeviceContainer devices;
-  for (NodeContainer::Iterator i = nodes.Begin (); i != nodes.End (); ++i)
-    {
-      Ptr<SimpleNetDevice> dev = CreateObject<SimpleNetDevice> ();
-      dev->SetAddress (Mac48Address::Allocate ());
-      dev->SetChannel (channel);
-      (*i)->AddDevice (dev);
-      devices.Add (dev);
-    }
-  return devices;
-}
-NetDeviceContainer
-SimpleHelper::Install (NodeContainer nodes)
-{
-  return Install (nodes, CreateObject<SimpleChannel> ());
-}
-\endcode
-
-Of course, at some point, this device helper class should also contain a couple of 
-ascii and pcap tracing helper functions but, since the default SimpleNetDevice
-class we used as an example here does not report any trace event, it would
-be of little use.
-
-*/

doc/howtos/howtos-packet-header.h

@@ -1,119 +0,0 @@
-/*!
-\page packet-header-trailer How to create a new type of protocol header or trailer
-\anchor howtos-packet-header-trailer
-
-<b>Question:</b> I want to implement a new protocol X which uses a new
-type of header Y. How do I implement and use this new header Y in ns-3 ?
-
-<b>Answer:</b> The key is to implement a new subclass of the ns3::Header
-base class to represent your protocol header:
-\code
-class YHeader : public Header
-{
-public:
-  // must be implemented to become a valid new header.
-  static TypeId GetTypeId (void);
-  virtual TypeId GetInstanceTypeId (void) const;
-  virtual uint32_t GetSerializedSize (void) const;
-  virtual void Serialize (Buffer::Iterator start) const;
-  virtual uint32_t Deserialize (Buffer::Iterator start);
-  virtual void Print (std::ostream &os) const;
-
-  // allow protocol-specific access to the header data.
-  void SetData (uint32_t data);
-  uint32_t GetData (void) const;
-private:
-  uint32_t m_data;
-};
-\endcode
-
-Once this class is implemented, you can easily store your protocol
-header into a packet:
-\code
-Ptr<Packet> p = ...;
-YHeader yHeader;
-yHeader.SetData (0xdeadbeaf);
-// copy the header into the packet
-p->AddHeader (yHeader);
-\endcode
-and get it out of a packet:
-\code
-Ptr<Packet> p = ...;
-YHeader yHeader;
-// copy the header from the packet
-p->RemoveHeader (yHeader);
-uint32_t data = yHeader.GetData ();
-\endcode
-
-The implementation of the new header is very simple. First, you need
-to give a TypeId to your YHeader class:
-\code
-TypeId
-YHeader::GetTypeId (void)
-{
-  static TypeId tid = TypeId ("YHeader")
-    .SetParent<Header> ()
-    .AddConstructor<YHeader> ()
-  ;
-  return tid;
-}
-TypeId
-YHeader::GetInstanceTypeId (void)
-{
-  return GetTypeId ();
-}
-\endcode
-
-Then, you need to allow your header to serialize and deserialize itself
-to a byte buffer in its network representation. Here, our new protocol
-header contains first a 2-byte constant, and, then, the data field so,
-the total size of the header is 2+4=6 bytes.
-\code
-uint32_t 
-YHeader::GetSerializedSize (void) const
-{
-  return 6;
-}
-void 
-YHeader::Serialize (Buffer::Iterator start) const
-{
-  // The 2 byte-constant
-  start.WriteU8 (0xfe);
-  start.WriteU8 (0xef);
-  // The data.
-  start.WriteHtonU32 (m_data);
-}
-uint32_t 
-YHeader::Deserialize (Buffer::Iterator start)
-{
-  uint8_t tmp;
-  tmp = start.ReadU8 ();
-  NS_ASSERT (tmp == 0xfe);
-  tmp = start.ReadU8 ();
-  NS_ASSERT (tmp == 0xef);
-  m_data = start.ReadNtohU32 ();
-  return 6; // the number of bytes consumed.
-}
-\endcode
-
-Finally, to make sure that Packet::Print also prints the content
-of your header, just as it prints the content of the other
-headers of the system, you need to provide a Print method:
-\code
-void 
-YHeader::Print (std::ostream &os) const
-{
-  os << "data=" << m_data;
-}
-\endcode
-
-The code will look the same if you want to implement a trailer,
-that is, a protocol data structure which will be appended to the
-end of the packet, not its start: you need to make sure that
-you derive from the ns3::Trailer base class and that you call
-Packet::AddTrailer and Packet::RemoveTrailer. Another important
-detail is that you must make sure to rewind the iterator in your
-Serialize and Deserialize methods writing to or reading from 
-the underlying buffer.
-
-*/

doc/howtos/howtos.h

@@ -1,20 +0,0 @@
-/*!
-\page howtos ns-3 HOWTOs
-\anchor howtos-anchor
-
-This is an organized set of frequently asked questions (FAQ) and HOWTOs
-for ns-3.  This complements the following wiki pages:
-
-- <a href="http://www.nsnam.org/wiki/index.php/User_FAQ">User FAQ</a>
-- <a href="http://www.nsnam.org/wiki/index.php/Developer_FAQ">Developer FAQ</a>
-
-Please consider contributing tips to either the wiki (yourself) or
-by submitting a patch to this maintained documentation.
-
-- \subpage callbacks
-- \subpage packet-header-trailer
-- \subpage net-device
-- \subpage application
-
-*/
-

doc/main.h

@@ -6,29 +6,29 @@
  * <a href="http://www.doxygen.org">Doxygen</a>.
  * Doxygen is typically used for 
  * API documentation, and organizes such documentation across different
- * modules.   This project uses Doxygen both for building the manual around 
- * the API documentation,  and a separate GNU texinfo document is used for 
- * the manual.
+ * modules.   This project uses Doxygen for building the definitive
+ * maintained API documentation,  Separate GNU texinfo documents are used for 
+ * a tutorial, reference manual, and testing and validation manual.
  *
  * The ns-3 project documentation is organized as follows:
  *     - <b><a href="modules.html">modules</a></b>:  The "Modules" tab (above) 
  *       organizes  all of the public API and supporting manual text 
- *       along the  source code directory structure.   This forms the 
- *       "ns-3 manual", and it is available in HTML and PDF forms.
- *     - \ref howtos-anchor "HOWTOs": A set of HOWTOs and FAQs is
- *       maintained on another Doxygen "Related Page" 
- *     - <a href="http://www.nsnam.org/docs/tutorial/tutorial.html">tutorial</a>:  The ns-3 tutorial is a separate document maintained in <a href="http://www.gnu.org/software/texinfo/"> GNU Texinfo</a>. 
+ *       along the  source code directory structure.   
+ *     - <a href="http://www.nsnam.org/tutorials.html">tutorial</a>:  The ns-3 tutorial is a separate document maintained in <a href="http://www.gnu.org/software/texinfo/"> GNU Texinfo</a>. 
+ *     - <a href="http://www.nsnam.org/tutorials.html">Reference manual</a>:  The ns-3 reference manual is a separate document maintained in <a href="http://www.gnu.org/software/texinfo/"> GNU Texinfo</a>. 
+ *     - <a href="http://www.nsnam.org/tutorials.html">Testing and validation manual</a>:  The ns-3 testing and validation manual is a separate document maintained in <a href="http://www.gnu.org/software/texinfo/"> GNU Texinfo</a>. 
  *     - The <b><a href="http://www.nsnam.org/wiki/index.php/Main_Page">ns-3 wiki</a></b> 
  *       contains additional user-contributed material.  Some wiki-contributed
- *       material may migrate to and overlap with the Doxygen information.
+ *       material may migrate to and overlap with the Doxygen and manual information.
  *
  * \section install-sec Building the Documentation
  * 
  * ns-3 requires Doxygen version 1.5.4 or greater to fully build all items,
  * although earlier versions of Doxygen will mostly work.
  * 
- * Type "./waf doxygen" to build the documentation.  The doc/ directory contains
- * configuration for Doxygen (doxygen.conf and main.txt).  The Doxygen 
+ * Type "./waf --doxygen" or "./waf --doxygen-no-build" to build the 
+ *  documentation.  The doc/ directory contains
+ * configuration for Doxygen (doxygen.conf) and main.h.  The Doxygen 
  * build process puts html files into the doc/html/ directory, and latex 
  * filex into the doc/latex/ directory.
  * 
@@ -44,8 +44,14 @@
  *       to network simulations but shared by pretty much every model
  *       of a network component.
  *     - node: located in src/node. Defines the abstract interfaces which 
- *       must be implemented by every node and more specifically, by ipv4 nodes.       
+ *       must be implemented by every node and more specifically, by 
+ *       IPv4 and IPv6 nodes.       
  *     - devices: located in src/devices. Contains a set of MAC-level models
+ *     - InternetStack: located in src/internet-stack. Contains TCP/IP models.
+ *     - Applications: located in src/applications
+ *     - Routing:  located in src/routing; routing protocols.
+ *     - Mobility:  located in src/mobility; Mobility models for nodes
+ *     - Helper:  located in src/helper; Helper API for the simulator
  *
  * More detail can be found in the <b><a href="modules.html">Modules</a></b>
  * tab.

doc/manual/Makefile

@@ -17,6 +17,7 @@ IMAGES_EPS = \
 	$(FIGURES)/node.eps \
 	$(FIGURES)/buffer.eps \
 	$(FIGURES)/sockets-overview.eps \
+	$(FIGURES)/software-organization.eps \
 	$(FIGURES)/routing.eps \
 	$(FIGURES)/routing-specialization.eps \
 	$(FIGURES)/testbed.eps \
@@ -31,10 +32,22 @@ IMAGES = $(IMAGES_EPS) $(IMAGES_PNG) $(IMAGES_PDF)
 
 CHAPTERS = \
 	manual.texi \
+	animation.texi \
 	attributes.texi \
+	bridge.texi \
 	callbacks.texi \
 	csma.texi \
 	emulation.texi \
+	emu.texi \
+	flow-monitor.texi \
+	helpers.texi \
+	internet.texi \
+	ipv4.texi \
+	ipv6.texi \
+	log.texi \
+	manual.texi \
+	mesh.texi \
+	names.texi \
 	new-models.texi \
 	node.texi \
 	objects.texi \
@@ -42,11 +55,16 @@ CHAPTERS = \
 	output.texi \
 	packets.texi \
 	point-to-point.texi \
+	python.texi \
 	random.texi \
 	realtime.texi \
 	routing.texi \
+	simple.texi \
 	sockets.texi \
 	statistics.texi \
+	tap.texi \
+	tcp.texi \
+	tracing.texi \
 	troubleshoot.texi \
 	wifi.texi
 
@@ -63,7 +81,7 @@ manual.html: version $(IMAGES) $(CHAPTERS)
 	$(TEXI2HTML) ${CSS} manual.texi
 
 manual/manual.html: version $(IMAGES) $(CHAPTERS)
-	$(TEXI2HTML) ${CSS} ${SPLIT} manual.texi
+	$(TEXI2HTML) ${CSS} ${SPLIT} --output manual manual.texi
 
 figures-clean:
 	rm -rf $(IMAGES)
@@ -71,6 +89,8 @@ figures-clean:
 version:
 	echo -n "ns-" > VERSION-PREFIX; cat VERSION-PREFIX ../../VERSION > VERSION; rm -rf VERSION-PREFIX
 
-clean: 	figures-clean
+texi-clean: 	
 	rm -rf manual.aux manual.cp manual.cps manual.fn manual.ky manual.pg manual.tp
 	rm -rf manual.vr manual.toc manual.log manual.pdf manual.html manual/ VERSION 
+
+clean:	figures-clean texi-clean

doc/manual/animation.texi

@@ -0,0 +1,210 @@
+@node Animation
+@chapter Animation
+@anchor{chap:Animation}
+
+@menu
+* Animation interface::
+* NetAnim::
+@end menu
+
+Animation is an important tool for network simulation. While ns-3 does 
+not contain a graphical animation tool, it does provide an animation interface 
+for use with stand-alone animators. Currently, the animation 
+interface only supports point-to-point links; however, we hope
+to support other link types such as CSMA and wireless in the near future.
+The animation interface in ns-3 allows the generation of a custom trace 
+file to be used by an animation program.
+
+An existing stand-alone program, NetAnim, uses these custom traces to 
+graphically display the simulation. NetAnim depicts packets traveling 
+on point-to-point links as they travel from node to node.
+
+@node Animation interface
+@section Animation interface
+
+The animation interface in ns-3 currently only supports point-to-point 
+links and can generate a custom trace file for use by an animation 
+program.  A snippet from a sample trace file is shown below.
+
+@verbatim
+0.0 N 0 4 5.5
+0.0 N 1 7 5.5
+0.0 N 2 2.5 2.90192
+
+...
+
+0.0 L 0 1
+0.0 L 0 2
+0.0 L 0 3
+
+...
+
+Running the simulation
+0.668926 P 11 1 0.66936 0.669926 0.67036
+0.67036 P 1 0 0.670794 0.67136 0.671794
+0.671794 P 0 6 0.672227 0.672794 0.673227
+
+...
+@end verbatim
+
+The tracefile describes where nodes and links should be placed at 
+the top of the file. Following this placement, the packet events 
+are shown. The format for node placement, link placement and 
+packet events is shown below.
+
+@itemize @bullet
+@item Node placement: <time of placement> <N for node> <node id> 
+                      <x position> <y position>
+@item Link placement: <time of placement> <L for link> <node1 id> 
+                      <node2 id>
+@item Packet events:  <time of first bit tx> <P for packet> 
+                      <source node> <destination node> 
+                      <time of last bit tx> 
+                      <time of first bit rx> 
+                      <time of last bit rx>
+@end itemize
+
+To get started using the animation interface, several example scripts 
+have been provided to show proper use.  These examples can be found 
+in examples/animation. The example scripts use the animation interface 
+as well as topology helpers in order to automatically place the nodes 
+and generate the custom trace. It is important to note that if a 
+topology helper is not used with its provided BoundingBox method, 
+which automatically calculates the nodes' canvas positions, the nodes 
+must be placed manually by aggregating a CanvasLocation to the node. 
+An example use of CanvasLocation can be found in any of the topology 
+helpers. Additionally, a simple example of placing a node is shown below:
+
+@verbatim
+  // assuming a node container m_hub exists and 
+  // contains at least one node.
+  // we grab this node and associate a 
+  // CanvasLocation to it, in order for the 
+  // animation interface to place the node
+  Ptr<Node> hub = m_hub.Get (0);
+  Ptr<CanvasLocation> hubLoc =  hub->GetObject<CanvasLocation> ();
+    if (hubLoc == 0)
+      {
+        hubLoc = CreateObject<CanvasLocation> ();
+        hub->AggregateObject (hubLoc);
+      }
+  Vector hubVec (5, 7);
+  hubLoc->SetLocation (hubVec);
+@end verbatim
+
+Finally, after the simulation has been set up and the nodes have been 
+placed, the animation interface is used to start the animation, which 
+writes the custom trace file.  Below is an example of how to set 
+up and start the animation interface.
+
+@verbatim
+  AnimationInterface anim;
+  // the animation interface can be set up to write 
+  // to a socket, if a port > 0 is specified
+  // see doxygen for more information
+  if (port > 0)
+    {
+      anim.SetServerPort (port);
+    }
+  else if (!animFile.empty ())
+    {
+      // if a file name is specified, 
+      // the trace is written to the file.
+      // otherwise, it is directed to stdout
+      anim.SetOutputFile (animFile);
+    }
+  anim.StartAnimation ();
+@end verbatim
+
+@node NetAnim
+@section NetAnim
+
+NetAnim is a stand-alone program which uses the custom trace files 
+generated by the animation interface to graphically display the 
+simulation.  NetAnim is based on the multi-platform 
+@uref{http://www.qtsoftware.com/products/,,Qt4 GUI toolkit}. A 
+screenshot of the NetAnim GUI is shown below.
+
+@float Figure,fig:anim-dumbbell
+@caption{NetAnim GUI with dumbbell animation.}
+@image{figures/animation-dumbbell, 4in}
+@end float
+
+The NetAnim GUI provides play, pause, and record buttons.  Play and 
+pause start and stop the simulation.  The record button starts a series 
+of screenshots of the animator, which are written to the directory in 
+which the trace file was run.  Two slider bars also exist.  The top 
+slider provides a "seek" functionality, which allows a user to skip to 
+any moment in the simulation.  The bottom slider changes the granularity 
+of the time step for the animation. Finally, there is a quit button to 
+stop the simulation and quit the animator.
+
+@subsection Prerequisites
+
+The animator requires the Qt4 development packages. If you are using a 
+Debian or Ubuntu Linux distribution, you can get the following package: 
+qt4-dev-tools 
+
+This should install everything you need to compile and build NetAnim. 
+If you are using an Red Hat based distribution, look for similar qt4 
+packages (or libqt4*) and install these using yum. Mac users should 
+install the binaries: http://www.qtsoftware.com/downloads/mac-os-cpp
+
+Make sure to download the binary package; look for a link to something 
+without the word "src" or "debug" in the download filename. These will 
+be the library binaries you need.
+
+@subsection Downloading NetAnim
+
+The tarball of the source code for NetAnim is available here: 
+@uref{http://www.nsnam.org/~jpelkey3/NetAnim.tar.gz,,http://www.nsnam.org/~jpelkey3/NetAnim.tar.gz}. 
+Download it, then untar it: 
+
+@verbatim
+tar -xzvf NetAnim.tar.gz
+@end verbatim
+
+@subsection Building NetAnim
+
+NetAnim uses a Qt4 build tool called qmake; this is similar to the 
+configure script from autotools in that it generates the Makefile, 
+which make then uses to build the project. qmake is different on 
+different versions of Qt, so we'll provide some additional information 
+that is system dependent. You can check your default version of qmake:
+
+@verbatim
+qmake --version
+Qmake version: 1.07a (Qt 3.3.8b)
+Qmake is free software from Trolltech ASA.
+@end verbatim
+
+If you see something like the above, where it says Qt 3.x.x, find the 
+qt4 version of qmake on your system and explicitly call it instead.
+
+In general,
+
+@verbatim
+cd NetAnim
+qmake
+make
+@end verbatim
+
+On Mac OSX,
+
+@verbatim
+cd NetAnim
+/usr/local/Trolltech/Qt-4.x.y/bin/qmake
+make
+@end verbatim
+
+Note that above, the x.y is the specific version of Qt4 you are running. 
+As of April 1st 2009, the latest version is 4.5.0, although you might 
+have an older version already installed. 
+
+On Ubuntu/Debian with Qt3 AND Qt4,
+
+@verbatim
+cd NetAnim
+qmake-qt4
+make
+@end verbatim

doc/manual/applications.texi

@@ -0,0 +1,6 @@
+@node Applications
+@chapter Applications
+
+@cartouche
+Placeholder chapter
+@end cartouche

doc/manual/attributes.texi

@@ -125,7 +125,8 @@ public:
 
 This is defined in the node.cc file as follows:
 
-@verbatim
+@smallformat
+@example
 TypeId 
 Node::GetTypeId (void)
 {
@@ -148,15 +149,16 @@ Node::GetTypeId (void)
     ;
   return tid;
 }
-@end verbatim
+@end example
+@end smallformat
 
-Look at the TypeId of an ns-3 @code{Object} class as an extended form of run 
-time type information (RTTI).  The C++ language includes simple kind of RTTI
+Consider the TypeId of an ns-3 @code{Object} class as an extended form of run 
+time type information (RTTI).  The C++ language includes a simple kind of RTTI
 in order to support @code{dynamic_cast} and @code{typeid} operators.
 
 The ``@code{.SetParent<Object> ()}'' call in the declaration above is used in 
 conjunction with our object aggregation mechanisms to allow safe up- and
-down-casing in inheritance trees during @code{GetObject}.
+down-casting in inheritance trees during @code{GetObject}.
 
 The ``@code{.AddConstructor<Node> ()}'' call is used in conjunction with our
 abstract object factory mechanisms to allow us to construct C++ objects without
@@ -183,7 +185,7 @@ without even knowing the concrete C++ type
 @verbatim
   ObjectFactory factory;
   const std::string typeId = "ns3::Node'';
-  factory.SetTypeId(typeId);
+  factory.SetTypeId (typeId);
   Ptr<Object> node = factory.Create <Object> ();
 @end verbatim
 
@@ -259,7 +261,8 @@ and some type of global default value.
 In the ns-3 attribute system, these value definitions and accessor
 functions are moved into the TypeId class; e.g.:  
 
-@verbatim
+@smallformat
+@example
 NS_OBJECT_ENSURE_REGISTERED (DropTailQueue);
 
 TypeId DropTailQueue::GetTypeId (void) 
@@ -276,7 +279,8 @@ TypeId DropTailQueue::GetTypeId (void)
   
   return tid;
 }
-@end verbatim
+@end example
+@end smallformat
 
 The AddAttribute() method is performing a number of things with this
 value:
@@ -295,11 +299,19 @@ section, we will provide an example script that shows how users
 may manipulate these values.
 
 Note that initialization of the attribute relies on the macro
-NS_OBJECT_ENSURE_REGISTERED (DropTailQueue) being called; if you leave
+@code{NS_OBJECT_ENSURE_REGISTERED} (DropTailQueue) being called; if you leave
 this out of your new class implementation, your attributes will not be 
 initialized correctly.
 
-@subsection Basic usage
+While we have described how to create attributes, we still haven't
+described how to access and manage these values.  For instance, there is no 
+@code{globals.h} header file where these are stored; attributes are
+stored with their classes.  Questions that naturally arise are how
+do users easily learn about all of the attributes of their models, and
+how does a user access these attributes, or document their values 
+as part of the record of their simulation?
+
+@subsection Default values and command-line arguments
 
 Let's look at how a user script might access these values.  
 This is based on the script found at @code{samples/main-attribute-value.cc},
@@ -341,7 +353,8 @@ Now, we will create a few objects using the low-level API; here,
 our newly created queues will not have a m_maxPackets initialized to
 100 packets but to 80 packets, because of what we did above with
 default values.
-@verbatim
+@smallformat
+@example
   Ptr<Node> n0 = CreateObject<Node> ();
 
   Ptr<PointToPointNetDevice> net0 = CreateObject<PointToPointNetDevice> ();
@@ -349,7 +362,8 @@ default values.
 
   Ptr<Queue> q = CreateObject<DropTailQueue> ();
   net0->AddQueue(q);
-@end verbatim
+@end example
+@end smallformat
 
 At this point, we have created a single node (Node 0) and a 
 single PointToPointNetDevice (NetDevice 0) and added a 
@@ -358,10 +372,10 @@ DropTailQueue to it.
 Now, we can manipulate the MaxPackets value of the already 
 instantiated DropTailQueue.  Here are various ways to do that.
 
-@subsubsection Pointer-based access
+@subsection Pointer-based access
 
 We assume that a smart pointer (Ptr) to a relevant network device is 
-in hand; here, it is the net0 pointer. 
+in hand; in the current example, it is the @code{net0} pointer. 
 
 One way to change the value is to access a pointer to the
 underlying queue and modify its attribute.
@@ -369,11 +383,11 @@ underlying queue and modify its attribute.
 First, we observe that we can get a pointer to the (base class)
 queue via the PointToPointNetDevice attributes, where it is called
 TxQueue 
-@verbatim
+@example
   PointerValue tmp;
   net0->GetAttribute ("TxQueue", tmp);
   Ptr<Object> txQueue = tmp.GetObject ();
-@end verbatim
+@end example
 
 Using the GetObject function, we can perform a safe downcast
 to a DropTailQueue, where MaxPackets is a member
@@ -409,44 +423,52 @@ Now, let's set it to another value (60 packets)
   NS_LOG_INFO ("3.  txQueue limit changed: " << limit.Get () << " packets");
 @end verbatim
 
-@subsubsection Namespace-based access
+@subsection Namespace-based access
 
 An alternative way to get at the attribute is to use the configuration namespace.
 Here, this attribute resides on a known path in this namespace; this approach
 is useful if one doesn't have access to the underlying pointers and would like
 to configure a specific attribute with a single statement.  
 
-@verbatim
+@smallformat
+@example
   Config::Set ("/NodeList/0/DeviceList/0/TxQueue/MaxPackets", UintegerValue (25));
   txQueue->GetAttribute ("MaxPackets", limit); 
   NS_LOG_INFO ("4.  txQueue limit changed through namespace: " << 
     limit.Get () << " packets");
-@end verbatim
+@end example
+@end smallformat
 
 We could have also used wildcards to set this value for all nodes and all net 
 devices (which in this simple example has the same effect as the previous Set())
-@verbatim
+@smallformat
+@example
   Config::Set ("/NodeList/*/DeviceList/*/TxQueue/MaxPackets", UintegerValue (15));
   txQueue->GetAttribute ("MaxPackets", limit); 
   NS_LOG_INFO ("5.  txQueue limit changed through wildcarded namespace: " << 
     limit.Get () << " packets");
-@end verbatim
+@end example
+@end smallformat
 
-@subsubsection Object Name Service-based access
+@subsection Object Name Service-based access
 
 Another way to get at the attribute is to use the object name service facility.
 Here, this attribute is found using a name string.  This approach is useful if 
 one doesn't have access to the underlying pointers and it is difficult to 
 determine the required concrete configuration namespaced path.
 
-@verbatim
+@smallformat
+@example
   Names::Add ("server", serverNode);
   Names::Add ("server/eth0", serverDevice);
 
   ...
 
   Config::Set ("/Names/server/eth0/TxQueue/MaxPackets", UintegerValue (25));
-@end verbatim
+@end example
+@end smallformat
+
+@xref{Object names} for a fuller treatment of the ns-3 configuration namespace.
 
 @subsection Setting through constructors helper classes
 
@@ -466,7 +488,8 @@ or from the higher-level helper APIs, such as:
                                  "LayoutType", StringValue ("RowFirst"));
 @end verbatim
 
-@subsection Value classes
+@subsection Implementation details
+@subsubsection Value classes
 Readers will note the new FooValue classes which are subclasses of the
 AttributeValue base class.  These can be thought of as
 an intermediate class that can be used to convert from raw types to the
@@ -489,14 +512,14 @@ the attribute system:
 @item ATTRIBUTE_HELPER_CPP
 @end itemize
 
-@subsection Initialization order
+@subsubsection Initialization order
 
 In general, the attribute code to assign values to the underlying
 class member variables is executed after an object is constructed.
 But what if you need the values assigned before the constructor
 body executes, because you need them in the logic of the constructor?
 There is a way to do this, used for example in the class 
-@code{ns3::ConfigStore}:  call @code{ObjectBase::ConstructSelf()}
+@code{ns3::ConfigStore}:  call @code{ObjectBase::ConstructSelf ()}
 as follows:
 
 @verbatim
@@ -546,7 +569,8 @@ Here, we discuss the impact on a user who wants to add a new class to
 ns-3; what additional things must be done to hook it into this system.
 
 We've already introduced what a TypeId definition looks like:
-@verbatim
+@smallformat
+@example
 TypeId
 RandomWalk2dMobilityModel::GetTypeId (void)
 {
@@ -568,7 +592,8 @@ RandomWalk2dMobilityModel::GetTypeId (void)
     ;
   return tid;
 }
-@end verbatim
+@end example
+@end smallformat
 
 The declaration for this in the class declaration is one-line public
 member method:
@@ -599,7 +624,9 @@ the conversions to/from strings and attribute values.  Most of this can be
 copy/pasted with macro-ized code.  For instance, consider class
 declaration for Rectangle in the @code{src/mobility/} directory:
 
-@verbatim
+@subsection Header file
+@smallformat
+@example
 /**
  * \brief a 2d rectangle
  */
@@ -612,35 +639,42 @@ class Rectangle
   double yMin;
   double yMax;
 };
-@end verbatim
+@end example
+@end smallformat
  
 One macro call and two operators, must be added below the class declaration
 in order to turn a Rectangle into a value usable by the @code{Attribute}
 system:
 
-@verbatim
+@smallformat
+@example
 std::ostream &operator << (std::ostream &os, const Rectangle &rectangle);
 std::istream &operator >> (std::istream &is, Rectangle &rectangle);
 
 ATTRIBUTE_HELPER_HEADER (Rectangle);
-@end verbatim
+@end example
+@end smallformat
 
+@subsection Implementation file
 In the class definition (@code{.cc} file), the code looks like this:
 
-@verbatim
+@smallformat
+@example
 ATTRIBUTE_HELPER_CPP (Rectangle);
 
 std::ostream &
 operator << (std::ostream &os, const Rectangle &rectangle)
 {
-  os << rectangle.xMin << "|" << rectangle.xMax << "|" << rectangle.yMin << "|" << rectangle.yMax;
+  os << rectangle.xMin << "|" << rectangle.xMax << "|" << rectangle.yMin << "|"
+     << rectangle.yMax;
   return os;
 }
 std::istream &
 operator >> (std::istream &is, Rectangle &rectangle)
  {
   char c1, c2, c3;
-  is >> rectangle.xMin >> c1 >> rectangle.xMax >> c2 >> rectangle.yMin >> c3 >> rectangle.yMax;
+  is >> rectangle.xMin >> c1 >> rectangle.xMax >> c2 >> rectangle.yMin >> c3 
+     >> rectangle.yMax;
   if (c1 != '|' ||
       c2 != '|' ||
       c3 != '|')
@@ -649,7 +683,8 @@ operator >> (std::istream &is, Rectangle &rectangle)
     }
   return is;
 }
-@end verbatim
+@end example
+@end smallformat
 
 These stream operators simply convert from a string representation of the
 Rectangle ("xMin|xMax|yMin|yMax") to the underlying Rectangle, and the
@@ -679,7 +714,8 @@ file to the scratch directory:
 Let's edit it to add the ConfigStore feature.  First, add an include statement 
 to include the contrib module, and then add these lines:
 
-@verbatim
+@smallformat
+@example
 #include "contrib-module.h"
 ...
 int main (...)
@@ -693,7 +729,8 @@ int main (...)
 
   Simulator::Run ();
 }
-@end verbatim
+@end example
+@end smallformat
 
 There are three attributes that govern the behavior of the ConfigStore:
 "Mode", "Filename", and "FileFormat".  The Mode (default "None") configures
@@ -705,12 +742,16 @@ the ConfigStore format is Xml or RawText format.
 
 So, using the above modified program, try executing the following
 waf command and 
-@verbatim
-./waf --command-template="%s --ns3::ConfigStore::Filename=csma-bridge-config.xml --ns3::ConfigStore::Mode=Save --ns3::ConfigStore::FileFormat=Xml" --run scratch/csma-bridge
-@end verbatim
+@smallformat
+@example
+./waf --command-template="%s --ns3::ConfigStore::Filename=csma-bridge-config.xml
+--ns3::ConfigStore::Mode=Save --ns3::ConfigStore::FileFormat=Xml" --run scratch/csma-bridge
+@end example
+@end smallformat
 After running, you can open the csma-bridge-config.xml file and it will
 display the configuration that was applied to your simulation; e.g.
-@verbatim
+@smallformat
+@example
 <?xml version="1.0" encoding="UTF-8"?>
 <ns3>
  <default name="ns3::V4Ping::Remote" value="102.102.102.102"/>
@@ -723,7 +764,9 @@ display the configuration that was applied to your simulation; e.g.
  <default name="ns3::QstaWifiMac::MaxMissedBeacons" value="10"/>
  <default name="ns3::QstaWifiMac::ActiveProbing" value="false"/>
 ...
-@end verbatim
+@end example
+@end smallformat
+
 This file can be archived with your simulation script and output data.
 
 While it is possible to generate a sample config file and lightly
@@ -749,7 +792,8 @@ separate file called "output-attributes.xml".  (Note-- to get this
 input xml file to begin with, it is sometimes helpful to run the
 program to generate an output xml file first, then hand-edit that
 file and re-input it for the next simulation run).
-@verbatim
+@smallformat
+@example
 #include "contrib-module.h"
 ...
 int main (...)
@@ -778,7 +822,8 @@ int main (...)
   outputConfig.ConfigureAttributes ();
   Simulator::Run ();
 }
-@end verbatim
+@end example
+@end smallformat
 
 @subsection GTK-based ConfigStore
 
@@ -794,24 +839,28 @@ sudo apt-get install libgtk2.0-0 libgtk2.0-dev
 @end verbatim
 To check whether it is configured or not, check the output of the
 ./waf configure step:
-@verbatim
+@smallformat
+@example
 ---- Summary of optional NS-3 features:
 Threading Primitives          : enabled
 Real Time Simulator           : enabled
 GtkConfigStore                : not enabled (library 'gtk+-2.0 >= 2.12' not found)
-@end verbatim
+@end example
+@end smallformat
 
 In the above example, it was not enabled, so it cannot be used until a
 suitable version is installed and ./waf configure; ./waf is rerun.
 
 Usage is almost the same as the non-GTK-based version, but there
 are no ConfigStore attributes involved:
-@verbatim
+@smallformat
+@example
   // Invoke just before entering Simulator::Run ()
   GtkConfigStore config;
   config.ConfigureDefaults ();
   config.ConfigureAttributes ();
-@end verbatim
+@end example
+@end smallformat
 
 Now, when you run the script, a GUI should pop up, allowing you to open
 menus of attributes on different nodes/objects, and then launch the

doc/manual/bridge.texi

@@ -0,0 +1,9 @@
+@node Bridge NetDevice
+@chapter Bridge NetDevice
+
+@cartouche
+Placeholder chapter
+@end cartouche
+
+Some examples of the use of Bridge NetDevice can be found in
+@code{examples/csma/} directory. 

doc/manual/callbacks.texi

@@ -7,15 +7,16 @@ chapter provides some motivation on the callback, guidance on how to use
 it, and details on its implementation.
 
 @menu
-* Motivation::
-* Background::
+* Callbacks Motivation::
+* Callbacks Background::
 * Using the Callback API::
 * Bound Callbacks::
 * Callback locations in ns-3::
+* Traced Callbacks::
 * Implementation details::
 @end menu
 
-@node Motivation
+@node Callbacks Motivation
 @section Motivation
 
 Consider that you have two simulation models A and B, and you wish
@@ -35,7 +36,6 @@ public:
 
 class B {
 public:
-  void ReceiveInput ( // parameters);
   void DoSomething (void);
   ...
 
@@ -91,9 +91,13 @@ to a transport protocol above, the user may be forced to hack the
 system to get the desired interconnections,  This is clearly not an
 optimal way to design a generic simulator.
 
-@node Background
+@node Callbacks Background
 @section Background
 
+@cartouche
+Readers familiar with programming callbacks may skip this tutorial section.
+@end cartouche
+
 The basic mechanism that allows one to address the problem above is known as
 a @emph{callback}.  The ultimate goal is to allow one piece of code to call 
 a function (or method in C++) without any specific inter-module dependency.
@@ -358,16 +362,19 @@ Consider also the following main program snippet:
 @end verbatim
 
 This is an example of a C-style callback -- one which does not include or need
-a @code{this} pointer.  The funtion template @code{Callback} is esentially the
+a @code{this} pointer.  The function template @code{Callback} is esentially the
 declaration of the variable containing the pointer-to-function.  In the example
 above, we explicitly showed a pointer to a function that returned an integer and
 took a single integer as a parameter,  The @code{Callback} template function is
 a generic version of that -- it is used to declare the type of a callback.  
 
+@strong{Note1:} Readers unfamiliar with C++ templates may consult
+@uref{http://www.cplusplus.com/doc/tutorial/templates/,,this reference}.
+
 The @code{Callback} template requires one mandatory argument (the return type 
 of the function to be assigned to this callback) and up to five optional 
 arguments, which each specify the type of the arguments (if your particular
-callback function has more than five arguments, then this can be easily handled
+callback function has more than five arguments, then this can be handled
 by extending the callback implementation).
 
 So in the above example, we have a declared a callback named "one" that will
@@ -451,7 +458,7 @@ invoked.  Consider this example, also from main-callback.cc:
 @end verbatim
 
 Here, we pass an additional object pointer to the @code{MakeCallback<>} function.
-Recall from the example above that @code{Operator()} will use the pointer to 
+Recall from the background section above that @code{Operator()} will use the pointer to 
 member syntax when it executes on an object:
 
 @verbatim
@@ -505,7 +512,7 @@ later -- when the @code{Callback} is called via @code{operator()}.  All of
 the parameters are provided by the calling function.  
 
 What if it is desired to allow the client function (the one that provides the
-callback) to provide some of the parameters?  Alexandrescu calls the process of
+callback) to provide some of the parameters?  @uref{http://erdani.com/book/main.html,,Alexandrescu} calls the process of
 allowing a client to specify one of the parameters @emph{binding}.  One of the 
 parameters of @code{operator()} has been bound (fixed) by the client.
 
@@ -539,7 +546,7 @@ takes the parameters to be bound.  In the case of the example above,
     MakeBoundCallback (&CsmaHelper::SniffEvent, pcap));
 @end verbatim
 
-Will create a specific callback implementation that knows to add in the extra
+will create a specific callback implementation that knows to add in the extra
 bound arguments.  Conceptually, it extends the specific functor described above
 with one or more bound arguments
 
@@ -581,16 +588,24 @@ function call:
   (*m_p.*m_pmi)(m_boundArg, arg);
 @end verbatim
 
+@node Traced Callbacks
+@section Traced Callbacks
+@cartouche
+Placeholder subsection
+@end cartouche
+@section Callback locations in @command{ns-3}
 @node Callback locations in ns-3
 @section Callback locations in @command{ns-3}
 
 Where are callbacks frequently used in @command{ns-3}?  Here are some of the
 more visible ones to typical users:
 
-@subsection Socket API
-@subsection Layer-2/Layer-3 API
-@subsection Tracing subsystem
-@subsection Routing
+@itemize @bullet
+@item Socket API
+@item Layer-2/Layer-3 API
+@item Tracing subsystem
+@item API between IP and routing subsystems
+@end itemize
 
 @node Implementation details
 @section Implementation details
@@ -600,8 +615,9 @@ itself.  The actual Callback code is quite complicated and very template-intense
 a deep understanding of the code is not required.  If interested, expert users may
 find the following useful:
 
-The code was originally written based on the techniques described 
-@uref{http://www.codeproject.com/cpp/TTLFunction.asp,,here}.
+The code was originally written based on the techniques described in 
+@uref{http://www.codeproject.com/cpp/TTLFunction.asp,,
+http://www.codeproject.com/cpp/TTLFunction.asp}.
 It was subsequently rewritten to follow the architecture outlined in 
 @uref{http://www.amazon.com/Modern-C\%2B\%2B-Design-Programming-Patterns/dp/0201704315/ref=pd_bbs_sr_1/102-0157303-1900156?ie=UTF8\&s=books\&qid=1187982662\&sr=1-1,,Modern C++ Design: Generic Programming and Design Patterns Applied-- Alexandrescu}, chapter 5, "Generalized Functors".
 

doc/manual/emu.texi

@@ -1,183 +1,288 @@
 @node Emu NetDevice
 @chapter Emu NetDevice
 
-This is the introduction to Emu NetDevice chapter, to complement the
-Emu model doxygen.
+@section Behavior
 
-@menu
-* Overview of the model::
-* Using the EmuNetDevice::
-* Emu Tracing::
-@end menu
+The @code{Emu} net device allows a simulation node to send and receive packets
+over a real network.  The emulated net device relies on a specified interface 
+being in promiscuous mode.  It opens a raw socket and binds to that interface.
+We perform MAC spoofing to separate simulation network traffic from other 
+network traffic that may be flowing to and from the host.
 
-@node Overview of the model
-@section Overview of the model
+One can use the @code{Emu} net device in a testbed situation where the 
+host on which the simulation is running has a specific interface of interest 
+which  drives the testbed hardware.  You would also need to set this specific 
+interface into promiscuous mode and provide an appropriate device name to the 
+ns-3 emulated net device.  An example of this environment is the ORBIT testbed 
+as described above.
 
-The emulated net device allows a simulation node to send and receive packets
-a real network.
-
-The Emu net device is not a complete net device and channel combination as is
-typical in ns-3.  The Emu device can be thought of as a proxy for a real
-device that resides in an ns-3 simulation.  The Emu net device talks to that
-real device using raw sockets and binds to the device via the Linux interface.
-There is no related Emu channel since other devices will most likely reside on
-different computers running entirely separate simulations.
-
-The Emu net device relies on a specified interface (``eth1, for example) being
-in promiscuous mode.  It opens a raw socket and binds to that interface.  We 
-perform MAC spoofing to separate simulation network traffic from other network
-traffic that may be flowing to and from the host.
-
-Normally, the use case for emulated net devices is in collections of
-small simulations that connect to the outside world through specific 
-interfaces.  For example, one could construct a number of virtual
-machines and connect them via a host-only network.  To use the emulated
-net device, you would need to set all of the host-only interfaces in
-promiscuous mode and provide an appropriate device name, "eth1" for example.
-
-One could also use the emulated net device in a testbed situation
-where the host on which the simulation is running has a specific interface
-of interest which drives the testbed hardware.  You would also need to set 
-this specific interface into promiscuous mode and provide an appropriate 
-device name to the ns-3 emulated net device.
-
-The emulated net device only works if the underlying interface is up in 
-promiscuous mode.  We could just turn it on, but the situation is that we 
-expect the other considerations listed above to have been dealt with.
-To verify that these issues are dealt with, we just make sure that the end 
-result of that process has taken place and that the specified interface is
-in promiscuous mode.
-
-@subsection Address Concerns
-
-Packets will be sent out over the device, but as mentioned, we use MAC spoofing.
-By default in the simulation, the MAC addresses will be generated using the 
+The @code{Emu} net device only works if the underlying interface is up and in 
+promiscuous mode.  Packets will be sent out over the device, but we use MAC
+spoofing.  The MAC addresses will be generated (by default) using the 
 Organizationally Unique Identifier (OUI) 00:00:00 as a base.  This vendor code
 is not assigned to any organization and so should not conflict with any real 
 hardware.  
 
-It is always up to you to determine that using these MAC addresses is
+It is always up to the user to determine that using these MAC addresses is
 okay on your network and won't conflict with anything else (including another
-simulation using emu devices) on your network.  If you are using the 
+simulation using @code{Emu} devices) on your network.  If you are using the 
 emulated net device in separate simulations you must consider global MAC 
 address assignment issues and ensure that MAC addresses are unique across
 all simulations.  The emulated net device respects the MAC address provided
-in the SetAddress method so you can do this manually.  For larger simulations,
-you may want to set the OUI in the MAC address allocation function.
+in the @code{SetAddress} method so you can do this manually.  For larger 
+simulations, you may want to set the OUI in the MAC address allocation function.
 
 IP addresses corresponding to the emulated net devices are the addresses 
 generated in the simulation, which are generated in the usual way via helper
-functions.
-
-@subsection Attributes
-
-The Emu network device appears to the ns-3 system just as any other device and
-can be controlled through the attribute system, and traced through conventional
-trace hooks.  The EmuNetDevice provides following Attributes:
-
-@itemize @bullet
-@item Address:  The Mac48Address of the device;
-@item DeviceName: The name of the underlying real device (e.g., ``eth1'');
-@item Start:  The simulation time at which to enable the underlying socket;
-@item Stop:  The simulation time at which to stop receiving from the underlying socket;
-@item TxQueue:  The transmit queue used by the device;
-@item InterframeGap:  The optional time to wait between "frames";
-@item Rx:  A trace source for received packets;
-@end itemize
-
-Packets sent over the EmuNetDevice are always routed through the 
-transmit queue to provide a trace hook for packets sent out over the 
-network.  This transmit queue can be set (via attribute) to model different
-queuing strategies.
-
-@node Using the EmuNetDevice
-@section Using the EmuNetDevice
+functions.  Since we are using MAC spoofing, there will not be a conflict 
+between ns-3 network stacks and any native network stacks.
 
 The emulated net device comes with a helper function as all ns-3 devices do.
 One unique aspect is that there is no channel associated with the underlying
-medium.  We really have no idea what this medium is, and so have not made an
-effort to model it abstractly.  The primary thing to be aware of is the 
-implication this has for static global routing.  The global router module
+medium.  We really have no idea what this external medium is, and so have not
+made an effort to model it abstractly.  The primary thing to be aware of is the 
+implication this has for IPv4 global routing.  The global router module
 attempts to walk the channels looking for adjacent networks.  Since there 
-is no channel, the global router will be unable to do this.
+is no channel, the global router will be unable to do this and you must then 
+use a dynamic routing protocol such as OLSR to include routing in 
+@code{Emu}-based networks.
 
-The Emu net devices are typically created and configured using the associated 
-@code{EmuHelper} object.  The various ns3 device helpers generally work in a
-similar way, and their use is seen in many of our example programs.
-
-The conceptual model of interest is that of a bare computer ``husk'' into which 
-you plug net devices.  The bare computers are created using a @code{NodeContainer}
-helper.  You just ask this helper to create as many computers (we call them
-@code{Nodes}) as you need on your network:
+@section Usage
 
+Any mixing of ns-3 objects with real objects will typically require that
+ns-3 compute checksums in its protocols.  By default, checksums are not
+computed by ns-3.  To enable checksums (e.g. UDP, TCP, IP), users must set
+the attribute @code{ChecksumEnabled} to true, such as follows:
 @verbatim
-  NodeContainer nodes;
-  nodes.Create (nEmuNodes);
+GlobalValue::Bind ("ChecksumEnabled", BooleanValue (true));
 @end verbatim
 
-Once you have your nodes, you need to instantiate a @code{EmuHelper} and set
-any attributes you may want to change.
+The usage of the @code{Emu} net device is straightforward once the network of
+simulations has been configured.  Since most of the work involved in working 
+with this device is in network configuration before even starting a simulation,
+you may want to take a moment to review a couple of HOWTO pages on the ns-3 wiki
+that describe how to set up a virtual test network using VMware and how to run
+a set of example (client server) simulations that use @code{Emu} net devices.
+
+@itemize @bullet
+@item @uref{http://www.nsnam.org/wiki/index.php/HOWTO_use_VMware_to_set_up_virtual_networks_(Windows)}
+@item @uref{http://www.nsnam.org/wiki/index.php/HOWTO_use_ns-3_scripts_to_drive_real_hardware_(experimental)} 
+@end itemize
+
+Once you are over the configuration hurdle, the script changes required to use 
+an @code{Emu} device are trivial.  The main structural difference is that you
+will need to create an ns-3 simulation script for each node.  In the case of
+the HOWTOs above, there is one client script and one server script.  The only
+``challenge'' is to get the addresses set correctly.
+
+Just as with all other ns-3 net devices, we provide a helper class for the 
+@code{Emu} net device.  The following code snippet illustrates how one would
+declare an EmuHelper and use it to set the ``DeviceName'' attribute to ``eth1''
+and install @code{Emu} devices on a group of nodes.  You would do this on both
+the client and server side in the case of the HOWTO seen above.
 
 @verbatim
   EmuHelper emu;
-  csma.SetAttribute ("DeviceName", StringValue ("eth1"));
+  emu.SetAttribute ("DeviceName", StringValue ("eth1"));
+  NetDeviceContainer d = emu.Install (n);
 @end verbatim
- 
-Once the attributes are set, all that remains is to create the devices
-and install them on the required nodes.  When we create the net devices, 
-we add them to a container to allow you to use them in the future.  This 
-all takes just one line of code.
+
+The only other change that may be required is to make sure that the address
+spaces (MAC and IP) on the client and server simulations are compatible.  First
+the MAC address is set to a unique well-known value in both places (illustrated
+here for one side).
 
 @verbatim
-  NetDeviceContainer emuDevices = emu.Install (nodes);
+  //
+  // We've got the devices in place.  Since we're using MAC address 
+  // spoofing under the sheets, we need to make sure that the MAC addresses
+  // we have assigned to our devices are unique.  Ns-3 will happily
+  // automatically assign the same MAC address to the devices in both halves
+  // of our two-script pair, so let's go ahead and just manually change them
+  // to something we ensure is unique.
+  //
+  Ptr<NetDevice> nd = d.Get (0);
+  Ptr<EmuNetDevice> ed = nd->GetObject<EmuNetDevice> ();
+  ed->SetAddress ("00:00:00:00:00:02");
 @end verbatim
 
-@node Emu Tracing
-@section Emu Tracing
+And then the IP address of the client or server is set in the usual way using
+helpers.
 
-Like all ns-3 devices, the Emu Model provides a number of trace sources.
-These trace sources can be hooked using your own custom trace code, or you
-can use our helper functions to arrange for tracing to be enabled on devices
-you specify.
+@verbatim
+  //
+  // We've got the "hardware" in place.  Now we need to add IP addresses.
+  // This is the server half of a two-script pair.  We need to make sure
+  // that the addressing in both of these applications is consistent, so
+  // we use provide an initial address in both cases.  Here, the client 
+  // will reside on one machine running ns-3 with one node having ns-3
+  // with IP address "10.1.1.2" and talk to a server script running in 
+  // another ns-3 on another computer that has an ns-3 node with IP 
+  // address "10.1.1.3"
+  //
+  Ipv4AddressHelper ipv4;
+  ipv4.SetBase ("10.1.1.0", "255.255.255.0", "0.0.0.2");
+  Ipv4InterfaceContainer i = ipv4.Assign (d);
+@end verbatim
 
-@subsection Upper-Level (MAC) Hooks
+You will use application helpers to generate traffic exactly as you do in any
+ns-3 simulation script.  Note that the server address shown below in a snippet
+from the client, must correspond to the IP address assigned to the server node
+similarly to the snippet above. 
 
-From the point of view of tracing in the net device, there are several 
-interesting points to insert trace hooks.  A convention inherited from other
-simulators is that packets destined for transmission onto attached networks
-pass through a single "transmit queue" in the net device.  We provide trace 
-hooks at this point in packet flow, which corresponds (abstractly) only to a 
-transition from the network to data link layer, and call them collectively
-the device MAC hooks.
+@verbatim
+  uint32_t packetSize = 1024;
+  uint32_t maxPacketCount = 2000;
+  Time interPacketInterval = Seconds (0.001);
+  UdpEchoClientHelper client ("10.1.1.3", 9);
+  client.SetAttribute ("MaxPackets", UintegerValue (maxPacketCount));
+  client.SetAttribute ("Interval", TimeValue (interPacketInterval));
+  client.SetAttribute ("PacketSize", UintegerValue (packetSize));
+  ApplicationContainer apps = client.Install (n.Get (0));
+  apps.Start (Seconds (1.0));
+  apps.Stop (Seconds (2.0));
+@end verbatim
 
-When a packet is sent to the Emu net device for transmission it always 
-passes through the transmit queue.  The transmit queue in the 
-EmuNetDevice inherits from Queue, and therefore inherits three 
-trace sources:
+The @code{Emu} net device and helper provide access to ASCII and pcap tracing
+functionality just as other ns-3 net devices to.  You enable tracing similarly
+to these other net devices:
 
-@itemize @bullet
-@item An Enqueue operation source (see Queue::m_traceEnqueue);
-@item A Dequeue operation source (see Queue::m_traceDequeue);
-@item A Drop operation source (see Queue::m_traceDrop).
-@end itemize
+@verbatim
+  EmuHelper::EnablePcapAll ("emu-udp-echo-client");
+@end verbatim
 
-The upper-level (MAC) trace hooks for the EmuNetDevice are, in fact, 
-exactly these three trace sources on the single transmit queue of the device.  
+To see an example of a client script using the @code{Emu} net device, see
+@code{examples/emu-udp-echo-client.cc} and @code{examples/emu-udp-echo-server.cc}
+in the repository @uref{http://code.nsnam.org/craigdo/ns-3-emu/}. 
 
-The m_traceEnqueue event is triggered when a packet is placed on the transmit
-queue.  This happens at the time that EmuNetDevice::Send or 
-EmuNetDevice::SendFrom is called by a higher layer to queue a packet for 
-transmission.
+@section Implementation
 
-The m_traceDequeue event is triggered when a packet is removed from the
-transmit queue.  Dequeues from the transmit queue happen immediately after
-the Enqueue event and just prior to the packet being sent to the underlying
-socket.  This means that the transmit queue really only exists to fire on
-enqueue and dequeue operations so the Emu device behaves like other ns-3
-devices in this respect.
+Perhaps the most unusual part of the @code{Emu} and @code{Tap} device 
+implementation relates to the requirement for executing some of the code 
+with super-user permissions.  Rather than force the user to execute the entire
+simulation as root, we provide a small ``creator'' program that runs as root
+and does any required high-permission sockets work.
 
-@subsection Lower-Level (PHY) Hooks
+We do a similar thing for both the @code{Emu} and the @code{Tap} devices.
+The high-level view is that the @code{CreateSocket} method creates a local 
+interprocess (Unix) socket, forks, and executes the small creation program.
+The small program, which runs as suid root, creates a raw socket and sends 
+back the raw socket file descriptor over the Unix socket that is passed to
+it as a parameter.  The raw socket is passed as a control message (sometimes 
+called ancillary data) of type SCM_RIGHTS.
+
+The @code{Emu} net device uses the ns-3 threading and multithreaded real-time
+scheduler extensions.  The interesting work in the @code{Emu} device is done
+when the net device is started (@code{EmuNetDevice::StartDevice ()}).  An 
+attribute (``Start'') provides a simulation time at which to spin up the 
+net device.  At this specified time (which defaults to t=0), the socket 
+creation function is called and executes as described above.  You may also
+specify a time at which to stop the device using the ``Stop'' attribute.
+
+Once the (promiscuous mode) socket is created, we bind it to an interface name 
+also provided as an attribute (``DeviceName'') that is stored internally as 
+@code{m_deviceName}:
+
+@verbatim
+  struct ifreq ifr;
+  bzero (&ifr, sizeof(ifr));
+  strncpy ((char *)ifr.ifr_name, m_deviceName.c_str (), IFNAMSIZ);
+
+  int32_t rc = ioctl (m_sock, SIOCGIFINDEX, &ifr);
+
+  struct sockaddr_ll ll;
+  bzero (&ll, sizeof(ll));
+
+  ll.sll_family = AF_PACKET;
+  ll.sll_ifindex = m_sll_ifindex;
+  ll.sll_protocol = htons(ETH_P_ALL);
+
+  rc = bind (m_sock, (struct sockaddr *)&ll, sizeof (ll));
+@end verbatim
+
+After the promiscuous raw socket is set up, a separate thread is spawned to do 
+reads from that socket and the link state is set to @code{Up}.
+
+@verbatim
+  m_readThread = Create<SystemThread> (
+    MakeCallback (&EmuNetDevice::ReadThread, this));
+  m_readThread->Start ();
+
+  NotifyLinkUp ();
+@end verbatim
+
+The @code{EmuNetDevice::ReadThread} function basically just sits in an infinite
+loop reading from the promiscuous mode raw socket and scheduling packet 
+receptions using the real-time simulator extensions.
+
+@verbatim
+  for (;;)
+    {
+      ...
+
+      len = recvfrom (m_sock, buf, bufferSize, 0, (struct sockaddr *)&addr, 
+        &addrSize);
+
+      ...
+
+      DynamicCast<RealtimeSimulatorImpl> (Simulator::GetImplementation ())->
+        ScheduleRealtimeNow (
+          MakeEvent (&EmuNetDevice::ForwardUp, this, buf, len));
+
+      ...
+    }
+@end verbatim
+
+The line starting with our templated DynamicCast function probably deserves a 
+comment.  It gains access to the simulator implementation object using
+the @code{Simulator::GetImplementation} method and then casts to the real-time
+simulator implementation to use the real-time schedule method 
+@code{ScheduleRealtimeNow}.  This function will cause a handler for the  newly
+received packet to be scheduled for execution at the current real time clock 
+value.  This will, in turn cause the simulation clock to be advanced to that 
+real time value when the scheduled event (@code{EmuNetDevice::ForwardUp}) is
+fired.
+
+The @code{ForwardUp} function operates as most other similar ns-3 net device 
+methods do.  The packet is first filtered based on the destination address.  In 
+the case of the @code{Emu} device, the MAC destination address will be the 
+address of the @code{Emu} device and not the hardware address of the real 
+device.  Headers are then stripped off and the trace hooks are hit.  Finally,
+the packet is passed up the ns-3 protocol stack using the receive callback 
+function of the net device.
+
+Sending a packet is equally straightforward as shown below.  The first thing
+we do is to add the ethernet header and trailer to the ns-3 @code{Packet} we
+are sending.  The source address corresponds to the address of the @code{Emu}
+device and not the underlying native device MAC address.  This is where the
+MAC address spoofing is done.  The trailer is added and we enqueue and dequeue
+the packet from the net device queue to hit the trace hooks.
+
+@verbatim
+  header.SetSource (source);
+  header.SetDestination (destination);
+  header.SetLengthType (packet->GetSize ());
+  packet->AddHeader (header);
+
+  EthernetTrailer trailer;
+  trailer.CalcFcs (packet);
+  packet->AddTrailer (trailer);
+
+  m_queue->Enqueue (packet);
+  packet = m_queue->Dequeue ();
+
+  struct sockaddr_ll ll;
+  bzero (&ll, sizeof (ll));
+
+  ll.sll_family = AF_PACKET;
+  ll.sll_ifindex = m_sll_ifindex;
+  ll.sll_protocol = htons(ETH_P_ALL);
+
+  rc = sendto (m_sock, packet->PeekData (), packet->GetSize (), 0, 
+    reinterpret_cast<struct sockaddr *> (&ll), sizeof (ll));
+@end verbatim
+
+
+Finally, we simply send the packet to the raw socket which puts it out on the 
+real network.
 
-There are no lower level trace hooks implemented in the Emu net device since
-we rely on the underlying OS implementation of the raw socket to perform
-the low level operations required to send and receive packets.

doc/manual/emulation.texi

@@ -1,6 +1,5 @@
 @node Emulation
 @chapter Emulation
-@anchor{chap:Emulation}
 
 ns-3 has been designed for integration into testbed and virtual machine
 environments.  We have addressed this need by providing two kinds of 
@@ -24,7 +23,7 @@ for details on the ORBIT testbed.
 A simulation of this kind is shown in the following figure:
 
 @float Figure,fig:testbed
-@center @caption{Example Implementation of Testbed Emulation.}
+@caption{Example Implementation of Testbed Emulation.}
 @center @image{figures/testbed, 5in}
 @end float
 
@@ -45,7 +44,7 @@ is shown in the following figure:
 
 @float Figure,fig:emulated-channel
 @caption{Implementation overview of emulated channel.}
-@image{figures/emulated-channel, 5in}
+@image{figures/emulated-channel, 6in}
 @end float
 
 Here, you will see that there is a single host with a number of virtual machines 
@@ -68,317 +67,3 @@ We expect the typical use case for this environment will be to analyze the
 behavior of native applications and protocol suites in the presence of large 
 simulated ns-3 networks.
 
-@section Behavior
-
-@subsection Emu Net Device
-
-The @code{Emu} net device allows a simulation node to send and receive packets
-over a real network.  The emulated net device relies on a specified interface 
-being in promiscuous mode.  It opens a raw socket and binds to that interface.
-We perform MAC spoofing to separate simulation network traffic from other 
-network traffic that may be flowing to and from the host.
-
-Normally, the use case for emulated net devices is in collections of small 
-simulations that connect to the outside world through specific interfaces.
-For example, one could construct a number of virtual machines and connect them
-via a host-only network.  To use the emulated net device, you would need to 
-set all of the host-only interfaces in promiscuous mode and provide an 
-appropriate device name, "eth1" for example.
-
-One could also use the @code{Emu} net device in a testbed situation where the 
-host on which the simulation is running has a specific interface of interest 
-which  drives the testbed hardware.  You would also need to set this specific 
-interface into promiscuous mode and provide an appropriate device name to the 
-ns-3 emulated net device.  An example of this environment is the ORBIT testbed 
-as described above.
-
-The @code{Emu} net device only works if the underlying interface is up and in 
-promiscuous mode.  Packets will be sent out over the device, but we use MAC
-spoofing.  The MAC addresses will be generated (by default) using the 
-Organizationally Unique Identifier (OUI) 00:00:00 as a base.  This vendor code
-is not assigned to any organization and so should not conflict with any real 
-hardware.  
-
-It is always up to the user to determine that using these MAC addresses is
-okay on your network and won't conflict with anything else (including another
-simulation using @code{Emu} devices) on your network.  If you are using the 
-emulated net device in separate simulations you must consider global MAC 
-address assignment issues and ensure that MAC addresses are unique across
-all simulations.  The emulated net device respects the MAC address provided
-in the @code{SetAddress} method so you can do this manually.  For larger 
-simulations, you may want to set the OUI in the MAC address allocation function.
-
-IP addresses corresponding to the emulated net devices are the addresses 
-generated in the simulation, which are generated in the usual way via helper
-functions.  Since we are using MAC spoofing, there will not be a conflict 
-between ns-3 network stacks and any native network stacks.
-
-The emulated net device comes with a helper function as all ns-3 devices do.
-One unique aspect is that there is no channel associated with the underlying
-medium.  We really have no idea what this external medium is, and so have not
-made an effort to model it abstractly.  The primary thing to be aware of is the 
-implication this has for static global routing.  The global router module
-attempts to walk the channels looking for adjacent networks.  Since there 
-is no channel, the global router will be unable to do this and you must then 
-use a dynamic routing protocol such as OLSR to include routing in 
-@code{Emu}-based networks.
-
-@subsection Tap Net Device
-
-The @code{Tap} Net Device is scheduled for inclusion in ns-3.4 at the writing
-of this section.  We will include details as soon as the @code{Tap} device is
-merged.
-
-@section Usage
-
-Any mixing of ns-3 objects with real objects will typically require that
-ns-3 compute checksums in its protocols.  By default, checksums are not
-computed by ns-3.  To enable checksums (e.g. UDP, TCP, IP), users must set
-the attribute @code{ChecksumEnabled} to true, such as follows:
-@verbatim
-GlobalValue::Bind ("ChecksumEnabled", BooleanValue (true));
-@end verbatim
-
-@subsection Emu Net Device
-
-The usage of the @code{Emu} net device is straightforward once the network of
-simulations has been configured.  Since most of the work involved in working 
-with this device is in network configuration before even starting a simulation,
-you may want to take a moment to review a couple of HOWTO pages on the ns-3 wiki
-that describe how to set up a virtual test network using VMware and how to run
-a set of example (client server) simulations that use @code{Emu} net devices.
-
-@uref{http://www.nsnam.org/wiki/index.php/HOWTO_use_VMware_to_set_up_virtual_networks_(Windows)}
-@uref{http://www.nsnam.org/wiki/index.php/HOWTO_use_ns-3_scripts_to_drive_real_hardware_(experimental)} 
-
-Once you are over the configuration hurdle, the script changes required to use 
-an @code{Emu} device are trivial.  The main structural difference is that you
-will need to create an ns-3 simulation script for each node.  In the case of
-the HOWTOs above, there is one client script and one server script.  The only
-``challenge'' is to get the addresses set correctly.
-
-Just as with all other ns-3 net devices, we provide a helper class for the 
-@code{Emu} net device.  The following code snippet illustrates how one would
-declare an EmuHelper and use it to set the ``DeviceName'' attribute to ``eth1''
-and install @code{Emu} devices on a group of nodes.  You would do this on both
-the client and server side in the case of the HOWTO seen above.
-
-@verbatim
-  EmuHelper emu;
-  emu.SetAttribute ("DeviceName", StringValue ("eth1"));
-  NetDeviceContainer d = emu.Install (n);
-@end verbatim
-
-The only other change that may be required is to make sure that the address
-spaces (MAC and IP) on the client and server simulations are compatible.  First
-the MAC address is set to a unique well-known value in both places (illustrated
-here for one side).
-
-@verbatim
-  //
-  // We've got the devices in place.  Since we're using MAC address 
-  // spoofing under the sheets, we need to make sure that the MAC addresses
-  // we have assigned to our devices are unique.  Ns-3 will happily
-  // automatically assign the same MAC addresses to the devices in both halves
-  // of our two-script pair, so let's go ahead and just manually change them
-  // to something we ensure is unique.
-  //
-  Ptr<NetDevice> nd = d.Get (0);
-  Ptr<EmuNetDevice> ed = nd->GetObject<EmuNetDevice> ();
-  ed->SetAddress ("00:00:00:00:00:02");
-@end verbatim
-
-And then the IP address of the client or server is set in the usual way using
-helpers.
-
-@verbatim
-  //
-  // We've got the "hardware" in place.  Now we need to add IP addresses.
-  // This is the server half of a two-script pair.  We need to make sure
-  // that the addressing in both of these applications is consistent, so
-  // we use provide an initial address in both cases.  Here, the client 
-  // will reside on one machine running ns-3 with one node having ns-3
-  // with IP address "10.1.1.2" and talk to a server script running in 
-  // another ns-3 on another computer that has an ns-3 node with IP 
-  // address "10.1.1.3"
-  //
-  Ipv4AddressHelper ipv4;
-  ipv4.SetBase ("10.1.1.0", "255.255.255.0", "0.0.0.2");
-  Ipv4InterfaceContainer i = ipv4.Assign (d);
-@end verbatim
-
-You will use application helpers to generate traffic exactly as you do in any
-ns-3 simulation script.  Note that the server address shown below in a snippet
-from the client, must correspond to the IP address assigned to the server node
-similarly to the snippet above. 
-
-@verbatim
-  uint32_t packetSize = 1024;
-  uint32_t maxPacketCount = 2000;
-  Time interPacketInterval = Seconds (0.001);
-  UdpEchoClientHelper client ("10.1.1.3", 9);
-  client.SetAttribute ("MaxPackets", UintegerValue (maxPacketCount));
-  client.SetAttribute ("Interval", TimeValue (interPacketInterval));
-  client.SetAttribute ("PacketSize", UintegerValue (packetSize));
-  ApplicationContainer apps = client.Install (n.Get (0));
-  apps.Start (Seconds (1.0));
-  apps.Stop (Seconds (2.0));
-@end verbatim
-
-The @code{Emu} net device and helper provide access to ASCII and pcap tracing
-functionality just as other ns-3 net devices to.  You enable tracing similarly
-to these other net devices:
-
-@verbatim
-  EmuHelper::EnablePcapAll ("emu-udp-echo-client");
-@end verbatim
-
-To see an example of a client script using the @code{Emu} net device, see
-@code{examples/emu-udp-echo-client.cc} and @code{examples/emu-udp-echo-server.cc}
-in the repository @uref{http://code.nsnam.org/craigdo/ns-3-emu/}. 
-
-@subsection Tap Net Device
-
-The @code{Tap} Net Device is scheduled for inclusion in ns-3.4 at the writing
-of this section.  We will include details as soon as the @code{Tap} device is
-merged.
-
-@section Implementation
-
-Perhaps the most unusual part of the @code{Emu} and @code{Tap} device 
-implementation relates to the requirement for executing some of the code 
-with super-user permissions.  Rather than force the user to execute the entire
-simulation as root, we provide a small ``creator'' program that runs as root
-and does any required high-permission sockets work.
-
-We do a similar thing for both the @code{Emu} and the @code{Tap} devices.
-The high-level view is that the @code{CreateSocket} method creates a local 
-interprocess (Unix) socket, forks, and executes the small creation program.
-The small program, which runs as suid root, creates a raw socket and sends 
-back the raw socket file descriptor over the Unix socket that is passed to
-it as a parameter.  The raw socket is passed as a control message (sometimes 
-called ancillary data) of type SCM_RIGHTS.
-
-@subsection Emu Net Device
-
-The @code{Emu} net device uses the ns-3 threading and multithreaded real-time
-scheduler extensions.  The interesting work in the @code{Emu} device is done
-when the net device is started (@code{EmuNetDevice::StartDevice ()}).  An 
-attribute (``Start'') provides a simulation time at which to spin up the 
-net device.  At this specified time (which defaults to t=0), the socket 
-creation function is called and executes as described above.  You may also
-specify a time at which to stop the device using the ``Stop'' attribute.
-
-Once the (promiscuous mode) socket is created, we bind it to an interface name 
-also provided as an attribute (``DeviceName'') that is stored internally as 
-@code{m_deviceName}:
-
-@verbatim
-  struct ifreq ifr;
-  bzero (&ifr, sizeof(ifr));
-  strncpy ((char *)ifr.ifr_name, m_deviceName.c_str (), IFNAMSIZ);
-
-  int32_t rc = ioctl (m_sock, SIOCGIFINDEX, &ifr);
-
-  struct sockaddr_ll ll;
-  bzero (&ll, sizeof(ll));
-
-  ll.sll_family = AF_PACKET;
-  ll.sll_ifindex = m_sll_ifindex;
-  ll.sll_protocol = htons(ETH_P_ALL);
-
-  rc = bind (m_sock, (struct sockaddr *)&ll, sizeof (ll));
-@end verbatim
-
-After the promiscuous raw socket is set up, a separate thread is spawned to do 
-reads from that socket and the link state is set to @code{Up}.
-
-@verbatim
-  m_readThread = Create<SystemThread> (
-    MakeCallback (&EmuNetDevice::ReadThread, this));
-  m_readThread->Start ();
-
-  NotifyLinkUp ();
-@end verbatim
-
-The @code{EmuNetDevice::ReadThread} function basically just sits in an infinite
-loop reading from the promiscuous mode raw socket and scheduling packet 
-receptions using the real-time simulator extensions.
-
-@verbatim
-  for (;;)
-    {
-      ...
-
-      len = recvfrom (m_sock, buf, bufferSize, 0, (struct sockaddr *)&addr, 
-        &addrSize);
-
-      ...
-
-      DynamicCast<RealtimeSimulatorImpl> (Simulator::GetImplementation ())->
-        ScheduleRealtimeNow (
-          MakeEvent (&EmuNetDevice::ForwardUp, this, buf, len));
-
-      ...
-    }
-@end verbatim
-
-The line starting with our templated DynamicCast function probably deserves a 
-comment.  It gains access to the simulator implementation object using
-the @code{Simulator::GetImplementation} method and then casts to the real-time
-simulator implementation to use the real-time schedule method 
-@code{ScheduleRealtimeNow}.  This function will cause a handler for the  newly
-received packet to be scheduled for execution at the current real time clock 
-value.  This will, in turn cause the simulation clock to be advanced to that 
-real time value when the scheduled event (@code{EmuNetDevice::ForwardUp}) is
-fired.
-
-The @code{ForwardUp} function operates as most other similar ns-3 net device 
-methods do.  The packet is first filtered based on the destination address.  In 
-the case of the @code{Emu} device, the MAC destination address will be the 
-address of the @code{Emu} device and not the hardware address of the real 
-device.  Headers are then stripped off and the trace hooks are hit.  Finally,
-the packet is passed up the ns-3 protocol stack using the receive callback 
-function of the net device.
-
-Sending a packet is equally straightforward as shown below.  The first thing
-we do is to add the ethernet header and trailer to the ns-3 @code{Packet} we
-are sending.  The source address corresponds to the address of the @code{Emu}
-device and not the underlying native device MAC address.  This is where the
-MAC address spoofing is done.  The trailer is added and we enqueue and dequeue
-the packet from the net device queue to hit the trace hooks.
-
-@verbatim
-  header.SetSource (source);
-  header.SetDestination (destination);
-  header.SetLengthType (packet->GetSize ());
-  packet->AddHeader (header);
-
-  EthernetTrailer trailer;
-  trailer.CalcFcs (packet);
-  packet->AddTrailer (trailer);
-
-  m_queue->Enqueue (packet);
-  packet = m_queue->Dequeue ();
-
-  struct sockaddr_ll ll;
-  bzero (&ll, sizeof (ll));
-
-  ll.sll_family = AF_PACKET;
-  ll.sll_ifindex = m_sll_ifindex;
-  ll.sll_protocol = htons(ETH_P_ALL);
-
-  rc = sendto (m_sock, packet->PeekData (), packet->GetSize (), 0, 
-    reinterpret_cast<struct sockaddr *> (&ll), sizeof (ll));
-@end verbatim
-
-
-Finally, we simply send the packet to the raw socket which puts it out on the 
-real network.
-
-@subsection Tap Net Device
-
-The @code{Tap} Net Device is scheduled for inclusion in ns-3.4 at the writing
-of this section.  We will include details as soon as the @code{Tap} device is
-merged.
-

doc/manual/flow-monitor.texi

@@ -0,0 +1,10 @@
+@node Flow Monitor
+@chapter Flow Monitor
+
+@cartouche
+Placeholder chapter
+@end cartouche
+
+This feature was added as contributed code (@code{src/contrib}) in ns-3.6.
+A paper on this feature is published in the proceedings of NSTools: @*
+@uref{http://www.nstools.org/techprog.shtml,,http://www.nstools.org/techprog.shtml}