update fixed bug list

To override the C++ virtual method 'DoStart', we new define a method in Python called 'DoStart', whilst before we would define '_DoStart'.  This change is to align pybindgen generated bindings with the other python bindings tools out there, such as boost.python, swig, and sip.  It is also simpler to understand for users.

.hgtags

@@ -43,3 +43,5 @@ c975274c9707b1f07d94cc51f205c351122131a5 ns-3.5
 d55c479666ac6be0575fac695ddf355c0530e0dd ns-3.6
 892efc87a1518fb69b04628c779195aee139d33e ns-3.7-RC3
 17bf6ee332baaa6b6f9b8a26d29c98f4e715648f ns-3.7-RC4
+be3fb855c65a46d22a7693cd156f154f63602e8e ns-3.7
+e61ce382fcdd5363a9d0052601c5eeae6f5e8d81 ns-3.8-RC1

AUTHORS

@@ -1,4 +1,5 @@
 Kirill Andreev (andreev@iitp.ru)
+Dean Armstrong (deanarm@gmail.com)
 Nicola Baldo (nbaldo@cttc.es)
 Mirko Banchi (mk.banchi@gmail.com)
 Ramon Bauza (monbauza@gmail.com)
@@ -6,18 +7,25 @@ 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)
+Dan Broyles (muxman@sbcglobal.net)
 Jonathan Brugge (j.d.brugge@student.utwente.nl)
 Elena Buchatskaia (borovkovaes@iitp.ru)
 Gustavo Carneiro (gjc@inescporto.pt, gjcarneiro@gmail.com)
 Angelos Chatzipapas (chatzipa@ceid.upatras.gr)
 Luis Cortes (cortes@gatech.edu)
+Andrey Churin (aachurin@gmail.com)
 Craig Dowell (craigdo@ee.washington.edu)
+Jahanzeb Farooq (Jahanzeb.Farooq@sophia.inria.fr, Fahanzeb.Farooq@gmail.com)
+Juliana Freitag Borin (juliana.freitag@gmail.com)
+Charline Taibi Guguen (charline.guguen@gmail.com)
+Tom Goff (tgoff@tgoff.net)
 David Gross (gdavid.devel@gmail.com)
-Mohamed Amine Ismail (amine.ismail@sophia.inria.fr, iamine@udcast.com)
 Tom Henderson (tomhend@u.washington.edu)
+Mohamed Amine Ismail (amine.ismail@sophia.inria.fr, iamine@udcast.com)
 Sam Jansen (sam.jansen@gmail.com)
 Liu Jian (liujatp@gmail.com)
 Joe Kopena (tjkopena@cs.drexel.edu)
+Flavio Kobuta (flaviokubota@gmail.com)
 Aleksey Kovalenko (kovalenko@iitp.ru)
 Mathieu Lacage (mathieu.lacage@sophia.inria.fr)
 Emmanuelle Laprise (emmmanuelle.laprise@bluekazoo.ca)
@@ -31,20 +39,26 @@ Faker Moatamri (faker.moatamri@sophia.inria.fr)
 Michael Nowatkowski (nowatkom@gmail.com)
 Duy Nguyen (duy@soe.ucsc.edu)
 Tommaso Pecorella (tommaso.pecorella@unifi.it)
+Josh Pelkey (jpelkey@gatech.edu)
+Giuseppe Piro (g.piro@poliba.it)
 Yana Podkosova (yanapdk@rambler.ru)
 Guangyu Pei (guangyu.pei@boeing.com)
 George F. Riley (riley@ece.gatech.edu)
+Bill Roome (wdr@bell-labs.com)
 Providence Salumu Munga (Providence.Salumu@gmail.com, Providence.Salumu_Munga@it-sudparis.eu)
+Florian Schmidt (Florian.Schmidt@cs.rwth-aachen.de)
 Guillaume Seguin (guillaume.seguin@sophia.inria.fr)
 Kulin Shah (m.kulin@gmail.com)
 Phillip Sitbon (phillip.sitbon@gmail.com)
 Ewgenij Starostin (estar@cs.tu-berlin.de)
+Lalith Suresh  (suresh.lalith@gmail.com)
 Adrian S. W. Tam (adrian.sw.tam@gmail.com)
+Hajime Tazaki (tazaki@sfc.wide.ad.jp)
 Wilson Thong (wilsonwk@ee.cityu.edu.hk)
 Mauro Tortonesi (mauro.tortonesi@unife.it)
 Andras Varga (andras@omnetpp.org)
 Sebastien Vincent (vincent@clarinet.u-strasbg.fr)
 Guillaume Vu-Brugier (gvubrugier@gmail.com)
 Tom Wambold (tom5760@gmail.com)
+Danqi Wang (beyondwdq@gmail.com)
 Florian Westphal (fw@strlen.de)
-Josh Pelkey (jpelkey@gatech.edu)

CHANGES.html

@@ -43,6 +43,159 @@ 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.7 to ns-3.8</h1>
+
+<h2>Changes to build system:</h2>
+
+<h2>New API:</h2>
+
+<ul>
+<li><b>Matrix propagation loss model:</b> This radio propagation model uses a two-dimensional matrix
+of path loss indexed by source and destination nodes.
+
+<li><b>WiMAX net device</b>: The developed WiMAX model attempts to provide an accurate MAC and
+PHY level implementation of the 802.16 specification with the Point-to-Multipoint (PMP) mode and the WirelessMAN-OFDM 
+PHY layer. By adding WimaxNetDevice objects to ns-3 nodes, one can create models of
+802.16-based networks. The source code for the WiMAX models lives in the directory src/devices/wimax.
+The model is mainly composed of three layers:
+<ul>
+<li>The convergence sublayer (CS)
+<li>The MAC Common Part Sublayer (MAC-CPS)
+<li>The Physical layer
+</ul>
+The main way that users who write simulation scripts will typically
+interact with the Wimax models is through the helper API and through
+the publicly visible attributes of the model.
+The helper API is defined in src/helper/wimax-helper.{cc,h}.
+Three examples containing some code that shows how to setup a 802.16 network are located under examples/wimax/ 
+
+<li><b>MPI Interface for distributed simulation:</b> Enables access
+to necessary MPI information such as MPI rank and size.
+
+<li><b>Point-to-point remote channel:</b> Enables point-to-point 
+connection between net-devices on different simulators, for use 
+with distributed simulation.
+
+<li><b>GetSystemId in simulator:</b> For use with distributed 
+simulation, GetSystemId returns zero by non-distributed 
+simulators.  For the distributed simulator, it returns the 
+MPI rank.
+
+<li><b>Enhancements to src/core/random-variable.cc/h:</b> New Zeta random variable generator. The Zeta random 
+distribution is tightly related to the Zipf distribution (already in ns-3.7). See the documentation, 
+especially because sometimes the Zeta distribution is called Zipf and viceversa. Here we conform to the 
+Wikipedia naming convention, i.e., Zipf is bounded while Zeta isn't. 
+
+<li><b>Two-ray ground propagation loss model:</b> Calculates the crossover distance under which Friis is used. The antenna 
+height is set to the nodes z coordinate, but can be added to using the model parameter SetHeightAboveZ, which 
+will affect ALL stations
+
+<li><b>Pareto random variable</b> has two new constructors to specify scale and shape:
+<pre>
+ParetoVariable (std::pair<double, double> params);
+ParetoVariable (std::pair<double, double> params, double b);
+</pre>
+</ul>
+
+<h2>Changes to existing API:</h2>
+<ul>
+<li><b>Tracing Helpers</b>: The organization of helpers for both pcap and ascii
+tracing, in devices and protocols, has been reworked.  Instead of each device 
+and protocol helper re-implementing trace enable methods, classes have been 
+developed to implement user-level tracing in a consistent way; and device and 
+protocol helpers use those classes to provide tracing functionality.<br>
+In addition to consistent operation across all helpers, the object name service
+has been integrated into the trace file naming scheme.<br>
+The internet stack helper has been extensively massaged to make it easier to 
+manage traces originating from protocols.  It used to be the case that there 
+was essentially no opportunity to filter tracing on interfaces, and resulting
+trace file names collided with those created by devices.  File names are now
+disambiguated and one can enable traces on a protocol/interface basis analogously
+to the node/device granularity of device-based helpers.<br>
+The primary user-visible results of this change are that trace-related functions
+have been changed from static functions to method calls; and a new object has
+been developed to hold streams for ascii traces.<br>
+New functionality is present for ascii traces.  It is now possible to create
+multiple ascii trace files automatically just as was possible for pcap trace 
+files.<br>
+The implementation of the helper code has been designed also to provide 
+functionality to make it easier for sophisticated users to hook traces of 
+various kinds and write results to (file) streams.
+Before:
+<pre>
+  CsmaHelper::EnablePcapAll ();
+
+  std::ofstream ascii;
+  ascii.open ("csma-one-subnet.tr", std::ios_base::binary | std::ios_base::out);
+  CsmaHelper::EnableAsciiAll (ascii);
+
+  InternetStackHelper::EnableAsciiAll (ascii);
+</pre>
+After:
+<pre>
+  CsmaHelper csmaHelper;
+  InternetStackHelper stack;
+  csmaHelper.EnablePcapAll ();
+
+  AsciiTraceHelper ascii;
+  csma.EnableAsciiAll (ascii.CreateFileStream ("csma-one-subnet.tr"));
+
+  stack.EnableAsciiIpv4All (stream);
+</pre>
+
+
+<li><b>Serialization and Deserialization</b> in buffer, nix-vector, 
+packet-metadata, and packet has been modified to use raw character 
+buffers, rather than the Buffer class
+<pre>
++ uint32_t Buffer::GetSerializedSize (void) const;
++ uint32_t Buffer::Serialize (uint8_t* buffer, uint32_t maxSize) const;
++ uint32_t Buffer::Deserialize (uint8_t* buffer, uint32_t size); 
+
+- void NixVector::Serialize (Buffer::Iterator i, uint32_t size) const;
++ uint32_t NixVector::Serialize (uint32_t* buffer, uint32_t maxSize) const;
+- uint32_t NixVector::Deserialize (Buffer::Iterator i);
++ uint32_t NixVector::Deserialize (uint32_t* buffer, uint32_t size);
+
+- void PacketMetadata::Serialize (Buffer::Iterator i, uint32_t size) const;
++ uint32_t PacketMetadata::Serialize (uint8_t* buffer, uint32_t maxSize) const;
+- uint32_t PacketMetadata::Deserialize (Buffer::Iterator i);
++ uint32_t PacketMetadata::Deserialize (uint8_t* buffer, uint32_t size);
+
++ uint32_t Packet::GetSerializedSize (void) const;
+- Buffer Packet::Serialize (void) const;
++ uint32_t Packet::Serialize (uint8_t* buffer, uint32_t maxSize) const;
+- void Packet::Deserialize (Buffer buffer);
++ Packet::Packet (uint8_t const*buffer, uint32_t size, bool magic);
+</pre>
+<li><b>PacketMetadata uid</b> has been changed to a 64-bit value. The 
+lower 32 bits give the uid, while the upper 32-bits give the MPI rank 
+for distributed simulations. For non-distributed simulations, the 
+upper 32 bits are simply zero.
+<pre>
+- inline PacketMetadata (uint32_t uid, uint32_t size);
++ inline PacketMetadata (uint64_t uid, uint32_t size);
+- uint32_t GetUid (void) const;
++ uint64_t GetUid (void) const;
+- PacketMetadata::PacketMetadata (uint32_t uid, uint32_t size);
++ PacketMetadata::PacketMetadata (uint64_t uid, uint32_t size); 
+
+- uint32_t Packet::GetUid (void) const;
++ uint64_t Packet::GetUid (void) const;
+</pre>
+
+<li><b>Moved propagation models</b> from src/devices/wifi to src/common
+
+<li><b>Moved Mtu attribute from base class NetDevice</b> This attribute is
+now found in all NetDevice subclasses.  
+</ul>
+
+<h2>Changed behavior:</h2>
+<ul>
+
+</ul>
+
 <hr>
 <h1>Changes from ns-3.6 to ns-3.7</h1>
 
@@ -64,7 +217,7 @@ event with a context different from the execution context of the caller. This AP
 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, 
+<li><b>Ad 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>
@@ -1019,7 +1172,7 @@ buffer.
 In the case of a receiver window collapse, when a advertised zero-window
 packet is received, the sender enters the persist probing state in which
 it sends probe packets with one payload byte at exponentially backed-off
-intervals up to 60s.  The reciever will continue to send advertised 
+intervals up to 60s.  The receiver will continue to send advertised 
 zero-window ACKs of the old data so long as the receiver buffer remains full.
 When the receiver window clears up due to an application read, the TCP
 will finally ACK the probe byte, and update its advertised window appropriately.

RELEASE_NOTES

@@ -9,6 +9,146 @@ 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.8
+===========
+
+Availability
+------------
+This release is not yet available.
+
+Supported platforms
+-------------------
+ns-3.8 has been tested on the following platforms:
+  - linux x86 gcc 4.4.0, 4.3.2, 4.2, 4.1.1, 4.1 and 3.4.6 (debug and optimized)
+  - linux x86_64 gcc 4.4.0, 4.3.2, 4.2.4, 4.2.3, 4.2.1, 4.1.3, 3.4.6 (debug and optimized)
+  - MacOS X ppc gcc 4.0.x and 4.2.x (debug and optimized)
+  - cygwin gcc 3.4.4 (debug only), gcc 4.3.2 (debug and optimized)
+
+Unofficially supported platform
+-------------------
+- mingw gcc 3.4.5 (debug only)
+
+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) WiMAX net device: Allow to simulated IEEE 802.16 point to multi-point based networks 
+
+  b) Distributed simulation for point-to-point networks using the Message 
+     Passing Interface (MPI) standard.
+    
+  c) Matrix propagation loss model uses a two-dimensional matrix of path loss indexed 
+     by source and destination nodes.
+
+  d) Topology read system: Allows quick and easy creation of large topologies by reading 
+     Inet or Orbis files
+
+  e) Gauss-Markov mobility model: Adds 3-d adaptation of Gauss-Markov mobility model which 
+     has both memory and variability
+
+  f) Steady-state random waypoint mobility model: Based on random waypoint mobility (RWM) model for case when 
+     speed, pause and position are uniformly distributed random variables. However, initial values of these 
+     parameters are not from uniform distribution but from stationary distribution of RWM model.
+
+  g) Two-ray ground propagation loss model: Calculates the crossover distance under which Friis is used. 
+     The antenna height is set to the nodes z coordinate, but can be added to using the model parameter 
+     SetHeightAboveZ, which will affect ALL stations
+
+
+API changes from ns-3.7
+-----------------------
+API changes for this release are documented in the file CHANGES.html. 
+
+Bugs fixed
+----------
+The following lists many of the bugs that were fixed since ns-3.7, in
+many cases referencing the Bugzilla bug number
+   - bug 155 - std::ostream & os" parameters not Python friendly
+   - bug 184 - GtkConfigStore do not support ConfigureDefault
+   - bug 407 - OLSR is missing HNA support
+   - bug 414 - No ReceiveErrorModel in SimpleNetDevice
+   - bug 602 - WifiRemoteStation lacks information about the access class of outgoing packets
+   - bug 622 - [PATCH] Friendly names for pcap traces
+   - bug 683 - Helper methods for pcap tracing with explicit filenames
+   - bug 706 - Backoff counting when starting NS.
+   - bug 720 - TapBridge creation fails from a script outside the ns3 tree
+   - bug 731 - Send function in point-to-point-net-device fails to check the return value of the Dequeue function
+   - bug 747 - Listening TCP socket closes on RST
+   - bug 748 - Cloned TCP socket uses wrong source address
+   - bug 772 - AODV is unable to correctly buffer packets waiting for route reply
+   - bug 777 - AODV ignores specified outgoing interface in RouteOutput()
+   - bug 778 - OLSR ignores specified outgoing interface in RouteOutput()
+   - bug 787 - Addition of Two Ray Ground model to propagation loss model and tests
+   - bug 788 - OLSR_NEIGH_HOLD_TIME should be 3 times OLSR_REFRESH_INTERVAL 
+   - bug 789 - [PATCH] Globalrouting externalroutes to use the new GetRootExitDirections()
+   - bug 794 - Ipv4Mask constructor for "/yy"-notation is wrong
+   - bug 796 - TCP bug in ns-3-dev branch : Crash detected during retesting of Chord on ns-3-dev branch
+   - bug 797 - Enhancements to src/core/random-variable.cc/h
+   - bug 801 - ns-3.7 and SVN not coexisting nicely
+   - bug 802 - Minstrel algorithm causes segmentation fault
+   - bug 804 - null-pointer references in 3.7 internet stack
+   - bug 806 - TCP doesn't work over a CSMA link
+   - bug 807 - ns2-mobility-helper.cc: node id parsed wrong
+   - bug 809 - Missing Python binding for Ipv4GlobalRouting::GetRoute
+   - bug 810 - In TCP, Socket::GetSockName() does not return the local socket address
+   - bug 812 - Assert when getting socket in RecvReply for AODV
+   - bug 813 - Nqos AP sends packet to non associated STA
+   - bug 814 - Function logging causing assert in wireless examples
+   - bug 815 - waf shell file descriptor leak
+   - bug 816 - tap-creator deadlock when python bindings enabled
+   - bug 817 - Pareto rng constructors using scale and shape instead of mean and shape
+   - bug 818 - TCP Socket implementation does not set ACK flag on retransmits
+   - bug 819 - Build break when gtk not installed
+   - bug 820 - Bad things happen in test.py when logging is enabled
+   - bug 821 - AODV asserts with function logging enabled
+   - bug 822 - Move Mtu attribute from NetDevice base class to subclasses
+   - bug 825 - UDP-Client-server's packet loss counter not properly reset
+   - bug 828 - PacketSocket::Close does not unregister protocol handler
+   - bug 829 - TCP unbound memory problem (pending data)
+   - bug 833 - OnOffApplication with PacketSocket: sniffs all traffic
+   - bug 834 - Incorrect signature of Ipv4FlowProbe::DropLogger
+   - bug 835 - Unlimited receive queues in sockets == evil
+   - bug 836 - Delay is incremented over time with BsUplinkSchedulerSimple and BsUplinkSchedulerRtps
+   - bug 838 - ns-3 can't compile on MacOS with 32bit processor
+   - bug 839 - TestSuite wimax-ss-mac-layer crashes on Darwin 9.8.0 Power Macintosh
+   - bug 840 - BS scheduler does not support fragmentation for UGS flows
+   - bug 841 - Multicast transmission breaks with QoS Wifi
+   - bug 844 - YansWifiPhy::GetPowerDbm off-by-one problem when calculating Tx power
+   - bug 847 - Segfaults on BaseStationNetDevice with OnOffApplication and rtPS sched
+   - bug 849 - stray patch files in lwip directory
+   - bug 850 - Ipv4GlobalRouting::LookupGlobal bug
+   - bug 855 - waf dies badly when switching from debug to optimized build or vice versa
+   - bug 856 - initialize vbl
+   - bug 857 - Link-Local Multicast handle in Ipv4 Output processing 
+   - bug 859 - Output interface estimation for the source address bound socket in IPv4 Raw socket
+   - bug 860 - waf sometimes dies while executing ns3header or gen_ns3_module_header tasks in case of 
+               parallel jobs
+   - bug 862 - NotifyInterfaceUp() Adds network route even when netmask is /32
+   - bug 863 - Wrong Scalar arithmetics
+   - bug 864 - Invalid return value in UdpSocketImpl::Send and Ipv4RawSocketImpl::Send
+   - bug 865 - Ipv4RawSocketImpl::RecvFrom does not return from address all the time.
+   - bug 866 - WiMAX mobility models not aggregated to Node
+   - bug 867 - Minor bug in Ipv4L3Protocol::Send()
+   - bug 868 - invalid packet size after Ipv4L3Protocol::Send
+   - bug 872 - ns3::PcapFileWrapper::Write explodes stack
+   - bug 873 - Queue occupancy counter not decremented in WifiMacQueue::Remove()
+   - bug 876 - Tcp socket does not handle ShutdownRecv correctly
+   - bug 877 - python bindings broken with multiple inheritance ?
+   - bug 880 - Node sending a packet to itself via 127.0.0.1 aborts
+   - bug 885 - Error in Ascii tracing in Python examples
+   - bug 891 - WiMAX device helper does not include propagation loss model by default 
+   - bug 894 - ./waf --run error message upon segfault
+
+Known issues
+------------
+ns-3 builds have been 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.7
 ===========
 

VERSION

@@ -1 +1 @@
-3.7
+3-dev

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

@@ -1,6 +1,7 @@
 callback_classes = [
     ['void', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['bool', 'ns3::Ptr<ns3::Packet>', 'ns3::Address const&', 'ns3::Address const&', 'unsigned short', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
+    ['void', 'ns3::Ptr<ns3::PacketBurst const>', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['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'],
@@ -10,8 +11,11 @@ callback_classes = [
     ['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'],
+    ['void', 'bool', 'unsigned long long', '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::Mac48Address', 'unsigned char', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
+    ['void', 'ns3::Mac48Address', 'unsigned char', 'bool', 'ns3::empty', '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'],

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

@@ -387,6 +387,11 @@ def register_Ns3AodvRerrHeader_methods(root_module, cls):
                    'uint32_t', 
                    [], 
                    is_const=True, is_virtual=True)
+    ## aodv-packet.h: static ns3::TypeId ns3::aodv::RerrHeader::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## aodv-packet.h: void ns3::aodv::RerrHeader::Print(std::ostream & os) const [member function]
     cls.add_method('Print', 
                    'void', 
@@ -535,6 +540,10 @@ def register_Ns3AodvRoutingTable_methods(root_module, cls):
     cls.add_method('LookupRoute', 
                    'bool', 
                    [param('ns3::Ipv4Address', 'dst'), param('ns3::aodv::RoutingTableEntry &', 'rt')])
+    ## aodv-rtable.h: bool ns3::aodv::RoutingTable::LookupValidRoute(ns3::Ipv4Address dst, ns3::aodv::RoutingTableEntry & rt) [member function]
+    cls.add_method('LookupValidRoute', 
+                   'bool', 
+                   [param('ns3::Ipv4Address', 'dst'), param('ns3::aodv::RoutingTableEntry &', 'rt')])
     ## aodv-rtable.h: bool ns3::aodv::RoutingTable::MarkLinkAsUnidirectional(ns3::Ipv4Address neighbor, ns3::Time blacklistTimeout) [member function]
     cls.add_method('MarkLinkAsUnidirectional', 
                    'bool', 
@@ -744,6 +753,11 @@ def register_Ns3AodvRrepAckHeader_methods(root_module, cls):
                    'uint32_t', 
                    [], 
                    is_const=True, is_virtual=True)
+    ## aodv-packet.h: static ns3::TypeId ns3::aodv::RrepAckHeader::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## aodv-packet.h: void ns3::aodv::RrepAckHeader::Print(std::ostream & os) const [member function]
     cls.add_method('Print', 
                    'void', 
@@ -813,6 +827,11 @@ def register_Ns3AodvRrepHeader_methods(root_module, cls):
                    'uint32_t', 
                    [], 
                    is_const=True, is_virtual=True)
+    ## aodv-packet.h: static ns3::TypeId ns3::aodv::RrepHeader::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## aodv-packet.h: void ns3::aodv::RrepHeader::Print(std::ostream & os) const [member function]
     cls.add_method('Print', 
                    'void', 
@@ -894,9 +913,9 @@ def register_Ns3AodvRreqHeader_methods(root_module, cls):
                    'uint8_t', 
                    [], 
                    is_const=True)
-    ## aodv-packet.h: uint8_t ns3::aodv::RreqHeader::GetId() const [member function]
+    ## aodv-packet.h: uint32_t ns3::aodv::RreqHeader::GetId() const [member function]
     cls.add_method('GetId', 
-                   'uint8_t', 
+                   'uint32_t', 
                    [], 
                    is_const=True)
     ## aodv-packet.h: ns3::TypeId ns3::aodv::RreqHeader::GetInstanceTypeId() const [member function]
@@ -919,6 +938,11 @@ def register_Ns3AodvRreqHeader_methods(root_module, cls):
                    'uint32_t', 
                    [], 
                    is_const=True, is_virtual=True)
+    ## aodv-packet.h: static ns3::TypeId ns3::aodv::RreqHeader::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## aodv-packet.h: bool ns3::aodv::RreqHeader::GetUnknownSeqno() const [member function]
     cls.add_method('GetUnknownSeqno', 
                    'bool', 
@@ -999,6 +1023,11 @@ def register_Ns3AodvTypeHeader_methods(root_module, cls):
                    'uint32_t', 
                    [], 
                    is_const=True, is_virtual=True)
+    ## aodv-packet.h: static ns3::TypeId ns3::aodv::TypeHeader::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## aodv-packet.h: bool ns3::aodv::TypeHeader::IsValid() const [member function]
     cls.add_method('IsValid', 
                    'bool', 

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

@@ -47,28 +47,56 @@ def register_types(module):
     module.add_class('Chunk', parent=root_module['ns3::ObjectBase'])
     ## 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'))
+    ## pcap-file-wrapper.h: ns3::PcapFileWrapper [class]
+    module.add_class('PcapFileWrapper', parent=root_module['ns3::Object'])
+    ## propagation-delay-model.h: ns3::PropagationDelayModel [class]
+    module.add_class('PropagationDelayModel', parent=root_module['ns3::Object'])
+    ## propagation-loss-model.h: ns3::PropagationLossModel [class]
+    module.add_class('PropagationLossModel', parent=root_module['ns3::Object'])
+    ## propagation-delay-model.h: ns3::RandomPropagationDelayModel [class]
+    module.add_class('RandomPropagationDelayModel', parent=root_module['ns3::PropagationDelayModel'])
+    ## propagation-loss-model.h: ns3::RandomPropagationLossModel [class]
+    module.add_class('RandomPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> > [class]
+    module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::OutputStreamWrapper', 'ns3::empty', 'ns3::DefaultDeleter<ns3::OutputStreamWrapper>'], 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'))
+    ## propagation-loss-model.h: ns3::ThreeLogDistancePropagationLossModel [class]
+    module.add_class('ThreeLogDistancePropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
     ## 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'])
+    ## propagation-loss-model.h: ns3::TwoRayGroundPropagationLossModel [class]
+    module.add_class('TwoRayGroundPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
+    ## propagation-delay-model.h: ns3::ConstantSpeedPropagationDelayModel [class]
+    module.add_class('ConstantSpeedPropagationDelayModel', parent=root_module['ns3::PropagationDelayModel'])
+    ## cost231-propagation-loss-model.h: ns3::Cost231PropagationLossModel [class]
+    module.add_class('Cost231PropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
+    ## cost231-propagation-loss-model.h: ns3::Cost231PropagationLossModel::Environment [enumeration]
+    module.add_enum('Environment', ['SubUrban', 'MediumCity', 'Metropolitan'], outer_class=root_module['ns3::Cost231PropagationLossModel'])
     ## 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'])
+    ## propagation-loss-model.h: ns3::FixedRssLossModel [class]
+    module.add_class('FixedRssLossModel', parent=root_module['ns3::PropagationLossModel'])
+    ## propagation-loss-model.h: ns3::FriisPropagationLossModel [class]
+    module.add_class('FriisPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
+    ## jakes-propagation-loss-model.h: ns3::JakesPropagationLossModel [class]
+    module.add_class('JakesPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
     ## error-model.h: ns3::ListErrorModel [class]
     module.add_class('ListErrorModel', parent=root_module['ns3::ErrorModel'])
+    ## propagation-loss-model.h: ns3::LogDistancePropagationLossModel [class]
+    module.add_class('LogDistancePropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
+    ## propagation-loss-model.h: ns3::MatrixPropagationLossModel [class]
+    module.add_class('MatrixPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
+    ## propagation-loss-model.h: ns3::NakagamiPropagationLossModel [class]
+    module.add_class('NakagamiPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
     ## nix-vector.h: ns3::NixVector [class]
     module.add_class('NixVector', parent=root_module['ns3::Object'])
+    ## output-stream-wrapper.h: ns3::OutputStreamWrapper [class]
+    module.add_class('OutputStreamWrapper', parent=root_module['ns3::SimpleRefCount< ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> >'])
     ## 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]
@@ -175,14 +203,28 @@ def register_methods(root_module):
     register_Ns3TagBuffer_methods(root_module, root_module['ns3::TagBuffer'])
     register_Ns3Chunk_methods(root_module, root_module['ns3::Chunk'])
     register_Ns3Header_methods(root_module, root_module['ns3::Header'])
-    register_Ns3PcapWriter_methods(root_module, root_module['ns3::PcapWriter'])
+    register_Ns3PcapFileWrapper_methods(root_module, root_module['ns3::PcapFileWrapper'])
+    register_Ns3PropagationDelayModel_methods(root_module, root_module['ns3::PropagationDelayModel'])
+    register_Ns3PropagationLossModel_methods(root_module, root_module['ns3::PropagationLossModel'])
+    register_Ns3RandomPropagationDelayModel_methods(root_module, root_module['ns3::RandomPropagationDelayModel'])
+    register_Ns3RandomPropagationLossModel_methods(root_module, root_module['ns3::RandomPropagationLossModel'])
+    register_Ns3ThreeLogDistancePropagationLossModel_methods(root_module, root_module['ns3::ThreeLogDistancePropagationLossModel'])
     register_Ns3Trailer_methods(root_module, root_module['ns3::Trailer'])
-    register_Ns3AsciiWriter_methods(root_module, root_module['ns3::AsciiWriter'])
+    register_Ns3TwoRayGroundPropagationLossModel_methods(root_module, root_module['ns3::TwoRayGroundPropagationLossModel'])
+    register_Ns3ConstantSpeedPropagationDelayModel_methods(root_module, root_module['ns3::ConstantSpeedPropagationDelayModel'])
+    register_Ns3Cost231PropagationLossModel_methods(root_module, root_module['ns3::Cost231PropagationLossModel'])
     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_Ns3FixedRssLossModel_methods(root_module, root_module['ns3::FixedRssLossModel'])
+    register_Ns3FriisPropagationLossModel_methods(root_module, root_module['ns3::FriisPropagationLossModel'])
+    register_Ns3JakesPropagationLossModel_methods(root_module, root_module['ns3::JakesPropagationLossModel'])
     register_Ns3ListErrorModel_methods(root_module, root_module['ns3::ListErrorModel'])
+    register_Ns3LogDistancePropagationLossModel_methods(root_module, root_module['ns3::LogDistancePropagationLossModel'])
+    register_Ns3MatrixPropagationLossModel_methods(root_module, root_module['ns3::MatrixPropagationLossModel'])
+    register_Ns3NakagamiPropagationLossModel_methods(root_module, root_module['ns3::NakagamiPropagationLossModel'])
     register_Ns3NixVector_methods(root_module, root_module['ns3::NixVector'])
+    register_Ns3OutputStreamWrapper_methods(root_module, root_module['ns3::OutputStreamWrapper'])
     register_Ns3Packet_methods(root_module, root_module['ns3::Packet'])
     register_Ns3RateErrorModel_methods(root_module, root_module['ns3::RateErrorModel'])
     return
@@ -194,6 +236,8 @@ def register_Ns3Buffer_methods(root_module, cls):
     cls.add_constructor([])
     ## buffer.h: ns3::Buffer::Buffer(uint32_t dataSize) [constructor]
     cls.add_constructor([param('uint32_t', 'dataSize')])
+    ## buffer.h: ns3::Buffer::Buffer(uint32_t dataSize, bool initialize) [constructor]
+    cls.add_constructor([param('uint32_t', 'dataSize'), param('bool', 'initialize')])
     ## buffer.h: bool ns3::Buffer::AddAtEnd(uint32_t end) [member function]
     cls.add_method('AddAtEnd', 
                    'bool', 
@@ -216,6 +260,11 @@ def register_Ns3Buffer_methods(root_module, cls):
                    'void', 
                    [param('std::ostream *', 'os'), param('uint32_t', 'size')], 
                    is_const=True)
+    ## buffer.h: uint32_t ns3::Buffer::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)
     ## buffer.h: ns3::Buffer ns3::Buffer::CreateFragment(uint32_t start, uint32_t length) const [member function]
     cls.add_method('CreateFragment', 
                    'ns3::Buffer', 
@@ -226,6 +275,10 @@ def register_Ns3Buffer_methods(root_module, cls):
                    'ns3::Buffer', 
                    [], 
                    is_const=True)
+    ## buffer.h: uint32_t ns3::Buffer::Deserialize(uint8_t * buffer, uint32_t size) [member function]
+    cls.add_method('Deserialize', 
+                   'uint32_t', 
+                   [param('uint8_t *', 'buffer'), param('uint32_t', 'size')])
     ## buffer.h: ns3::Buffer::Iterator ns3::Buffer::End() const [member function]
     cls.add_method('End', 
                    'ns3::Buffer::Iterator', 
@@ -241,6 +294,11 @@ def register_Ns3Buffer_methods(root_module, cls):
                    'int32_t', 
                    [], 
                    is_const=True)
+    ## buffer.h: uint32_t ns3::Buffer::GetSerializedSize() const [member function]
+    cls.add_method('GetSerializedSize', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## buffer.h: uint32_t ns3::Buffer::GetSize() const [member function]
     cls.add_method('GetSize', 
                    'uint32_t', 
@@ -259,6 +317,11 @@ def register_Ns3Buffer_methods(root_module, cls):
     cls.add_method('RemoveAtStart', 
                    'void', 
                    [param('uint32_t', 'start')])
+    ## buffer.h: uint32_t ns3::Buffer::Serialize(uint8_t * buffer, uint32_t maxSize) const [member function]
+    cls.add_method('Serialize', 
+                   'uint32_t', 
+                   [param('uint8_t *', 'buffer'), param('uint32_t', 'maxSize')], 
+                   is_const=True)
     return
 
 def register_Ns3BufferIterator_methods(root_module, cls):
@@ -544,8 +607,8 @@ def register_Ns3DataRate_methods(root_module, cls):
     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')])
+    ## packet-metadata.h: ns3::PacketMetadata::PacketMetadata(uint64_t uid, uint32_t size) [constructor]
+    cls.add_constructor([param('uint64_t', 'uid'), param('uint32_t', 'size')])
     ## packet-metadata.h: ns3::PacketMetadata::PacketMetadata(ns3::PacketMetadata const & o) [copy constructor]
     cls.add_constructor([param('ns3::PacketMetadata const &', 'o')])
     ## packet-metadata.h: void ns3::PacketMetadata::AddAtEnd(ns3::PacketMetadata const & o) [member function]
@@ -574,10 +637,10 @@ def register_Ns3PacketMetadata_methods(root_module, cls):
                    'ns3::PacketMetadata', 
                    [param('uint32_t', 'start'), param('uint32_t', 'end')], 
                    is_const=True)
-    ## packet-metadata.h: uint32_t ns3::PacketMetadata::Deserialize(ns3::Buffer::Iterator i) [member function]
+    ## packet-metadata.h: uint32_t ns3::PacketMetadata::Deserialize(uint8_t * buffer, uint32_t size) [member function]
     cls.add_method('Deserialize', 
                    'uint32_t', 
-                   [param('ns3::Buffer::Iterator', 'i')])
+                   [param('uint8_t *', 'buffer'), param('uint32_t', 'size')])
     ## packet-metadata.h: static void ns3::PacketMetadata::Enable() [member function]
     cls.add_method('Enable', 
                    'void', 
@@ -593,9 +656,9 @@ def register_Ns3PacketMetadata_methods(root_module, cls):
                    'uint32_t', 
                    [], 
                    is_const=True)
-    ## packet-metadata.h: uint32_t ns3::PacketMetadata::GetUid() const [member function]
+    ## packet-metadata.h: uint64_t ns3::PacketMetadata::GetUid() const [member function]
     cls.add_method('GetUid', 
-                   'uint32_t', 
+                   'uint64_t', 
                    [], 
                    is_const=True)
     ## packet-metadata.h: void ns3::PacketMetadata::RemoveAtEnd(uint32_t end) [member function]
@@ -614,10 +677,10 @@ def register_Ns3PacketMetadata_methods(root_module, cls):
     cls.add_method('RemoveTrailer', 
                    'void', 
                    [param('ns3::Trailer const &', 'trailer'), param('uint32_t', 'size')])
-    ## packet-metadata.h: void ns3::PacketMetadata::Serialize(ns3::Buffer::Iterator i, uint32_t size) const [member function]
+    ## packet-metadata.h: uint32_t ns3::PacketMetadata::Serialize(uint8_t * buffer, uint32_t maxSize) const [member function]
     cls.add_method('Serialize', 
-                   'void', 
-                   [param('ns3::Buffer::Iterator', 'i'), param('uint32_t', 'size')], 
+                   'uint32_t', 
+                   [param('uint8_t *', 'buffer'), param('uint32_t', 'maxSize')], 
                    is_const=True)
     return
 
@@ -731,10 +794,12 @@ def register_Ns3PacketTagListTagData_methods(root_module, cls):
     return
 
 def register_Ns3PcapFile_methods(root_module, cls):
-    ## pcap-file.h: ns3::PcapFile::PcapFile(ns3::PcapFile const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::PcapFile const &', 'arg0')])
     ## pcap-file.h: ns3::PcapFile::PcapFile() [constructor]
     cls.add_constructor([])
+    ## pcap-file.h: void ns3::PcapFile::Clear() [member function]
+    cls.add_method('Clear', 
+                   'void', 
+                   [])
     ## pcap-file.h: void ns3::PcapFile::Close() [member function]
     cls.add_method('Close', 
                    'void', 
@@ -744,6 +809,16 @@ def register_Ns3PcapFile_methods(root_module, cls):
                    '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: bool ns3::PcapFile::Eof() const [member function]
+    cls.add_method('Eof', 
+                   'bool', 
+                   [], 
+                   is_const=True)
+    ## pcap-file.h: bool ns3::PcapFile::Fail() const [member function]
+    cls.add_method('Fail', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## pcap-file.h: uint32_t ns3::PcapFile::GetDataLinkType() [member function]
     cls.add_method('GetDataLinkType', 
                    'uint32_t', 
@@ -776,22 +851,30 @@ def register_Ns3PcapFile_methods(root_module, cls):
     cls.add_method('GetVersionMinor', 
                    'uint16_t', 
                    [])
-    ## pcap-file.h: bool ns3::PcapFile::Init(uint32_t dataLinkType, uint32_t snapLen=ns3::PcapFile::SNAPLEN_DEFAULT, int32_t timeZoneCorrection=ns3::PcapFile::ZONE_DEFAULT, bool swapMode=false) [member function]
+    ## pcap-file.h: void ns3::PcapFile::Init(uint32_t dataLinkType, uint32_t snapLen=ns3::PcapFile::SNAPLEN_DEFAULT, int32_t timeZoneCorrection=ns3::PcapFile::ZONE_DEFAULT, bool swapMode=false) [member function]
     cls.add_method('Init', 
-                   'bool', 
+                   'void', 
                    [param('uint32_t', 'dataLinkType'), param('uint32_t', 'snapLen', default_value='ns3::PcapFile::SNAPLEN_DEFAULT'), param('int32_t', 'timeZoneCorrection', default_value='ns3::PcapFile::ZONE_DEFAULT'), param('bool', 'swapMode', default_value='false')])
-    ## pcap-file.h: bool ns3::PcapFile::Open(std::string const & filename, std::string const & mode) [member function]
+    ## pcap-file.h: void ns3::PcapFile::Open(std::string const & filename, std::_Ios_Openmode mode) [member function]
     cls.add_method('Open', 
-                   'bool', 
-                   [param('std::string const &', 'filename'), param('std::string const &', 'mode')])
-    ## pcap-file.h: bool ns3::PcapFile::Read(uint8_t * const data, uint32_t maxBytes, uint32_t & tsSec, uint32_t & tsUsec, uint32_t & inclLen, uint32_t & origLen, uint32_t & readLen) [member function]
+                   'void', 
+                   [param('std::string const &', 'filename'), param('std::_Ios_Openmode', 'mode')])
+    ## pcap-file.h: void ns3::PcapFile::Read(uint8_t * const data, uint32_t maxBytes, uint32_t & tsSec, uint32_t & tsUsec, uint32_t & inclLen, uint32_t & origLen, uint32_t & readLen) [member function]
     cls.add_method('Read', 
-                   'bool', 
+                   'void', 
                    [param('uint8_t * const', 'data'), param('uint32_t', 'maxBytes'), param('uint32_t &', 'tsSec'), param('uint32_t &', 'tsUsec'), param('uint32_t &', 'inclLen'), param('uint32_t &', 'origLen'), param('uint32_t &', 'readLen')])
-    ## pcap-file.h: bool ns3::PcapFile::Write(uint32_t tsSec, uint32_t tsUsec, uint8_t const * const data, uint32_t totalLen) [member function]
+    ## pcap-file.h: void ns3::PcapFile::Write(uint32_t tsSec, uint32_t tsUsec, uint8_t const * const data, uint32_t totalLen) [member function]
     cls.add_method('Write', 
-                   'bool', 
+                   'void', 
                    [param('uint32_t', 'tsSec'), param('uint32_t', 'tsUsec'), param('uint8_t const * const', 'data'), param('uint32_t', 'totalLen')])
+    ## pcap-file.h: void ns3::PcapFile::Write(uint32_t tsSec, uint32_t tsUsec, ns3::Ptr<ns3::Packet const> p) [member function]
+    cls.add_method('Write', 
+                   'void', 
+                   [param('uint32_t', 'tsSec'), param('uint32_t', 'tsUsec'), param('ns3::Ptr< ns3::Packet const >', 'p')])
+    ## pcap-file.h: void ns3::PcapFile::Write(uint32_t tsSec, uint32_t tsUsec, ns3::Header & header, ns3::Ptr<ns3::Packet const> p) [member function]
+    cls.add_method('Write', 
+                   'void', 
+                   [param('uint32_t', 'tsSec'), param('uint32_t', 'tsUsec'), param('ns3::Header &', 'header'), param('ns3::Ptr< ns3::Packet const >', 'p')])
     ## pcap-file.h: ns3::PcapFile::SNAPLEN_DEFAULT [variable]
     cls.add_static_attribute('SNAPLEN_DEFAULT', 'uint32_t const', is_const=True)
     ## pcap-file.h: ns3::PcapFile::ZONE_DEFAULT [variable]
@@ -948,56 +1031,168 @@ def register_Ns3Header_methods(root_module, cls):
                    is_pure_virtual=True, is_const=True, is_virtual=True)
     return
 
-def register_Ns3PcapWriter_methods(root_module, cls):
-    ## pcap-writer.h: ns3::PcapWriter::PcapWriter(ns3::PcapWriter const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::PcapWriter const &', 'arg0')])
-    ## pcap-writer.h: ns3::PcapWriter::PcapWriter() [constructor]
-    cls.add_constructor([])
-    ## pcap-writer.h: static ns3::TypeId ns3::PcapWriter::GetTypeId() [member function]
+def register_Ns3PcapFileWrapper_methods(root_module, cls):
+    ## pcap-file-wrapper.h: static ns3::TypeId ns3::PcapFileWrapper::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
                    [], 
                    is_static=True)
-    ## pcap-writer.h: void ns3::PcapWriter::Open(std::string const & name) [member function]
+    ## pcap-file-wrapper.h: ns3::PcapFileWrapper::PcapFileWrapper() [constructor]
+    cls.add_constructor([])
+    ## pcap-file-wrapper.h: bool ns3::PcapFileWrapper::Fail() const [member function]
+    cls.add_method('Fail', 
+                   'bool', 
+                   [], 
+                   is_const=True)
+    ## pcap-file-wrapper.h: bool ns3::PcapFileWrapper::Eof() const [member function]
+    cls.add_method('Eof', 
+                   'bool', 
+                   [], 
+                   is_const=True)
+    ## pcap-file-wrapper.h: void ns3::PcapFileWrapper::Clear() [member function]
+    cls.add_method('Clear', 
+                   'void', 
+                   [])
+    ## pcap-file-wrapper.h: void ns3::PcapFileWrapper::Open(std::string const & filename, std::_Ios_Openmode mode) [member function]
     cls.add_method('Open', 
                    'void', 
-                   [param('std::string const &', 'name')])
-    ## pcap-writer.h: void ns3::PcapWriter::SetCaptureSize(uint32_t size) [member function]
-    cls.add_method('SetCaptureSize', 
-                   'void', 
-                   [param('uint32_t', 'size')])
-    ## pcap-writer.h: void ns3::PcapWriter::WriteEthernetHeader() [member function]
-    cls.add_method('WriteEthernetHeader', 
+                   [param('std::string const &', 'filename'), param('std::_Ios_Openmode', 'mode')])
+    ## pcap-file-wrapper.h: void ns3::PcapFileWrapper::Close() [member function]
+    cls.add_method('Close', 
                    'void', 
                    [])
-    ## pcap-writer.h: void ns3::PcapWriter::WriteIpHeader() [member function]
-    cls.add_method('WriteIpHeader', 
+    ## pcap-file-wrapper.h: void ns3::PcapFileWrapper::Init(uint32_t dataLinkType, uint32_t snapLen=std::numeric_limits<unsigned int>::max(), int32_t tzCorrection=ns3::PcapFile::ZONE_DEFAULT) [member function]
+    cls.add_method('Init', 
                    'void', 
+                   [param('uint32_t', 'dataLinkType'), param('uint32_t', 'snapLen', default_value='std::numeric_limits<unsigned int>::max()'), param('int32_t', 'tzCorrection', default_value='ns3::PcapFile::ZONE_DEFAULT')])
+    ## pcap-file-wrapper.h: void ns3::PcapFileWrapper::Write(ns3::Time t, ns3::Ptr<ns3::Packet const> p) [member function]
+    cls.add_method('Write', 
+                   'void', 
+                   [param('ns3::Time', 't'), param('ns3::Ptr< ns3::Packet const >', 'p')])
+    ## pcap-file-wrapper.h: void ns3::PcapFileWrapper::Write(ns3::Time t, ns3::Header & header, ns3::Ptr<ns3::Packet const> p) [member function]
+    cls.add_method('Write', 
+                   'void', 
+                   [param('ns3::Time', 't'), param('ns3::Header &', 'header'), param('ns3::Ptr< ns3::Packet const >', 'p')])
+    ## pcap-file-wrapper.h: void ns3::PcapFileWrapper::Write(ns3::Time t, uint8_t const * buffer, uint32_t length) [member function]
+    cls.add_method('Write', 
+                   'void', 
+                   [param('ns3::Time', 't'), param('uint8_t const *', 'buffer'), param('uint32_t', 'length')])
+    ## pcap-file-wrapper.h: uint32_t ns3::PcapFileWrapper::GetMagic() [member function]
+    cls.add_method('GetMagic', 
+                   'uint32_t', 
                    [])
-    ## pcap-writer.h: void ns3::PcapWriter::WritePacket(ns3::Ptr<ns3::Packet const> packet) [member function]
-    cls.add_method('WritePacket', 
-                   'void', 
-                   [param('ns3::Ptr< ns3::Packet const >', 'packet')])
-    ## pcap-writer.h: void ns3::PcapWriter::WritePppHeader() [member function]
-    cls.add_method('WritePppHeader', 
-                   'void', 
+    ## pcap-file-wrapper.h: uint16_t ns3::PcapFileWrapper::GetVersionMajor() [member function]
+    cls.add_method('GetVersionMajor', 
+                   'uint16_t', 
                    [])
-    ## pcap-writer.h: void ns3::PcapWriter::WriteWifiHeader() [member function]
-    cls.add_method('WriteWifiHeader', 
-                   'void', 
+    ## pcap-file-wrapper.h: uint16_t ns3::PcapFileWrapper::GetVersionMinor() [member function]
+    cls.add_method('GetVersionMinor', 
+                   'uint16_t', 
                    [])
-    ## pcap-writer.h: void ns3::PcapWriter::WriteWifiMonitorPacket(ns3::Ptr<ns3::Packet const> packet, uint16_t channelFreqMhz, uint16_t channelNumber, uint32_t rate, bool isShortPreamble, bool isTx, double signalDbm, double noiseDbm) [member function]
-    cls.add_method('WriteWifiMonitorPacket', 
-                   'void', 
-                   [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('uint16_t', 'channelFreqMhz'), param('uint16_t', 'channelNumber'), param('uint32_t', 'rate'), param('bool', 'isShortPreamble'), param('bool', 'isTx'), param('double', 'signalDbm'), param('double', 'noiseDbm')])
-    ## pcap-writer.h: void ns3::PcapWriter::WriteWifiPrismHeader() [member function]
-    cls.add_method('WriteWifiPrismHeader', 
-                   'void', 
+    ## pcap-file-wrapper.h: int32_t ns3::PcapFileWrapper::GetTimeZoneOffset() [member function]
+    cls.add_method('GetTimeZoneOffset', 
+                   'int32_t', 
                    [])
-    ## pcap-writer.h: void ns3::PcapWriter::WriteWifiRadiotapHeader() [member function]
-    cls.add_method('WriteWifiRadiotapHeader', 
-                   'void', 
+    ## pcap-file-wrapper.h: uint32_t ns3::PcapFileWrapper::GetSigFigs() [member function]
+    cls.add_method('GetSigFigs', 
+                   'uint32_t', 
                    [])
+    ## pcap-file-wrapper.h: uint32_t ns3::PcapFileWrapper::GetSnapLen() [member function]
+    cls.add_method('GetSnapLen', 
+                   'uint32_t', 
+                   [])
+    ## pcap-file-wrapper.h: uint32_t ns3::PcapFileWrapper::GetDataLinkType() [member function]
+    cls.add_method('GetDataLinkType', 
+                   'uint32_t', 
+                   [])
+    return
+
+def register_Ns3PropagationDelayModel_methods(root_module, cls):
+    ## propagation-delay-model.h: ns3::PropagationDelayModel::PropagationDelayModel() [constructor]
+    cls.add_constructor([])
+    ## propagation-delay-model.h: ns3::PropagationDelayModel::PropagationDelayModel(ns3::PropagationDelayModel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::PropagationDelayModel const &', 'arg0')])
+    ## propagation-delay-model.h: ns3::Time ns3::PropagationDelayModel::GetDelay(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('GetDelay', 
+                   'ns3::Time', 
+                   [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
+    ## propagation-delay-model.h: static ns3::TypeId ns3::PropagationDelayModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    return
+
+def register_Ns3PropagationLossModel_methods(root_module, cls):
+    ## propagation-loss-model.h: static ns3::TypeId ns3::PropagationLossModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## propagation-loss-model.h: ns3::PropagationLossModel::PropagationLossModel() [constructor]
+    cls.add_constructor([])
+    ## propagation-loss-model.h: void ns3::PropagationLossModel::SetNext(ns3::Ptr<ns3::PropagationLossModel> next) [member function]
+    cls.add_method('SetNext', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::PropagationLossModel >', 'next')])
+    ## propagation-loss-model.h: double ns3::PropagationLossModel::CalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('CalcRxPower', 
+                   'double', 
+                   [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True)
+    ## propagation-loss-model.h: double ns3::PropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('DoCalcRxPower', 
+                   'double', 
+                   [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
+    return
+
+def register_Ns3RandomPropagationDelayModel_methods(root_module, cls):
+    ## propagation-delay-model.h: ns3::RandomPropagationDelayModel::RandomPropagationDelayModel(ns3::RandomPropagationDelayModel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::RandomPropagationDelayModel const &', 'arg0')])
+    ## propagation-delay-model.h: ns3::RandomPropagationDelayModel::RandomPropagationDelayModel() [constructor]
+    cls.add_constructor([])
+    ## propagation-delay-model.h: ns3::Time ns3::RandomPropagationDelayModel::GetDelay(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('GetDelay', 
+                   'ns3::Time', 
+                   [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True, is_virtual=True)
+    ## propagation-delay-model.h: static ns3::TypeId ns3::RandomPropagationDelayModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    return
+
+def register_Ns3RandomPropagationLossModel_methods(root_module, cls):
+    ## propagation-loss-model.h: static ns3::TypeId ns3::RandomPropagationLossModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## propagation-loss-model.h: ns3::RandomPropagationLossModel::RandomPropagationLossModel() [constructor]
+    cls.add_constructor([])
+    ## propagation-loss-model.h: double ns3::RandomPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('DoCalcRxPower', 
+                   'double', 
+                   [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True, visibility='private', is_virtual=True)
+    return
+
+def register_Ns3ThreeLogDistancePropagationLossModel_methods(root_module, cls):
+    ## propagation-loss-model.h: static ns3::TypeId ns3::ThreeLogDistancePropagationLossModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## propagation-loss-model.h: ns3::ThreeLogDistancePropagationLossModel::ThreeLogDistancePropagationLossModel() [constructor]
+    cls.add_constructor([])
+    ## propagation-loss-model.h: double ns3::ThreeLogDistancePropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('DoCalcRxPower', 
+                   'double', 
+                   [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True, visibility='private', is_virtual=True)
     return
 
 def register_Ns3Trailer_methods(root_module, cls):
@@ -1033,18 +1228,157 @@ 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')], 
+def register_Ns3TwoRayGroundPropagationLossModel_methods(root_module, cls):
+    ## propagation-loss-model.h: static ns3::TypeId ns3::TwoRayGroundPropagationLossModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
                    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', 
+    ## propagation-loss-model.h: ns3::TwoRayGroundPropagationLossModel::TwoRayGroundPropagationLossModel() [constructor]
+    cls.add_constructor([])
+    ## propagation-loss-model.h: void ns3::TwoRayGroundPropagationLossModel::SetLambda(double frequency, double speed) [member function]
+    cls.add_method('SetLambda', 
                    'void', 
-                   [param('ns3::AsciiWriter::Type', 'type'), param('std::string', 'message'), param('ns3::Ptr< ns3::Packet const >', 'p')])
+                   [param('double', 'frequency'), param('double', 'speed')])
+    ## propagation-loss-model.h: void ns3::TwoRayGroundPropagationLossModel::SetLambda(double lambda) [member function]
+    cls.add_method('SetLambda', 
+                   'void', 
+                   [param('double', 'lambda')])
+    ## propagation-loss-model.h: void ns3::TwoRayGroundPropagationLossModel::SetSystemLoss(double systemLoss) [member function]
+    cls.add_method('SetSystemLoss', 
+                   'void', 
+                   [param('double', 'systemLoss')])
+    ## propagation-loss-model.h: void ns3::TwoRayGroundPropagationLossModel::SetMinDistance(double minDistance) [member function]
+    cls.add_method('SetMinDistance', 
+                   'void', 
+                   [param('double', 'minDistance')])
+    ## propagation-loss-model.h: double ns3::TwoRayGroundPropagationLossModel::GetMinDistance() const [member function]
+    cls.add_method('GetMinDistance', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## propagation-loss-model.h: double ns3::TwoRayGroundPropagationLossModel::GetLambda() const [member function]
+    cls.add_method('GetLambda', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## propagation-loss-model.h: double ns3::TwoRayGroundPropagationLossModel::GetSystemLoss() const [member function]
+    cls.add_method('GetSystemLoss', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## propagation-loss-model.h: void ns3::TwoRayGroundPropagationLossModel::SetHeightAboveZ(double heightAboveZ) [member function]
+    cls.add_method('SetHeightAboveZ', 
+                   'void', 
+                   [param('double', 'heightAboveZ')])
+    ## propagation-loss-model.h: double ns3::TwoRayGroundPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('DoCalcRxPower', 
+                   'double', 
+                   [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True, visibility='private', is_virtual=True)
+    return
+
+def register_Ns3ConstantSpeedPropagationDelayModel_methods(root_module, cls):
+    ## propagation-delay-model.h: ns3::ConstantSpeedPropagationDelayModel::ConstantSpeedPropagationDelayModel(ns3::ConstantSpeedPropagationDelayModel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::ConstantSpeedPropagationDelayModel const &', 'arg0')])
+    ## propagation-delay-model.h: ns3::ConstantSpeedPropagationDelayModel::ConstantSpeedPropagationDelayModel() [constructor]
+    cls.add_constructor([])
+    ## propagation-delay-model.h: ns3::Time ns3::ConstantSpeedPropagationDelayModel::GetDelay(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('GetDelay', 
+                   'ns3::Time', 
+                   [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True, is_virtual=True)
+    ## propagation-delay-model.h: double ns3::ConstantSpeedPropagationDelayModel::GetSpeed() const [member function]
+    cls.add_method('GetSpeed', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## propagation-delay-model.h: static ns3::TypeId ns3::ConstantSpeedPropagationDelayModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## propagation-delay-model.h: void ns3::ConstantSpeedPropagationDelayModel::SetSpeed(double speed) [member function]
+    cls.add_method('SetSpeed', 
+                   'void', 
+                   [param('double', 'speed')])
+    return
+
+def register_Ns3Cost231PropagationLossModel_methods(root_module, cls):
+    ## cost231-propagation-loss-model.h: static ns3::TypeId ns3::Cost231PropagationLossModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## cost231-propagation-loss-model.h: ns3::Cost231PropagationLossModel::Cost231PropagationLossModel() [constructor]
+    cls.add_constructor([])
+    ## cost231-propagation-loss-model.h: double ns3::Cost231PropagationLossModel::GetLoss(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('GetLoss', 
+                   'double', 
+                   [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True)
+    ## cost231-propagation-loss-model.h: void ns3::Cost231PropagationLossModel::SetBSAntennaHeight(double height) [member function]
+    cls.add_method('SetBSAntennaHeight', 
+                   'void', 
+                   [param('double', 'height')])
+    ## cost231-propagation-loss-model.h: void ns3::Cost231PropagationLossModel::SetSSAntennaHeight(double height) [member function]
+    cls.add_method('SetSSAntennaHeight', 
+                   'void', 
+                   [param('double', 'height')])
+    ## cost231-propagation-loss-model.h: void ns3::Cost231PropagationLossModel::SetEnvironment(ns3::Cost231PropagationLossModel::Environment env) [member function]
+    cls.add_method('SetEnvironment', 
+                   'void', 
+                   [param('ns3::Cost231PropagationLossModel::Environment', 'env')])
+    ## cost231-propagation-loss-model.h: void ns3::Cost231PropagationLossModel::SetLambda(double lambda) [member function]
+    cls.add_method('SetLambda', 
+                   'void', 
+                   [param('double', 'lambda')])
+    ## cost231-propagation-loss-model.h: void ns3::Cost231PropagationLossModel::SetMinDistance(double minDistance) [member function]
+    cls.add_method('SetMinDistance', 
+                   'void', 
+                   [param('double', 'minDistance')])
+    ## cost231-propagation-loss-model.h: double ns3::Cost231PropagationLossModel::GetBSAntennaHeight() const [member function]
+    cls.add_method('GetBSAntennaHeight', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## cost231-propagation-loss-model.h: double ns3::Cost231PropagationLossModel::GetSSAntennaHeight() const [member function]
+    cls.add_method('GetSSAntennaHeight', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## cost231-propagation-loss-model.h: ns3::Cost231PropagationLossModel::Environment ns3::Cost231PropagationLossModel::GetEnvironment() const [member function]
+    cls.add_method('GetEnvironment', 
+                   'ns3::Cost231PropagationLossModel::Environment', 
+                   [], 
+                   is_const=True)
+    ## cost231-propagation-loss-model.h: double ns3::Cost231PropagationLossModel::GetMinDistance() const [member function]
+    cls.add_method('GetMinDistance', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## cost231-propagation-loss-model.h: double ns3::Cost231PropagationLossModel::GetLambda() const [member function]
+    cls.add_method('GetLambda', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## cost231-propagation-loss-model.h: void ns3::Cost231PropagationLossModel::SetLambda(double frequency, double speed) [member function]
+    cls.add_method('SetLambda', 
+                   'void', 
+                   [param('double', 'frequency'), param('double', 'speed')])
+    ## cost231-propagation-loss-model.h: double ns3::Cost231PropagationLossModel::GetShadowing() [member function]
+    cls.add_method('GetShadowing', 
+                   'double', 
+                   [])
+    ## cost231-propagation-loss-model.h: void ns3::Cost231PropagationLossModel::SetShadowing(double shadowing) [member function]
+    cls.add_method('SetShadowing', 
+                   'void', 
+                   [param('double', 'shadowing')])
+    ## cost231-propagation-loss-model.h: double ns3::Cost231PropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('DoCalcRxPower', 
+                   'double', 
+                   [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True, visibility='private', is_virtual=True)
     return
 
 def register_Ns3DataRateChecker_methods(root_module, cls):
@@ -1130,6 +1464,104 @@ def register_Ns3ErrorModel_methods(root_module, cls):
                    is_pure_virtual=True, visibility='private', is_virtual=True)
     return
 
+def register_Ns3FixedRssLossModel_methods(root_module, cls):
+    ## propagation-loss-model.h: static ns3::TypeId ns3::FixedRssLossModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## propagation-loss-model.h: ns3::FixedRssLossModel::FixedRssLossModel() [constructor]
+    cls.add_constructor([])
+    ## propagation-loss-model.h: void ns3::FixedRssLossModel::SetRss(double rss) [member function]
+    cls.add_method('SetRss', 
+                   'void', 
+                   [param('double', 'rss')])
+    ## propagation-loss-model.h: double ns3::FixedRssLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('DoCalcRxPower', 
+                   'double', 
+                   [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True, visibility='private', is_virtual=True)
+    return
+
+def register_Ns3FriisPropagationLossModel_methods(root_module, cls):
+    ## propagation-loss-model.h: static ns3::TypeId ns3::FriisPropagationLossModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## propagation-loss-model.h: ns3::FriisPropagationLossModel::FriisPropagationLossModel() [constructor]
+    cls.add_constructor([])
+    ## propagation-loss-model.h: void ns3::FriisPropagationLossModel::SetLambda(double frequency, double speed) [member function]
+    cls.add_method('SetLambda', 
+                   'void', 
+                   [param('double', 'frequency'), param('double', 'speed')])
+    ## propagation-loss-model.h: void ns3::FriisPropagationLossModel::SetLambda(double lambda) [member function]
+    cls.add_method('SetLambda', 
+                   'void', 
+                   [param('double', 'lambda')])
+    ## propagation-loss-model.h: void ns3::FriisPropagationLossModel::SetSystemLoss(double systemLoss) [member function]
+    cls.add_method('SetSystemLoss', 
+                   'void', 
+                   [param('double', 'systemLoss')])
+    ## propagation-loss-model.h: void ns3::FriisPropagationLossModel::SetMinDistance(double minDistance) [member function]
+    cls.add_method('SetMinDistance', 
+                   'void', 
+                   [param('double', 'minDistance')])
+    ## propagation-loss-model.h: double ns3::FriisPropagationLossModel::GetMinDistance() const [member function]
+    cls.add_method('GetMinDistance', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## propagation-loss-model.h: double ns3::FriisPropagationLossModel::GetLambda() const [member function]
+    cls.add_method('GetLambda', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## propagation-loss-model.h: double ns3::FriisPropagationLossModel::GetSystemLoss() const [member function]
+    cls.add_method('GetSystemLoss', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## propagation-loss-model.h: double ns3::FriisPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('DoCalcRxPower', 
+                   'double', 
+                   [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True, visibility='private', is_virtual=True)
+    return
+
+def register_Ns3JakesPropagationLossModel_methods(root_module, cls):
+    ## jakes-propagation-loss-model.h: ns3::JakesPropagationLossModel::JakesPropagationLossModel() [constructor]
+    cls.add_constructor([])
+    ## jakes-propagation-loss-model.h: uint8_t ns3::JakesPropagationLossModel::GetNOscillators() const [member function]
+    cls.add_method('GetNOscillators', 
+                   'uint8_t', 
+                   [], 
+                   is_const=True)
+    ## jakes-propagation-loss-model.h: uint8_t ns3::JakesPropagationLossModel::GetNRays() const [member function]
+    cls.add_method('GetNRays', 
+                   'uint8_t', 
+                   [], 
+                   is_const=True)
+    ## jakes-propagation-loss-model.h: static ns3::TypeId ns3::JakesPropagationLossModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## jakes-propagation-loss-model.h: void ns3::JakesPropagationLossModel::SetNOscillators(uint8_t nOscillators) [member function]
+    cls.add_method('SetNOscillators', 
+                   'void', 
+                   [param('uint8_t', 'nOscillators')])
+    ## jakes-propagation-loss-model.h: void ns3::JakesPropagationLossModel::SetNRays(uint8_t nRays) [member function]
+    cls.add_method('SetNRays', 
+                   'void', 
+                   [param('uint8_t', 'nRays')])
+    ## jakes-propagation-loss-model.h: double ns3::JakesPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('DoCalcRxPower', 
+                   'double', 
+                   [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True, visibility='private', is_virtual=True)
+    return
+
 def register_Ns3ListErrorModel_methods(root_module, cls):
     ## error-model.h: ns3::ListErrorModel::ListErrorModel(ns3::ListErrorModel const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::ListErrorModel const &', 'arg0')])
@@ -1161,6 +1593,72 @@ def register_Ns3ListErrorModel_methods(root_module, cls):
                    visibility='private', is_virtual=True)
     return
 
+def register_Ns3LogDistancePropagationLossModel_methods(root_module, cls):
+    ## propagation-loss-model.h: static ns3::TypeId ns3::LogDistancePropagationLossModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## propagation-loss-model.h: ns3::LogDistancePropagationLossModel::LogDistancePropagationLossModel() [constructor]
+    cls.add_constructor([])
+    ## propagation-loss-model.h: void ns3::LogDistancePropagationLossModel::SetPathLossExponent(double n) [member function]
+    cls.add_method('SetPathLossExponent', 
+                   'void', 
+                   [param('double', 'n')])
+    ## propagation-loss-model.h: double ns3::LogDistancePropagationLossModel::GetPathLossExponent() const [member function]
+    cls.add_method('GetPathLossExponent', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## propagation-loss-model.h: void ns3::LogDistancePropagationLossModel::SetReference(double referenceDistance, double referenceLoss) [member function]
+    cls.add_method('SetReference', 
+                   'void', 
+                   [param('double', 'referenceDistance'), param('double', 'referenceLoss')])
+    ## propagation-loss-model.h: double ns3::LogDistancePropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('DoCalcRxPower', 
+                   'double', 
+                   [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True, visibility='private', is_virtual=True)
+    return
+
+def register_Ns3MatrixPropagationLossModel_methods(root_module, cls):
+    ## propagation-loss-model.h: static ns3::TypeId ns3::MatrixPropagationLossModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## propagation-loss-model.h: ns3::MatrixPropagationLossModel::MatrixPropagationLossModel() [constructor]
+    cls.add_constructor([])
+    ## propagation-loss-model.h: void ns3::MatrixPropagationLossModel::SetLoss(ns3::Ptr<ns3::Node> a, ns3::Ptr<ns3::Node> b, double loss, bool symmetric=true) [member function]
+    cls.add_method('SetLoss', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Node >', 'a'), param('ns3::Ptr< ns3::Node >', 'b'), param('double', 'loss'), param('bool', 'symmetric', default_value='true')])
+    ## propagation-loss-model.h: void ns3::MatrixPropagationLossModel::SetDefaultLoss(double arg0) [member function]
+    cls.add_method('SetDefaultLoss', 
+                   'void', 
+                   [param('double', 'arg0')])
+    ## propagation-loss-model.h: double ns3::MatrixPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('DoCalcRxPower', 
+                   'double', 
+                   [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True, visibility='private', is_virtual=True)
+    return
+
+def register_Ns3NakagamiPropagationLossModel_methods(root_module, cls):
+    ## propagation-loss-model.h: static ns3::TypeId ns3::NakagamiPropagationLossModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## propagation-loss-model.h: ns3::NakagamiPropagationLossModel::NakagamiPropagationLossModel() [constructor]
+    cls.add_constructor([])
+    ## propagation-loss-model.h: double ns3::NakagamiPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('DoCalcRxPower', 
+                   'double', 
+                   [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True, visibility='private', is_virtual=True)
+    return
+
 def register_Ns3NixVector_methods(root_module, cls):
     cls.add_output_stream_operator()
     ## nix-vector.h: ns3::NixVector::NixVector() [constructor]
@@ -1181,10 +1679,10 @@ def register_Ns3NixVector_methods(root_module, cls):
                    'ns3::Ptr< ns3::NixVector >', 
                    [], 
                    is_const=True)
-    ## nix-vector.h: uint32_t ns3::NixVector::Deserialize(ns3::Buffer::Iterator i) [member function]
+    ## nix-vector.h: uint32_t ns3::NixVector::Deserialize(uint32_t * buffer, uint32_t size) [member function]
     cls.add_method('Deserialize', 
                    'uint32_t', 
-                   [param('ns3::Buffer::Iterator', 'i')])
+                   [param('uint32_t *', 'buffer'), param('uint32_t', 'size')])
     ## nix-vector.h: void ns3::NixVector::DumpNixVector(std::ostream & os) const [member function]
     cls.add_method('DumpNixVector', 
                    'void', 
@@ -1208,13 +1706,28 @@ def register_Ns3NixVector_methods(root_module, cls):
                    'ns3::TypeId', 
                    [], 
                    is_static=True)
-    ## nix-vector.h: void ns3::NixVector::Serialize(ns3::Buffer::Iterator i, uint32_t size) const [member function]
+    ## nix-vector.h: uint32_t ns3::NixVector::Serialize(uint32_t * buffer, uint32_t maxSize) const [member function]
     cls.add_method('Serialize', 
-                   'void', 
-                   [param('ns3::Buffer::Iterator', 'i'), param('uint32_t', 'size')], 
+                   'uint32_t', 
+                   [param('uint32_t *', 'buffer'), param('uint32_t', 'maxSize')], 
                    is_const=True)
     return
 
+def register_Ns3OutputStreamWrapper_methods(root_module, cls):
+    ## output-stream-wrapper.h: ns3::OutputStreamWrapper::OutputStreamWrapper(ns3::OutputStreamWrapper const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::OutputStreamWrapper const &', 'arg0')])
+    ## output-stream-wrapper.h: ns3::OutputStreamWrapper::OutputStreamWrapper() [constructor]
+    cls.add_constructor([])
+    ## output-stream-wrapper.h: std::ostream * ns3::OutputStreamWrapper::GetStream() [member function]
+    cls.add_method('GetStream', 
+                   'std::ostream *', 
+                   [])
+    ## output-stream-wrapper.h: void ns3::OutputStreamWrapper::SetStream(std::ostream * ostream) [member function]
+    cls.add_method('SetStream', 
+                   'void', 
+                   [param('std::ostream *', 'ostream')])
+    return
+
 def register_Ns3Packet_methods(root_module, cls):
     cls.add_output_stream_operator()
     ## packet.h: ns3::Packet::Packet() [constructor]
@@ -1223,6 +1736,8 @@ def register_Ns3Packet_methods(root_module, cls):
     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, bool magic) [constructor]
+    cls.add_constructor([param('uint8_t const *', 'buffer'), param('uint32_t', 'size'), param('bool', 'magic')])
     ## 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]
@@ -1276,10 +1791,6 @@ def register_Ns3Packet_methods(root_module, cls):
                    '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', 
@@ -1310,14 +1821,19 @@ def register_Ns3Packet_methods(root_module, cls):
                    'ns3::PacketTagIterator', 
                    [], 
                    is_const=True)
+    ## packet.h: uint32_t ns3::Packet::GetSerializedSize() const [member function]
+    cls.add_method('GetSerializedSize', 
+                   'uint32_t', 
+                   [], 
+                   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]
+    ## packet.h: uint64_t ns3::Packet::GetUid() const [member function]
     cls.add_method('GetUid', 
-                   'uint32_t', 
+                   'uint64_t', 
                    [], 
                    is_const=True)
     ## packet.h: uint8_t const * ns3::Packet::PeekData() const [member function]
@@ -1382,10 +1898,10 @@ def register_Ns3Packet_methods(root_module, cls):
     cls.add_method('RemoveTrailer', 
                    'uint32_t', 
                    [param('ns3::Trailer &', 'trailer')])
-    ## packet.h: ns3::Buffer ns3::Packet::Serialize() const [member function]
+    ## packet.h: uint32_t ns3::Packet::Serialize(uint8_t * buffer, uint32_t maxSize) const [member function]
     cls.add_method('Serialize', 
-                   'ns3::Buffer', 
-                   [], 
+                   'uint32_t', 
+                   [param('uint8_t *', 'buffer'), param('uint32_t', 'maxSize')], 
                    is_const=True)
     ## packet.h: void ns3::Packet::SetNixVector(ns3::Ptr<ns3::NixVector> arg0) [member function]
     cls.add_method('SetNixVector', 

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

@@ -93,6 +93,8 @@ def register_types(module):
     module.add_class('Vector3D')
     ## random-variable.h: ns3::WeibullVariable [class]
     module.add_class('WeibullVariable', parent=root_module['ns3::RandomVariable'])
+    ## random-variable.h: ns3::ZetaVariable [class]
+    module.add_class('ZetaVariable', parent=root_module['ns3::RandomVariable'])
     ## random-variable.h: ns3::ZipfVariable [class]
     module.add_class('ZipfVariable', parent=root_module['ns3::RandomVariable'])
     ## empty.h: ns3::empty [class]
@@ -203,17 +205,10 @@ def register_types(module):
     module.add_class('Vector3DChecker', parent=root_module['ns3::AttributeChecker'])
     ## vector.h: ns3::Vector3DValue [class]
     module.add_class('Vector3DValue', parent=root_module['ns3::AttributeValue'])
-    ## traced-value.h: ns3::TracedValue<unsigned int> [class]
-    module.add_class('TracedValue', template_parameters=['unsigned int'])
-    ## traced-value.h: ns3::TracedValue<unsigned int> [class]
-    root_module['ns3::TracedValue< unsigned int >'].implicitly_converts_to(root_module['ns3::IntegerValue'])
-    ## traced-value.h: ns3::TracedValue<unsigned int> [class]
-    root_module['ns3::TracedValue< unsigned int >'].implicitly_converts_to(root_module['ns3::UintegerValue'])
-    ## traced-value.h: ns3::TracedValue<unsigned int> [class]
-    root_module['ns3::TracedValue< unsigned int >'].implicitly_converts_to(root_module['ns3::BooleanValue'])
-    ## traced-value.h: ns3::TracedValue<unsigned int> [class]
-    root_module['ns3::TracedValue< unsigned int >'].implicitly_converts_to(root_module['ns3::EnumValue'])
     module.add_container('std::list< ns3::Ptr< ns3::Packet > >', 'ns3::Ptr< ns3::Packet >', container_type='list')
+    module.add_container('std::list< ns3::Ptr< ns3::UlJob > >', 'ns3::Ptr< ns3::UlJob >', container_type='list')
+    module.add_container('std::list< ns3::Ptr< ns3::Packet const > >', 'ns3::Ptr< ns3::Packet const >', container_type='list')
+    module.add_container('std::vector< ns3::Ptr< ns3::WimaxConnection > >', 'ns3::Ptr< ns3::WimaxConnection >', container_type='vector')
     module.add_container('std::vector< ns3::Ptr< ns3::FlowProbe > >', 'ns3::Ptr< ns3::FlowProbe >', container_type='vector')
     module.add_container('std::list< ns3::Ptr< ns3::RadvdPrefix > >', 'ns3::Ptr< ns3::RadvdPrefix >', container_type='list')
     module.add_container('std::vector< ns3::Ptr< ns3::NetDevice > >', 'ns3::Ptr< ns3::NetDevice >', container_type='vector')
@@ -351,6 +346,7 @@ def register_methods(root_module):
     register_Ns3Vector2D_methods(root_module, root_module['ns3::Vector2D'])
     register_Ns3Vector3D_methods(root_module, root_module['ns3::Vector3D'])
     register_Ns3WeibullVariable_methods(root_module, root_module['ns3::WeibullVariable'])
+    register_Ns3ZetaVariable_methods(root_module, root_module['ns3::ZetaVariable'])
     register_Ns3ZipfVariable_methods(root_module, root_module['ns3::ZipfVariable'])
     register_Ns3Empty_methods(root_module, root_module['ns3::empty'])
     register_Ns3ConstantVariable_methods(root_module, root_module['ns3::ConstantVariable'])
@@ -365,7 +361,6 @@ def register_methods(root_module):
     register_Ns3Object_methods(root_module, root_module['ns3::Object'])
     register_Ns3ObjectAggregateIterator_methods(root_module, root_module['ns3::Object::AggregateIterator'])
     register_Ns3ParetoVariable_methods(root_module, root_module['ns3::ParetoVariable'])
-    register_Ns3SimpleRefCount__Ns3AsciiWriter_Ns3Empty_Ns3DefaultDeleter__lt__ns3AsciiWriter__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AsciiWriter, ns3::empty, ns3::DefaultDeleter<ns3::AsciiWriter> >'])
     register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >'])
     register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeChecker__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> >'])
     register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeValue__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> >'])
@@ -379,6 +374,7 @@ def register_methods(root_module):
     register_Ns3SimpleRefCount__Ns3Ipv6MulticastRoute_Ns3Empty_Ns3DefaultDeleter__lt__ns3Ipv6MulticastRoute__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::Ipv6MulticastRoute, ns3::empty, ns3::DefaultDeleter<ns3::Ipv6MulticastRoute> >'])
     register_Ns3SimpleRefCount__Ns3Ipv6Route_Ns3Empty_Ns3DefaultDeleter__lt__ns3Ipv6Route__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::Ipv6Route, ns3::empty, ns3::DefaultDeleter<ns3::Ipv6Route> >'])
     register_Ns3SimpleRefCount__Ns3MeshWifiInterfaceMacPlugin_Ns3Empty_Ns3DefaultDeleter__lt__ns3MeshWifiInterfaceMacPlugin__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::MeshWifiInterfaceMacPlugin, ns3::empty, ns3::DefaultDeleter<ns3::MeshWifiInterfaceMacPlugin> >'])
+    register_Ns3SimpleRefCount__Ns3OutputStreamWrapper_Ns3Empty_Ns3DefaultDeleter__lt__ns3OutputStreamWrapper__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> >'])
     register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Packet__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> >'])
     register_Ns3SimpleRefCount__Ns3PbbAddressBlock_Ns3Empty_Ns3DefaultDeleter__lt__ns3PbbAddressBlock__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::PbbAddressBlock, ns3::empty, ns3::DefaultDeleter<ns3::PbbAddressBlock> >'])
     register_Ns3SimpleRefCount__Ns3PbbMessage_Ns3Empty_Ns3DefaultDeleter__lt__ns3PbbMessage__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::PbbMessage, ns3::empty, ns3::DefaultDeleter<ns3::PbbMessage> >'])
@@ -425,7 +421,6 @@ def register_methods(root_module):
     register_Ns3Vector2DValue_methods(root_module, root_module['ns3::Vector2DValue'])
     register_Ns3Vector3DChecker_methods(root_module, root_module['ns3::Vector3DChecker'])
     register_Ns3Vector3DValue_methods(root_module, root_module['ns3::Vector3DValue'])
-    register_Ns3TracedValue__Unsigned_int_methods(root_module, root_module['ns3::TracedValue< unsigned int >'])
     register_Ns3ConfigMatchContainer_methods(root_module, root_module['ns3::Config::MatchContainer'])
     return
 
@@ -1575,11 +1570,20 @@ def register_Ns3WeibullVariable_methods(root_module, cls):
     cls.add_constructor([param('double', 'm'), param('double', 's'), param('double', 'b')])
     return
 
+def register_Ns3ZetaVariable_methods(root_module, cls):
+    ## random-variable.h: ns3::ZetaVariable::ZetaVariable(ns3::ZetaVariable const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::ZetaVariable const &', 'arg0')])
+    ## random-variable.h: ns3::ZetaVariable::ZetaVariable(double alpha) [constructor]
+    cls.add_constructor([param('double', 'alpha')])
+    ## random-variable.h: ns3::ZetaVariable::ZetaVariable() [constructor]
+    cls.add_constructor([])
+    return
+
 def register_Ns3ZipfVariable_methods(root_module, cls):
     ## random-variable.h: ns3::ZipfVariable::ZipfVariable(ns3::ZipfVariable const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::ZipfVariable const &', 'arg0')])
-    ## random-variable.h: ns3::ZipfVariable::ZipfVariable(long int n, double alpha) [constructor]
-    cls.add_constructor([param('long int', 'n'), param('double', 'alpha')])
+    ## random-variable.h: ns3::ZipfVariable::ZipfVariable(long int N, double alpha) [constructor]
+    cls.add_constructor([param('long int', 'N'), param('double', 'alpha')])
     ## random-variable.h: ns3::ZipfVariable::ZipfVariable() [constructor]
     cls.add_constructor([])
     return
@@ -1778,18 +1782,10 @@ def register_Ns3ParetoVariable_methods(root_module, cls):
     cls.add_constructor([param('double', 'm'), param('double', 's')])
     ## random-variable.h: ns3::ParetoVariable::ParetoVariable(double m, double s, double b) [constructor]
     cls.add_constructor([param('double', 'm'), param('double', 's'), param('double', 'b')])
-    return
-
-def register_Ns3SimpleRefCount__Ns3AsciiWriter_Ns3Empty_Ns3DefaultDeleter__lt__ns3AsciiWriter__gt___methods(root_module, cls):
-    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::AsciiWriter, ns3::empty, ns3::DefaultDeleter<ns3::AsciiWriter> >::SimpleRefCount() [constructor]
-    cls.add_constructor([])
-    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::AsciiWriter, ns3::empty, ns3::DefaultDeleter<ns3::AsciiWriter> >::SimpleRefCount(ns3::SimpleRefCount<ns3::AsciiWriter, ns3::empty, ns3::DefaultDeleter<ns3::AsciiWriter> > const & o) [copy constructor]
-    cls.add_constructor([param('ns3::SimpleRefCount< ns3::AsciiWriter, ns3::empty, ns3::DefaultDeleter< ns3::AsciiWriter > > const &', 'o')])
-    ## simple-ref-count.h: static void ns3::SimpleRefCount<ns3::AsciiWriter, ns3::empty, ns3::DefaultDeleter<ns3::AsciiWriter> >::Cleanup() [member function]
-    cls.add_method('Cleanup', 
-                   'void', 
-                   [], 
-                   is_static=True)
+    ## random-variable.h: ns3::ParetoVariable::ParetoVariable(std::pair<double,double> params) [constructor]
+    cls.add_constructor([param('std::pair< double, double >', 'params')])
+    ## random-variable.h: ns3::ParetoVariable::ParetoVariable(std::pair<double,double> params, double b) [constructor]
+    cls.add_constructor([param('std::pair< double, double >', 'params'), param('double', 'b')])
     return
 
 def register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, cls):
@@ -1948,6 +1944,18 @@ def register_Ns3SimpleRefCount__Ns3MeshWifiInterfaceMacPlugin_Ns3Empty_Ns3Defaul
                    is_static=True)
     return
 
+def register_Ns3SimpleRefCount__Ns3OutputStreamWrapper_Ns3Empty_Ns3DefaultDeleter__lt__ns3OutputStreamWrapper__gt___methods(root_module, cls):
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> >::SimpleRefCount() [constructor]
+    cls.add_constructor([])
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> >::SimpleRefCount(ns3::SimpleRefCount<ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> > const & o) [copy constructor]
+    cls.add_constructor([param('ns3::SimpleRefCount< ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter< ns3::OutputStreamWrapper > > const &', 'o')])
+    ## simple-ref-count.h: static void ns3::SimpleRefCount<ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> >::Cleanup() [member function]
+    cls.add_method('Cleanup', 
+                   'void', 
+                   [], 
+                   is_static=True)
+    return
+
 def register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Packet__gt___methods(root_module, cls):
     ## simple-ref-count.h: ns3::SimpleRefCount<ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> >::SimpleRefCount() [constructor]
     cls.add_constructor([])
@@ -2898,48 +2906,6 @@ def register_Ns3Vector3DValue_methods(root_module, cls):
                    [param('ns3::Vector3D const &', 'value')])
     return
 
-def register_Ns3TracedValue__Unsigned_int_methods(root_module, cls):
-    ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue() [constructor]
-    cls.add_constructor([])
-    ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::TracedValue<unsigned int> const & o) [copy constructor]
-    cls.add_constructor([param('ns3::TracedValue< unsigned int > const &', 'o')])
-    ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(unsigned int const & v) [constructor]
-    cls.add_constructor([param('unsigned int const &', 'v')])
-    ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::IntegerValue const & value) [constructor]
-    cls.add_constructor([param('ns3::IntegerValue const &', 'value')])
-    ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::UintegerValue const & value) [constructor]
-    cls.add_constructor([param('ns3::UintegerValue const &', 'value')])
-    ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::BooleanValue const & value) [constructor]
-    cls.add_constructor([param('ns3::BooleanValue const &', 'value')])
-    ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::EnumValue const & value) [constructor]
-    cls.add_constructor([param('ns3::EnumValue const &', 'value')])
-    ## traced-value.h: void ns3::TracedValue<unsigned int>::Connect(ns3::CallbackBase const & cb, std::basic_string<char,std::char_traits<char>,std::allocator<char> > path) [member function]
-    cls.add_method('Connect', 
-                   'void', 
-                   [param('ns3::CallbackBase const &', 'cb'), param('std::string', 'path')])
-    ## traced-value.h: void ns3::TracedValue<unsigned int>::ConnectWithoutContext(ns3::CallbackBase const & cb) [member function]
-    cls.add_method('ConnectWithoutContext', 
-                   'void', 
-                   [param('ns3::CallbackBase const &', 'cb')])
-    ## traced-value.h: void ns3::TracedValue<unsigned int>::Disconnect(ns3::CallbackBase const & cb, std::basic_string<char,std::char_traits<char>,std::allocator<char> > path) [member function]
-    cls.add_method('Disconnect', 
-                   'void', 
-                   [param('ns3::CallbackBase const &', 'cb'), param('std::string', 'path')])
-    ## traced-value.h: void ns3::TracedValue<unsigned int>::DisconnectWithoutContext(ns3::CallbackBase const & cb) [member function]
-    cls.add_method('DisconnectWithoutContext', 
-                   'void', 
-                   [param('ns3::CallbackBase const &', 'cb')])
-    ## traced-value.h: unsigned int ns3::TracedValue<unsigned int>::Get() const [member function]
-    cls.add_method('Get', 
-                   'unsigned int', 
-                   [], 
-                   is_const=True)
-    ## traced-value.h: void ns3::TracedValue<unsigned int>::Set(unsigned int const & v) [member function]
-    cls.add_method('Set', 
-                   'void', 
-                   [param('unsigned int const &', 'v')])
-    return
-
 def register_Ns3ConfigMatchContainer_methods(root_module, cls):
     ## config.h: ns3::Config::MatchContainer::MatchContainer(ns3::Config::MatchContainer const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::Config::MatchContainer const &', 'arg0')])
@@ -3043,6 +3009,21 @@ def register_functions(root_module):
     module.add_function('MakeBooleanChecker', 
                         'ns3::Ptr< ns3::AttributeChecker const >', 
                         [])
+    ## callback.h: extern ns3::Callback<void,ns3::Ptr<const ns3::Packet>,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ns3::MakeBoundCallback(void (*)( ::ns3::Ptr<ns3::OutputStreamWrapper>,::ns3::Ptr<ns3::Packet const> ) * fnPtr, ns3::Ptr<ns3::OutputStreamWrapper> a) [free function]
+    module.add_function('MakeBoundCallback', 
+                        'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 
+                        [param('void ( * ) ( ns3::Ptr< ns3::OutputStreamWrapper >, ns3::Ptr< ns3::Packet const > ) *', 'fnPtr'), param('ns3::Ptr< ns3::OutputStreamWrapper >', 'a')], 
+                        template_parameters=['void', 'ns3::Ptr<ns3::OutputStreamWrapper>', 'ns3::Ptr<ns3::OutputStreamWrapper>', 'ns3::Ptr<ns3::Packet const>'])
+    ## callback.h: extern ns3::Callback<void,ns3::Ptr<const ns3::Packet>,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ns3::MakeBoundCallback(void (*)( ::ns3::Ptr<ns3::PcapFileWrapper>,::ns3::Ptr<ns3::Packet const> ) * fnPtr, ns3::Ptr<ns3::PcapFileWrapper> a) [free function]
+    module.add_function('MakeBoundCallback', 
+                        'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 
+                        [param('void ( * ) ( ns3::Ptr< ns3::PcapFileWrapper >, ns3::Ptr< ns3::Packet const > ) *', 'fnPtr'), param('ns3::Ptr< ns3::PcapFileWrapper >', 'a')], 
+                        template_parameters=['void', 'ns3::Ptr<ns3::PcapFileWrapper>', 'ns3::Ptr<ns3::PcapFileWrapper>', 'ns3::Ptr<ns3::Packet const>'])
+    ## callback.h: extern ns3::Callback<void,std::basic_string<char, std::char_traits<char>, std::allocator<char> >,ns3::Ptr<const ns3::Packet>,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ns3::MakeBoundCallback(void (*)( ::ns3::Ptr<ns3::OutputStreamWrapper>,::std::basic_string<char,std::char_traits<char>,std::allocator<char> >,::ns3::Ptr<ns3::Packet const> ) * fnPtr, ns3::Ptr<ns3::OutputStreamWrapper> a) [free function]
+    module.add_function('MakeBoundCallback', 
+                        'ns3::Callback< void, std::basic_string< char, std::char_traits< char >, std::allocator< char > >, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 
+                        [param('void ( * ) ( ns3::Ptr< ns3::OutputStreamWrapper >, std::string, ns3::Ptr< ns3::Packet const > ) *', 'fnPtr'), param('ns3::Ptr< ns3::OutputStreamWrapper >', 'a')], 
+                        template_parameters=['void', 'ns3::Ptr<ns3::OutputStreamWrapper>', 'ns3::Ptr<ns3::OutputStreamWrapper>', 'std::string', 'ns3::Ptr<ns3::Packet const>'])
     ## callback.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeCallbackChecker() [free function]
     module.add_function('MakeCallbackChecker', 
                         'ns3::Ptr< ns3::AttributeChecker const >', 

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

@@ -266,6 +266,11 @@ def register_Ns3CsmaNetDevice_methods(root_module, cls):
     cls.add_method('SetQueue', 
                    'void', 
                    [param('ns3::Ptr< ns3::Queue >', 'queue')])
+    ## csma-net-device.h: ns3::Ptr<ns3::Queue> ns3::CsmaNetDevice::GetQueue() const [member function]
+    cls.add_method('GetQueue', 
+                   'ns3::Ptr< ns3::Queue >', 
+                   [], 
+                   is_const=True)
     ## csma-net-device.h: void ns3::CsmaNetDevice::SetReceiveErrorModel(ns3::Ptr<ns3::ErrorModel> em) [member function]
     cls.add_method('SetReceiveErrorModel', 
                    'void', 
@@ -290,15 +295,6 @@ def register_Ns3CsmaNetDevice_methods(root_module, cls):
     cls.add_method('SetReceiveEnable', 
                    'void', 
                    [param('bool', 'enable')])
-    ## csma-net-device.h: void ns3::CsmaNetDevice::SetFrameSize(uint16_t frameSize) [member function]
-    cls.add_method('SetFrameSize', 
-                   'void', 
-                   [param('uint16_t', 'frameSize')])
-    ## csma-net-device.h: uint16_t ns3::CsmaNetDevice::GetFrameSize() const [member function]
-    cls.add_method('GetFrameSize', 
-                   'uint16_t', 
-                   [], 
-                   is_const=True)
     ## csma-net-device.h: void ns3::CsmaNetDevice::SetEncapsulationMode(ns3::CsmaNetDevice::EncapsulationMode mode) [member function]
     cls.add_method('SetEncapsulationMode', 
                    'void', 
@@ -432,11 +428,6 @@ def register_Ns3CsmaNetDevice_methods(root_module, cls):
                    'void', 
                    [], 
                    visibility='protected', is_virtual=True)
-    ## csma-net-device.h: ns3::Ptr<ns3::Queue> ns3::CsmaNetDevice::GetQueue() const [member function]
-    cls.add_method('GetQueue', 
-                   'ns3::Ptr< ns3::Queue >', 
-                   [], 
-                   is_const=True, visibility='protected')
     ## csma-net-device.h: void ns3::CsmaNetDevice::AddHeader(ns3::Ptr<ns3::Packet> p, ns3::Mac48Address source, ns3::Mac48Address dest, uint16_t protocolNumber) [member function]
     cls.add_method('AddHeader', 
                    'void', 

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

@@ -147,6 +147,11 @@ def register_Ns3EmuNetDevice_methods(root_module, cls):
                    'ns3::Ptr< ns3::Node >', 
                    [], 
                    is_const=True, is_virtual=True)
+    ## emu-net-device.h: ns3::Ptr<ns3::Queue> ns3::EmuNetDevice::GetQueue() const [member function]
+    cls.add_method('GetQueue', 
+                   'ns3::Ptr< ns3::Queue >', 
+                   [], 
+                   is_const=True)
     ## emu-net-device.h: static ns3::TypeId ns3::EmuNetDevice::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 

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

@@ -290,6 +290,8 @@ def register_Ns3FlowMonitorFlowStats_methods(root_module, cls):
     cls.add_instance_attribute('delayHistogram', 'ns3::Histogram', is_const=False)
     ## flow-monitor.h: ns3::FlowMonitor::FlowStats::delaySum [variable]
     cls.add_instance_attribute('delaySum', 'ns3::Time', is_const=False)
+    ## flow-monitor.h: ns3::FlowMonitor::FlowStats::flowInterruptionsHistogram [variable]
+    cls.add_instance_attribute('flowInterruptionsHistogram', 'ns3::Histogram', is_const=False)
     ## flow-monitor.h: ns3::FlowMonitor::FlowStats::jitterHistogram [variable]
     cls.add_instance_attribute('jitterHistogram', 'ns3::Histogram', is_const=False)
     ## flow-monitor.h: ns3::FlowMonitor::FlowStats::jitterSum [variable]

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

@@ -331,7 +331,7 @@ def register_Ns3GlobalRouter_methods(root_module, cls):
                    [])
     ## global-router-interface.h: ns3::Ipv4RoutingTableEntry * ns3::GlobalRouter::GetInjectedRoute(uint32_t i) [member function]
     cls.add_method('GetInjectedRoute', 
-                   'ns3::Ipv4RoutingTableEntry *', 
+                   retval('ns3::Ipv4RoutingTableEntry *', caller_owns_return=False), 
                    [param('uint32_t', 'i')])
     ## global-router-interface.h: void ns3::GlobalRouter::RemoveInjectedRoute(uint32_t i) [member function]
     cls.add_method('RemoveInjectedRoute', 
@@ -379,7 +379,7 @@ def register_Ns3Ipv4GlobalRouting_methods(root_module, cls):
                    [])
     ## ipv4-global-routing.h: ns3::Ipv4RoutingTableEntry * ns3::Ipv4GlobalRouting::GetRoute(uint32_t i) [member function]
     cls.add_method('GetRoute', 
-                   'ns3::Ipv4RoutingTableEntry *', 
+                   retval('ns3::Ipv4RoutingTableEntry *', caller_owns_return=False), 
                    [param('uint32_t', 'i')])
     ## ipv4-global-routing.h: static ns3::TypeId ns3::Ipv4GlobalRouting::GetTypeId() [member function]
     cls.add_method('GetTypeId', 

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

@@ -59,6 +59,8 @@ def register_types(module):
     module.add_class('Icmpv6TooBig', parent=root_module['ns3::Icmpv6Header'])
     ## ipv6-extension-header.h: ns3::Ipv6ExtensionHeader [class]
     module.add_class('Ipv6ExtensionHeader', parent=root_module['ns3::Header'])
+    ## ipv6-extension-header.h: ns3::Ipv6ExtensionHopByHopHeader [class]
+    module.add_class('Ipv6ExtensionHopByHopHeader', parent=[root_module['ns3::Ipv6ExtensionHeader'], root_module['ns3::OptionField']])
     ## ipv6-extension-header.h: ns3::Ipv6ExtensionRoutingHeader [class]
     module.add_class('Ipv6ExtensionRoutingHeader', parent=root_module['ns3::Ipv6ExtensionHeader'])
     ## ipv6-option-header.h: ns3::Ipv6OptionHeader [class]
@@ -101,12 +103,16 @@ def register_types(module):
     module.add_enum('RxStatus', ['RX_OK', 'RX_CSUM_FAILED', 'RX_ENDPOINT_CLOSED', 'RX_ENDPOINT_UNREACH'], outer_class=root_module['ns3::Ipv4L4Protocol'])
     ## ipv6-extension-header.h: ns3::Ipv6ExtensionAHHeader [class]
     module.add_class('Ipv6ExtensionAHHeader', parent=root_module['ns3::Ipv6ExtensionHeader'])
+    ## ipv6-extension-header.h: ns3::Ipv6ExtensionDestinationHeader [class]
+    module.add_class('Ipv6ExtensionDestinationHeader', parent=[root_module['ns3::Ipv6ExtensionHeader'], root_module['ns3::OptionField']])
     ## ipv6-extension-header.h: ns3::Ipv6ExtensionESPHeader [class]
     module.add_class('Ipv6ExtensionESPHeader', parent=root_module['ns3::Ipv6ExtensionHeader'])
     ## ipv6-extension-header.h: ns3::Ipv6ExtensionFragmentHeader [class]
     module.add_class('Ipv6ExtensionFragmentHeader', parent=root_module['ns3::Ipv6ExtensionHeader'])
     ## ipv6-extension-header.h: ns3::Ipv6ExtensionLooseRoutingHeader [class]
     module.add_class('Ipv6ExtensionLooseRoutingHeader', parent=root_module['ns3::Ipv6ExtensionRoutingHeader'])
+    ## ipv6-interface.h: ns3::Ipv6Interface [class]
+    module.add_class('Ipv6Interface', parent=root_module['ns3::Object'])
     ## ipv6-l3-protocol.h: ns3::Ipv6L3Protocol [class]
     module.add_class('Ipv6L3Protocol', parent=root_module['ns3::Ipv6'])
     ## ipv6-l3-protocol.h: ns3::Ipv6L3Protocol::DropReason [enumeration]
@@ -231,6 +237,7 @@ def register_methods(root_module):
     register_Ns3Icmpv6TimeExceeded_methods(root_module, root_module['ns3::Icmpv6TimeExceeded'])
     register_Ns3Icmpv6TooBig_methods(root_module, root_module['ns3::Icmpv6TooBig'])
     register_Ns3Ipv6ExtensionHeader_methods(root_module, root_module['ns3::Ipv6ExtensionHeader'])
+    register_Ns3Ipv6ExtensionHopByHopHeader_methods(root_module, root_module['ns3::Ipv6ExtensionHopByHopHeader'])
     register_Ns3Ipv6ExtensionRoutingHeader_methods(root_module, root_module['ns3::Ipv6ExtensionRoutingHeader'])
     register_Ns3Ipv6OptionHeader_methods(root_module, root_module['ns3::Ipv6OptionHeader'])
     register_Ns3Ipv6OptionHeaderAlignment_methods(root_module, root_module['ns3::Ipv6OptionHeader::Alignment'])
@@ -249,9 +256,11 @@ def register_methods(root_module):
     register_Ns3Ipv4L3Protocol_methods(root_module, root_module['ns3::Ipv4L3Protocol'])
     register_Ns3Ipv4L4Protocol_methods(root_module, root_module['ns3::Ipv4L4Protocol'])
     register_Ns3Ipv6ExtensionAHHeader_methods(root_module, root_module['ns3::Ipv6ExtensionAHHeader'])
+    register_Ns3Ipv6ExtensionDestinationHeader_methods(root_module, root_module['ns3::Ipv6ExtensionDestinationHeader'])
     register_Ns3Ipv6ExtensionESPHeader_methods(root_module, root_module['ns3::Ipv6ExtensionESPHeader'])
     register_Ns3Ipv6ExtensionFragmentHeader_methods(root_module, root_module['ns3::Ipv6ExtensionFragmentHeader'])
     register_Ns3Ipv6ExtensionLooseRoutingHeader_methods(root_module, root_module['ns3::Ipv6ExtensionLooseRoutingHeader'])
+    register_Ns3Ipv6Interface_methods(root_module, root_module['ns3::Ipv6Interface'])
     register_Ns3Ipv6L3Protocol_methods(root_module, root_module['ns3::Ipv6L3Protocol'])
     register_Ns3Ipv6L4Protocol_methods(root_module, root_module['ns3::Ipv6L4Protocol'])
     register_Ns3NdiscCache_methods(root_module, root_module['ns3::NdiscCache'])
@@ -1481,6 +1490,43 @@ def register_Ns3Ipv6ExtensionHeader_methods(root_module, cls):
                    [param('uint8_t', 'nextHeader')])
     return
 
+def register_Ns3Ipv6ExtensionHopByHopHeader_methods(root_module, cls):
+    ## ipv6-extension-header.h: ns3::Ipv6ExtensionHopByHopHeader::Ipv6ExtensionHopByHopHeader(ns3::Ipv6ExtensionHopByHopHeader const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::Ipv6ExtensionHopByHopHeader const &', 'arg0')])
+    ## ipv6-extension-header.h: ns3::Ipv6ExtensionHopByHopHeader::Ipv6ExtensionHopByHopHeader() [constructor]
+    cls.add_constructor([])
+    ## ipv6-extension-header.h: uint32_t ns3::Ipv6ExtensionHopByHopHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
+    cls.add_method('Deserialize', 
+                   'uint32_t', 
+                   [param('ns3::Buffer::Iterator', 'start')], 
+                   is_virtual=True)
+    ## ipv6-extension-header.h: ns3::TypeId ns3::Ipv6ExtensionHopByHopHeader::GetInstanceTypeId() const [member function]
+    cls.add_method('GetInstanceTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## ipv6-extension-header.h: uint32_t ns3::Ipv6ExtensionHopByHopHeader::GetSerializedSize() const [member function]
+    cls.add_method('GetSerializedSize', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## ipv6-extension-header.h: static ns3::TypeId ns3::Ipv6ExtensionHopByHopHeader::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## ipv6-extension-header.h: void ns3::Ipv6ExtensionHopByHopHeader::Print(std::ostream & os) const [member function]
+    cls.add_method('Print', 
+                   'void', 
+                   [param('std::ostream &', 'os')], 
+                   is_const=True, is_virtual=True)
+    ## ipv6-extension-header.h: void ns3::Ipv6ExtensionHopByHopHeader::Serialize(ns3::Buffer::Iterator start) const [member function]
+    cls.add_method('Serialize', 
+                   'void', 
+                   [param('ns3::Buffer::Iterator', 'start')], 
+                   is_const=True, is_virtual=True)
+    return
+
 def register_Ns3Ipv6ExtensionRoutingHeader_methods(root_module, cls):
     ## ipv6-extension-header.h: ns3::Ipv6ExtensionRoutingHeader::Ipv6ExtensionRoutingHeader(ns3::Ipv6ExtensionRoutingHeader const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::Ipv6ExtensionRoutingHeader const &', 'arg0')])
@@ -2616,6 +2662,43 @@ def register_Ns3Ipv6ExtensionAHHeader_methods(root_module, cls):
                    is_const=True, is_virtual=True)
     return
 
+def register_Ns3Ipv6ExtensionDestinationHeader_methods(root_module, cls):
+    ## ipv6-extension-header.h: ns3::Ipv6ExtensionDestinationHeader::Ipv6ExtensionDestinationHeader(ns3::Ipv6ExtensionDestinationHeader const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::Ipv6ExtensionDestinationHeader const &', 'arg0')])
+    ## ipv6-extension-header.h: ns3::Ipv6ExtensionDestinationHeader::Ipv6ExtensionDestinationHeader() [constructor]
+    cls.add_constructor([])
+    ## ipv6-extension-header.h: uint32_t ns3::Ipv6ExtensionDestinationHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
+    cls.add_method('Deserialize', 
+                   'uint32_t', 
+                   [param('ns3::Buffer::Iterator', 'start')], 
+                   is_virtual=True)
+    ## ipv6-extension-header.h: ns3::TypeId ns3::Ipv6ExtensionDestinationHeader::GetInstanceTypeId() const [member function]
+    cls.add_method('GetInstanceTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## ipv6-extension-header.h: uint32_t ns3::Ipv6ExtensionDestinationHeader::GetSerializedSize() const [member function]
+    cls.add_method('GetSerializedSize', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## ipv6-extension-header.h: static ns3::TypeId ns3::Ipv6ExtensionDestinationHeader::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## ipv6-extension-header.h: void ns3::Ipv6ExtensionDestinationHeader::Print(std::ostream & os) const [member function]
+    cls.add_method('Print', 
+                   'void', 
+                   [param('std::ostream &', 'os')], 
+                   is_const=True, is_virtual=True)
+    ## ipv6-extension-header.h: void ns3::Ipv6ExtensionDestinationHeader::Serialize(ns3::Buffer::Iterator start) const [member function]
+    cls.add_method('Serialize', 
+                   'void', 
+                   [param('ns3::Buffer::Iterator', 'start')], 
+                   is_const=True, is_virtual=True)
+    return
+
 def register_Ns3Ipv6ExtensionESPHeader_methods(root_module, cls):
     ## ipv6-extension-header.h: ns3::Ipv6ExtensionESPHeader::Ipv6ExtensionESPHeader(ns3::Ipv6ExtensionESPHeader const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::Ipv6ExtensionESPHeader const &', 'arg0')])
@@ -2776,6 +2859,147 @@ def register_Ns3Ipv6ExtensionLooseRoutingHeader_methods(root_module, cls):
                    [param('std::vector< ns3::Ipv6Address >', 'routersAddress')])
     return
 
+def register_Ns3Ipv6Interface_methods(root_module, cls):
+    ## ipv6-interface.h: ns3::Ipv6Interface::Ipv6Interface(ns3::Ipv6Interface const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::Ipv6Interface const &', 'arg0')])
+    ## ipv6-interface.h: ns3::Ipv6Interface::Ipv6Interface() [constructor]
+    cls.add_constructor([])
+    ## ipv6-interface.h: bool ns3::Ipv6Interface::AddAddress(ns3::Ipv6InterfaceAddress iface) [member function]
+    cls.add_method('AddAddress', 
+                   'bool', 
+                   [param('ns3::Ipv6InterfaceAddress', 'iface')])
+    ## ipv6-interface.h: ns3::Ipv6InterfaceAddress ns3::Ipv6Interface::GetAddress(uint32_t index) const [member function]
+    cls.add_method('GetAddress', 
+                   'ns3::Ipv6InterfaceAddress', 
+                   [param('uint32_t', 'index')], 
+                   is_const=True)
+    ## ipv6-interface.h: ns3::Ipv6InterfaceAddress ns3::Ipv6Interface::GetAddressMatchingDestination(ns3::Ipv6Address dst) [member function]
+    cls.add_method('GetAddressMatchingDestination', 
+                   'ns3::Ipv6InterfaceAddress', 
+                   [param('ns3::Ipv6Address', 'dst')])
+    ## ipv6-interface.h: uint16_t ns3::Ipv6Interface::GetBaseReachableTime() const [member function]
+    cls.add_method('GetBaseReachableTime', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
+    ## ipv6-interface.h: uint8_t ns3::Ipv6Interface::GetCurHopLimit() const [member function]
+    cls.add_method('GetCurHopLimit', 
+                   'uint8_t', 
+                   [], 
+                   is_const=True)
+    ## ipv6-interface.h: ns3::Ptr<ns3::NetDevice> ns3::Ipv6Interface::GetDevice() const [member function]
+    cls.add_method('GetDevice', 
+                   'ns3::Ptr< ns3::NetDevice >', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## ipv6-interface.h: ns3::Ipv6InterfaceAddress ns3::Ipv6Interface::GetLinkLocalAddress() const [member function]
+    cls.add_method('GetLinkLocalAddress', 
+                   'ns3::Ipv6InterfaceAddress', 
+                   [], 
+                   is_const=True)
+    ## ipv6-interface.h: uint16_t ns3::Ipv6Interface::GetMetric() const [member function]
+    cls.add_method('GetMetric', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
+    ## ipv6-interface.h: uint32_t ns3::Ipv6Interface::GetNAddresses() const [member function]
+    cls.add_method('GetNAddresses', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
+    ## ipv6-interface.h: uint16_t ns3::Ipv6Interface::GetReachableTime() const [member function]
+    cls.add_method('GetReachableTime', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
+    ## ipv6-interface.h: uint16_t ns3::Ipv6Interface::GetRetransTimer() const [member function]
+    cls.add_method('GetRetransTimer', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
+    ## ipv6-interface.h: static ns3::TypeId ns3::Ipv6Interface::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## ipv6-interface.h: bool ns3::Ipv6Interface::IsDown() const [member function]
+    cls.add_method('IsDown', 
+                   'bool', 
+                   [], 
+                   is_const=True)
+    ## ipv6-interface.h: bool ns3::Ipv6Interface::IsForwarding() const [member function]
+    cls.add_method('IsForwarding', 
+                   'bool', 
+                   [], 
+                   is_const=True)
+    ## ipv6-interface.h: bool ns3::Ipv6Interface::IsUp() const [member function]
+    cls.add_method('IsUp', 
+                   'bool', 
+                   [], 
+                   is_const=True)
+    ## ipv6-interface.h: ns3::Ipv6InterfaceAddress ns3::Ipv6Interface::RemoveAddress(uint32_t index) [member function]
+    cls.add_method('RemoveAddress', 
+                   'ns3::Ipv6InterfaceAddress', 
+                   [param('uint32_t', 'index')])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::Send(ns3::Ptr<ns3::Packet> p, ns3::Ipv6Address dest) [member function]
+    cls.add_method('Send', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv6Address', 'dest')])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::SetBaseReachableTime(uint16_t baseReachableTime) [member function]
+    cls.add_method('SetBaseReachableTime', 
+                   'void', 
+                   [param('uint16_t', 'baseReachableTime')])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::SetCurHopLimit(uint8_t curHopLimit) [member function]
+    cls.add_method('SetCurHopLimit', 
+                   'void', 
+                   [param('uint8_t', 'curHopLimit')])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::SetDevice(ns3::Ptr<ns3::NetDevice> device) [member function]
+    cls.add_method('SetDevice', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::NetDevice >', 'device')])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::SetDown() [member function]
+    cls.add_method('SetDown', 
+                   'void', 
+                   [])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::SetForwarding(bool forward) [member function]
+    cls.add_method('SetForwarding', 
+                   'void', 
+                   [param('bool', 'forward')])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::SetMetric(uint16_t metric) [member function]
+    cls.add_method('SetMetric', 
+                   'void', 
+                   [param('uint16_t', 'metric')])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::SetNode(ns3::Ptr<ns3::Node> node) [member function]
+    cls.add_method('SetNode', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Node >', 'node')])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::SetNsDadUid(ns3::Ipv6Address address, uint32_t uid) [member function]
+    cls.add_method('SetNsDadUid', 
+                   'void', 
+                   [param('ns3::Ipv6Address', 'address'), param('uint32_t', 'uid')])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::SetReachableTime(uint16_t reachableTime) [member function]
+    cls.add_method('SetReachableTime', 
+                   'void', 
+                   [param('uint16_t', 'reachableTime')])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::SetRetransTimer(uint16_t retransTimer) [member function]
+    cls.add_method('SetRetransTimer', 
+                   'void', 
+                   [param('uint16_t', 'retransTimer')])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::SetState(ns3::Ipv6Address address, ns3::Ipv6InterfaceAddress::State_e state) [member function]
+    cls.add_method('SetState', 
+                   'void', 
+                   [param('ns3::Ipv6Address', 'address'), param('ns3::Ipv6InterfaceAddress::State_e', 'state')])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::SetUp() [member function]
+    cls.add_method('SetUp', 
+                   'void', 
+                   [])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
+    return
+
 def register_Ns3Ipv6L3Protocol_methods(root_module, cls):
     ## ipv6-l3-protocol.h: ns3::Ipv6L3Protocol::PROT_NUMBER [variable]
     cls.add_static_attribute('PROT_NUMBER', 'uint16_t const', is_const=True)
@@ -3430,10 +3654,6 @@ def register_Ns3Icmpv6L4Protocol_methods(root_module, cls):
     cls.add_method('DoDAD', 
                    'void', 
                    [param('ns3::Ipv6Address', 'target'), param('ns3::Ptr< ns3::Ipv6Interface >', 'interface')])
-    ## icmpv6-l4-protocol.h: void ns3::Icmpv6L4Protocol::DoDad(ns3::Ipv6Address addr, ns3::Ptr<ns3::Ipv6Interface> interface) [member function]
-    cls.add_method('DoDad', 
-                   'void', 
-                   [param('ns3::Ipv6Address', 'addr'), param('ns3::Ptr< ns3::Ipv6Interface >', 'interface')])
     ## icmpv6-l4-protocol.h: ns3::Ptr<ns3::Packet> ns3::Icmpv6L4Protocol::ForgeEchoRequest(ns3::Ipv6Address src, ns3::Ipv6Address dst, uint16_t id, uint16_t seq, ns3::Ptr<ns3::Packet> data) [member function]
     cls.add_method('ForgeEchoRequest', 
                    'ns3::Ptr< ns3::Packet >', 

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

@@ -111,7 +111,7 @@ def register_Ns3Ipv4ListRouting_methods(root_module, cls):
     ## ipv4-list-routing.h: ns3::Ptr<ns3::Ipv4RoutingProtocol> ns3::Ipv4ListRouting::GetRoutingProtocol(uint32_t index, int16_t & priority) const [member function]
     cls.add_method('GetRoutingProtocol', 
                    'ns3::Ptr< ns3::Ipv4RoutingProtocol >', 
-                   [param('uint32_t', 'index'), param('int16_t &', 'priority')], 
+                   [param('uint32_t', 'index'), param('int16_t &', 'priority', direction=2)], 
                    is_const=True, is_virtual=True)
     ## ipv4-list-routing.h: static ns3::TypeId ns3::Ipv4ListRouting::GetTypeId() [member function]
     cls.add_method('GetTypeId', 

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

@@ -385,6 +385,11 @@ def register_Ns3MeshWifiInterfaceMac_methods(root_module, cls):
                    'ns3::TypeId', 
                    [], 
                    is_static=True)
+    ## mesh-wifi-interface-mac.h: ns3::Ptr<ns3::WifiPhy> ns3::MeshWifiInterfaceMac::GetWifiPhy() const [member function]
+    cls.add_method('GetWifiPhy', 
+                   'ns3::Ptr< ns3::WifiPhy >', 
+                   [], 
+                   is_const=True)
     ## mesh-wifi-interface-mac.h: void ns3::MeshWifiInterfaceMac::InstallPlugin(ns3::Ptr<ns3::MeshWifiInterfaceMacPlugin> plugin) [member function]
     cls.add_method('InstallPlugin', 
                    'void', 
@@ -509,6 +514,11 @@ def register_Ns3MeshWifiInterfaceMac_methods(root_module, cls):
                    'void', 
                    [], 
                    visibility='private', is_virtual=True)
+    ## mesh-wifi-interface-mac.h: void ns3::MeshWifiInterfaceMac::DoStart() [member function]
+    cls.add_method('DoStart', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
     ## mesh-wifi-interface-mac.h: void ns3::MeshWifiInterfaceMac::ForwardUp(ns3::Ptr<ns3::Packet> packet, ns3::Mac48Address src, ns3::Mac48Address dst) [member function]
     cls.add_method('ForwardUp', 
                    'void', 

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

@@ -3,8 +3,12 @@ from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandler
 def register_types(module):
     root_module = module.get_root()
     
+    ## box.h: ns3::Box [class]
+    module.add_class('Box')
+    ## box.h: ns3::Box::Side [enumeration]
+    module.add_enum('Side', ['RIGHT', 'LEFT', 'TOP', 'BOTTOM', 'UP', 'DOWN'], outer_class=root_module['ns3::Box'])
     ## constant-velocity-helper.h: ns3::ConstantVelocityHelper [class]
-    module.add_class('ConstantVelocityHelper', allow_subclassing=False)
+    module.add_class('ConstantVelocityHelper')
     ## rectangle.h: ns3::Rectangle [class]
     module.add_class('Rectangle')
     ## rectangle.h: ns3::Rectangle::Side [enumeration]
@@ -13,12 +17,18 @@ def register_types(module):
     module.add_class('Waypoint')
     ## position-allocator.h: ns3::PositionAllocator [class]
     module.add_class('PositionAllocator', parent=root_module['ns3::Object'])
+    ## position-allocator.h: ns3::RandomBoxPositionAllocator [class]
+    module.add_class('RandomBoxPositionAllocator', parent=root_module['ns3::PositionAllocator'])
     ## 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'])
     ## position-allocator.h: ns3::UniformDiscPositionAllocator [class]
     module.add_class('UniformDiscPositionAllocator', parent=root_module['ns3::PositionAllocator'])
+    ## box.h: ns3::BoxChecker [class]
+    module.add_class('BoxChecker', parent=root_module['ns3::AttributeChecker'])
+    ## box.h: ns3::BoxValue [class]
+    module.add_class('BoxValue', parent=root_module['ns3::AttributeValue'])
     ## position-allocator.h: ns3::GridPositionAllocator [class]
     module.add_class('GridPositionAllocator', parent=root_module['ns3::PositionAllocator'])
     ## position-allocator.h: ns3::GridPositionAllocator::LayoutType [enumeration]
@@ -39,6 +49,8 @@ def register_types(module):
     module.add_class('RectangleChecker', parent=root_module['ns3::AttributeChecker'])
     ## rectangle.h: ns3::RectangleValue [class]
     module.add_class('RectangleValue', parent=root_module['ns3::AttributeValue'])
+    ## steady-state-random-waypoint-mobility-model.h: ns3::SteadyStateRandomWaypointMobilityModel [class]
+    module.add_class('SteadyStateRandomWaypointMobilityModel', parent=root_module['ns3::MobilityModel'])
     ## waypoint.h: ns3::WaypointChecker [class]
     module.add_class('WaypointChecker', parent=root_module['ns3::AttributeChecker'])
     ## waypoint-mobility-model.h: ns3::WaypointMobilityModel [class]
@@ -51,6 +63,8 @@ def register_types(module):
     module.add_class('ConstantPositionMobilityModel', parent=root_module['ns3::MobilityModel'])
     ## constant-velocity-mobility-model.h: ns3::ConstantVelocityMobilityModel [class]
     module.add_class('ConstantVelocityMobilityModel', parent=root_module['ns3::MobilityModel'])
+    ## gauss-markov-mobility-model.h: ns3::GaussMarkovMobilityModel [class]
+    module.add_class('GaussMarkovMobilityModel', parent=root_module['ns3::MobilityModel'])
     ## hierarchical-mobility-model.h: ns3::HierarchicalMobilityModel [class]
     module.add_class('HierarchicalMobilityModel', parent=root_module['ns3::MobilityModel'])
     
@@ -135,13 +149,17 @@ def register_types_ns3_olsr(module):
     
 
 def register_methods(root_module):
+    register_Ns3Box_methods(root_module, root_module['ns3::Box'])
     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_Ns3RandomBoxPositionAllocator_methods(root_module, root_module['ns3::RandomBoxPositionAllocator'])
     register_Ns3RandomDiscPositionAllocator_methods(root_module, root_module['ns3::RandomDiscPositionAllocator'])
     register_Ns3RandomRectanglePositionAllocator_methods(root_module, root_module['ns3::RandomRectanglePositionAllocator'])
     register_Ns3UniformDiscPositionAllocator_methods(root_module, root_module['ns3::UniformDiscPositionAllocator'])
+    register_Ns3BoxChecker_methods(root_module, root_module['ns3::BoxChecker'])
+    register_Ns3BoxValue_methods(root_module, root_module['ns3::BoxValue'])
     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'])
@@ -150,15 +168,54 @@ def register_methods(root_module):
     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_Ns3SteadyStateRandomWaypointMobilityModel_methods(root_module, root_module['ns3::SteadyStateRandomWaypointMobilityModel'])
     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'])
+    register_Ns3GaussMarkovMobilityModel_methods(root_module, root_module['ns3::GaussMarkovMobilityModel'])
     register_Ns3HierarchicalMobilityModel_methods(root_module, root_module['ns3::HierarchicalMobilityModel'])
     return
 
+def register_Ns3Box_methods(root_module, cls):
+    cls.add_output_stream_operator()
+    ## box.h: ns3::Box::Box(ns3::Box const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::Box const &', 'arg0')])
+    ## box.h: ns3::Box::Box(double _xMin, double _xMax, double _yMin, double _yMax, double _zMin, double _zMax) [constructor]
+    cls.add_constructor([param('double', '_xMin'), param('double', '_xMax'), param('double', '_yMin'), param('double', '_yMax'), param('double', '_zMin'), param('double', '_zMax')])
+    ## box.h: ns3::Box::Box() [constructor]
+    cls.add_constructor([])
+    ## box.h: ns3::Vector ns3::Box::CalculateIntersection(ns3::Vector const & current, ns3::Vector const & speed) const [member function]
+    cls.add_method('CalculateIntersection', 
+                   'ns3::Vector', 
+                   [param('ns3::Vector const &', 'current'), param('ns3::Vector const &', 'speed')], 
+                   is_const=True)
+    ## box.h: ns3::Box::Side ns3::Box::GetClosestSide(ns3::Vector const & position) const [member function]
+    cls.add_method('GetClosestSide', 
+                   'ns3::Box::Side', 
+                   [param('ns3::Vector const &', 'position')], 
+                   is_const=True)
+    ## box.h: bool ns3::Box::IsInside(ns3::Vector const & position) const [member function]
+    cls.add_method('IsInside', 
+                   'bool', 
+                   [param('ns3::Vector const &', 'position')], 
+                   is_const=True)
+    ## box.h: ns3::Box::xMax [variable]
+    cls.add_instance_attribute('xMax', 'double', is_const=False)
+    ## box.h: ns3::Box::xMin [variable]
+    cls.add_instance_attribute('xMin', 'double', is_const=False)
+    ## box.h: ns3::Box::yMax [variable]
+    cls.add_instance_attribute('yMax', 'double', is_const=False)
+    ## box.h: ns3::Box::yMin [variable]
+    cls.add_instance_attribute('yMin', 'double', is_const=False)
+    ## box.h: ns3::Box::zMax [variable]
+    cls.add_instance_attribute('zMax', 'double', is_const=False)
+    ## box.h: ns3::Box::zMin [variable]
+    cls.add_instance_attribute('zMin', 'double', is_const=False)
+    return
+
 def register_Ns3ConstantVelocityHelper_methods(root_module, cls):
     ## constant-velocity-helper.h: ns3::ConstantVelocityHelper::ConstantVelocityHelper(ns3::ConstantVelocityHelper const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::ConstantVelocityHelper const &', 'arg0')])
@@ -204,6 +261,11 @@ def register_Ns3ConstantVelocityHelper_methods(root_module, cls):
                    'void', 
                    [param('ns3::Rectangle const &', 'rectangle')], 
                    is_const=True)
+    ## constant-velocity-helper.h: void ns3::ConstantVelocityHelper::UpdateWithBounds(ns3::Box const & bounds) const [member function]
+    cls.add_method('UpdateWithBounds', 
+                   'void', 
+                   [param('ns3::Box const &', 'bounds')], 
+                   is_const=True)
     return
 
 def register_Ns3Rectangle_methods(root_module, cls):
@@ -270,6 +332,35 @@ def register_Ns3PositionAllocator_methods(root_module, cls):
                    is_static=True)
     return
 
+def register_Ns3RandomBoxPositionAllocator_methods(root_module, cls):
+    ## position-allocator.h: ns3::RandomBoxPositionAllocator::RandomBoxPositionAllocator(ns3::RandomBoxPositionAllocator const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::RandomBoxPositionAllocator const &', 'arg0')])
+    ## position-allocator.h: ns3::RandomBoxPositionAllocator::RandomBoxPositionAllocator() [constructor]
+    cls.add_constructor([])
+    ## position-allocator.h: ns3::Vector ns3::RandomBoxPositionAllocator::GetNext() const [member function]
+    cls.add_method('GetNext', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## position-allocator.h: static ns3::TypeId ns3::RandomBoxPositionAllocator::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## position-allocator.h: void ns3::RandomBoxPositionAllocator::SetX(ns3::RandomVariable x) [member function]
+    cls.add_method('SetX', 
+                   'void', 
+                   [param('ns3::RandomVariable', 'x')])
+    ## position-allocator.h: void ns3::RandomBoxPositionAllocator::SetY(ns3::RandomVariable y) [member function]
+    cls.add_method('SetY', 
+                   'void', 
+                   [param('ns3::RandomVariable', 'y')])
+    ## position-allocator.h: void ns3::RandomBoxPositionAllocator::SetZ(ns3::RandomVariable z) [member function]
+    cls.add_method('SetZ', 
+                   'void', 
+                   [param('ns3::RandomVariable', 'z')])
+    return
+
 def register_Ns3RandomDiscPositionAllocator_methods(root_module, cls):
     ## position-allocator.h: ns3::RandomDiscPositionAllocator::RandomDiscPositionAllocator(ns3::RandomDiscPositionAllocator const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::RandomDiscPositionAllocator const &', 'arg0')])
@@ -357,6 +448,46 @@ def register_Ns3UniformDiscPositionAllocator_methods(root_module, cls):
                    [param('double', 'y')])
     return
 
+def register_Ns3BoxChecker_methods(root_module, cls):
+    ## box.h: ns3::BoxChecker::BoxChecker() [constructor]
+    cls.add_constructor([])
+    ## box.h: ns3::BoxChecker::BoxChecker(ns3::BoxChecker const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::BoxChecker const &', 'arg0')])
+    return
+
+def register_Ns3BoxValue_methods(root_module, cls):
+    ## box.h: ns3::BoxValue::BoxValue() [constructor]
+    cls.add_constructor([])
+    ## box.h: ns3::BoxValue::BoxValue(ns3::BoxValue const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::BoxValue const &', 'arg0')])
+    ## box.h: ns3::BoxValue::BoxValue(ns3::Box const & value) [constructor]
+    cls.add_constructor([param('ns3::Box const &', 'value')])
+    ## box.h: ns3::Ptr<ns3::AttributeValue> ns3::BoxValue::Copy() const [member function]
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## box.h: bool ns3::BoxValue::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)
+    ## box.h: ns3::Box ns3::BoxValue::Get() const [member function]
+    cls.add_method('Get', 
+                   'ns3::Box', 
+                   [], 
+                   is_const=True)
+    ## box.h: std::string ns3::BoxValue::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)
+    ## box.h: void ns3::BoxValue::Set(ns3::Box const & value) [member function]
+    cls.add_method('Set', 
+                   'void', 
+                   [param('ns3::Box const &', 'value')])
+    return
+
 def register_Ns3GridPositionAllocator_methods(root_module, cls):
     ## position-allocator.h: ns3::GridPositionAllocator::GridPositionAllocator(ns3::GridPositionAllocator const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::GridPositionAllocator const &', 'arg0')])
@@ -646,6 +777,38 @@ def register_Ns3RectangleValue_methods(root_module, cls):
                    [param('ns3::Rectangle const &', 'value')])
     return
 
+def register_Ns3SteadyStateRandomWaypointMobilityModel_methods(root_module, cls):
+    ## steady-state-random-waypoint-mobility-model.h: ns3::SteadyStateRandomWaypointMobilityModel::SteadyStateRandomWaypointMobilityModel(ns3::SteadyStateRandomWaypointMobilityModel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::SteadyStateRandomWaypointMobilityModel const &', 'arg0')])
+    ## steady-state-random-waypoint-mobility-model.h: ns3::SteadyStateRandomWaypointMobilityModel::SteadyStateRandomWaypointMobilityModel() [constructor]
+    cls.add_constructor([])
+    ## steady-state-random-waypoint-mobility-model.h: static ns3::TypeId ns3::SteadyStateRandomWaypointMobilityModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## steady-state-random-waypoint-mobility-model.h: void ns3::SteadyStateRandomWaypointMobilityModel::DoStart() [member function]
+    cls.add_method('DoStart', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
+    ## steady-state-random-waypoint-mobility-model.h: ns3::Vector ns3::SteadyStateRandomWaypointMobilityModel::DoGetPosition() const [member function]
+    cls.add_method('DoGetPosition', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, visibility='private', is_virtual=True)
+    ## steady-state-random-waypoint-mobility-model.h: ns3::Vector ns3::SteadyStateRandomWaypointMobilityModel::DoGetVelocity() const [member function]
+    cls.add_method('DoGetVelocity', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, visibility='private', is_virtual=True)
+    ## steady-state-random-waypoint-mobility-model.h: void ns3::SteadyStateRandomWaypointMobilityModel::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_Ns3WaypointChecker_methods(root_module, cls):
     ## waypoint.h: ns3::WaypointChecker::WaypointChecker() [constructor]
     cls.add_constructor([])
@@ -825,6 +988,38 @@ def register_Ns3ConstantVelocityMobilityModel_methods(root_module, cls):
                    visibility='private', is_virtual=True)
     return
 
+def register_Ns3GaussMarkovMobilityModel_methods(root_module, cls):
+    ## gauss-markov-mobility-model.h: ns3::GaussMarkovMobilityModel::GaussMarkovMobilityModel(ns3::GaussMarkovMobilityModel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::GaussMarkovMobilityModel const &', 'arg0')])
+    ## gauss-markov-mobility-model.h: ns3::GaussMarkovMobilityModel::GaussMarkovMobilityModel() [constructor]
+    cls.add_constructor([])
+    ## gauss-markov-mobility-model.h: static ns3::TypeId ns3::GaussMarkovMobilityModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## gauss-markov-mobility-model.h: void ns3::GaussMarkovMobilityModel::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
+    ## gauss-markov-mobility-model.h: ns3::Vector ns3::GaussMarkovMobilityModel::DoGetPosition() const [member function]
+    cls.add_method('DoGetPosition', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, visibility='private', is_virtual=True)
+    ## gauss-markov-mobility-model.h: ns3::Vector ns3::GaussMarkovMobilityModel::DoGetVelocity() const [member function]
+    cls.add_method('DoGetVelocity', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, visibility='private', is_virtual=True)
+    ## gauss-markov-mobility-model.h: void ns3::GaussMarkovMobilityModel::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_Ns3HierarchicalMobilityModel_methods(root_module, cls):
     ## hierarchical-mobility-model.h: ns3::HierarchicalMobilityModel::HierarchicalMobilityModel(ns3::HierarchicalMobilityModel const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::HierarchicalMobilityModel const &', 'arg0')])
@@ -872,6 +1067,10 @@ def register_Ns3HierarchicalMobilityModel_methods(root_module, cls):
 
 def register_functions(root_module):
     module = root_module
+    ## box.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeBoxChecker() [free function]
+    module.add_function('MakeBoxChecker', 
+                        'ns3::Ptr< ns3::AttributeChecker const >', 
+                        [])
     ## rectangle.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeRectangleChecker() [free function]
     module.add_function('MakeRectangleChecker', 
                         'ns3::Ptr< ns3::AttributeChecker const >', 

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

@@ -0,0 +1,355 @@
+from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandlers
+
+def register_types(module):
+    root_module = module.get_root()
+    
+    ## distributed-simulator-impl.h: ns3::LbtsMessage [class]
+    module.add_class('LbtsMessage')
+    ## mpi-interface.h: ns3::MpiInterface [class]
+    module.add_class('MpiInterface')
+    ## mpi-interface.h: ns3::SentBuffer [class]
+    module.add_class('SentBuffer')
+    ## distributed-simulator-impl.h: ns3::DistributedSimulatorImpl [class]
+    module.add_class('DistributedSimulatorImpl', parent=root_module['ns3::SimulatorImpl'])
+    
+    ## 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_Ns3LbtsMessage_methods(root_module, root_module['ns3::LbtsMessage'])
+    register_Ns3MpiInterface_methods(root_module, root_module['ns3::MpiInterface'])
+    register_Ns3SentBuffer_methods(root_module, root_module['ns3::SentBuffer'])
+    register_Ns3DistributedSimulatorImpl_methods(root_module, root_module['ns3::DistributedSimulatorImpl'])
+    return
+
+def register_Ns3LbtsMessage_methods(root_module, cls):
+    ## distributed-simulator-impl.h: ns3::LbtsMessage::LbtsMessage(ns3::LbtsMessage const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::LbtsMessage const &', 'arg0')])
+    ## distributed-simulator-impl.h: ns3::LbtsMessage::LbtsMessage() [constructor]
+    cls.add_constructor([])
+    ## distributed-simulator-impl.h: ns3::LbtsMessage::LbtsMessage(uint32_t rxc, uint32_t txc, uint32_t id, ns3::Time const & t) [constructor]
+    cls.add_constructor([param('uint32_t', 'rxc'), param('uint32_t', 'txc'), param('uint32_t', 'id'), param('ns3::Time const &', 't')])
+    ## distributed-simulator-impl.h: uint32_t ns3::LbtsMessage::GetMyId() [member function]
+    cls.add_method('GetMyId', 
+                   'uint32_t', 
+                   [])
+    ## distributed-simulator-impl.h: uint32_t ns3::LbtsMessage::GetRxCount() [member function]
+    cls.add_method('GetRxCount', 
+                   'uint32_t', 
+                   [])
+    ## distributed-simulator-impl.h: ns3::Time ns3::LbtsMessage::GetSmallestTime() [member function]
+    cls.add_method('GetSmallestTime', 
+                   'ns3::Time', 
+                   [])
+    ## distributed-simulator-impl.h: uint32_t ns3::LbtsMessage::GetTxCount() [member function]
+    cls.add_method('GetTxCount', 
+                   'uint32_t', 
+                   [])
+    return
+
+def register_Ns3MpiInterface_methods(root_module, cls):
+    ## mpi-interface.h: ns3::MpiInterface::MpiInterface() [constructor]
+    cls.add_constructor([])
+    ## mpi-interface.h: ns3::MpiInterface::MpiInterface(ns3::MpiInterface const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::MpiInterface const &', 'arg0')])
+    ## mpi-interface.h: static void ns3::MpiInterface::Destroy() [member function]
+    cls.add_method('Destroy', 
+                   'void', 
+                   [], 
+                   is_static=True)
+    ## mpi-interface.h: static void ns3::MpiInterface::Enable(int * arg0, char * * * arg1) [member function]
+    cls.add_method('Enable', 
+                   'void', 
+                   [param('int *', 'arg0'), param('char * * *', 'arg1')], 
+                   is_static=True)
+    ## mpi-interface.h: static uint32_t ns3::MpiInterface::GetRxCount() [member function]
+    cls.add_method('GetRxCount', 
+                   'uint32_t', 
+                   [], 
+                   is_static=True)
+    ## mpi-interface.h: static uint32_t ns3::MpiInterface::GetSize() [member function]
+    cls.add_method('GetSize', 
+                   'uint32_t', 
+                   [], 
+                   is_static=True)
+    ## mpi-interface.h: static uint32_t ns3::MpiInterface::GetSystemId() [member function]
+    cls.add_method('GetSystemId', 
+                   'uint32_t', 
+                   [], 
+                   is_static=True)
+    ## mpi-interface.h: static uint32_t ns3::MpiInterface::GetTxCount() [member function]
+    cls.add_method('GetTxCount', 
+                   'uint32_t', 
+                   [], 
+                   is_static=True)
+    ## mpi-interface.h: static bool ns3::MpiInterface::IsEnabled() [member function]
+    cls.add_method('IsEnabled', 
+                   'bool', 
+                   [], 
+                   is_static=True)
+    ## mpi-interface.h: static void ns3::MpiInterface::ReceiveMessages() [member function]
+    cls.add_method('ReceiveMessages', 
+                   'void', 
+                   [], 
+                   is_static=True)
+    ## mpi-interface.h: static void ns3::MpiInterface::SendPacket(ns3::Ptr<ns3::Packet> arg0, ns3::Time const & arg1, uint32_t arg2, uint32_t arg3) [member function]
+    cls.add_method('SendPacket', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Packet >', 'arg0'), param('ns3::Time const &', 'arg1'), param('uint32_t', 'arg2'), param('uint32_t', 'arg3')], 
+                   is_static=True)
+    ## mpi-interface.h: static void ns3::MpiInterface::TestSendComplete() [member function]
+    cls.add_method('TestSendComplete', 
+                   'void', 
+                   [], 
+                   is_static=True)
+    return
+
+def register_Ns3SentBuffer_methods(root_module, cls):
+    ## mpi-interface.h: ns3::SentBuffer::SentBuffer(ns3::SentBuffer const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::SentBuffer const &', 'arg0')])
+    ## mpi-interface.h: ns3::SentBuffer::SentBuffer() [constructor]
+    cls.add_constructor([])
+    ## mpi-interface.h: uint8_t * ns3::SentBuffer::GetBuffer() [member function]
+    cls.add_method('GetBuffer', 
+                   'uint8_t *', 
+                   [])
+    ## mpi-interface.h: MPI_Request * ns3::SentBuffer::GetRequest() [member function]
+    cls.add_method('GetRequest', 
+                   'MPI_Request *', 
+                   [])
+    ## mpi-interface.h: void ns3::SentBuffer::SetBuffer(uint8_t * arg0) [member function]
+    cls.add_method('SetBuffer', 
+                   'void', 
+                   [param('uint8_t *', 'arg0')])
+    return
+
+def register_Ns3DistributedSimulatorImpl_methods(root_module, cls):
+    ## distributed-simulator-impl.h: ns3::DistributedSimulatorImpl::DistributedSimulatorImpl(ns3::DistributedSimulatorImpl const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::DistributedSimulatorImpl const &', 'arg0')])
+    ## distributed-simulator-impl.h: ns3::DistributedSimulatorImpl::DistributedSimulatorImpl() [constructor]
+    cls.add_constructor([])
+    ## distributed-simulator-impl.h: void ns3::DistributedSimulatorImpl::Cancel(ns3::EventId const & ev) [member function]
+    cls.add_method('Cancel', 
+                   'void', 
+                   [param('ns3::EventId const &', 'ev')], 
+                   is_virtual=True)
+    ## distributed-simulator-impl.h: void ns3::DistributedSimulatorImpl::Destroy() [member function]
+    cls.add_method('Destroy', 
+                   'void', 
+                   [], 
+                   is_virtual=True)
+    ## distributed-simulator-impl.h: uint32_t ns3::DistributedSimulatorImpl::GetContext() const [member function]
+    cls.add_method('GetContext', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## distributed-simulator-impl.h: ns3::Time ns3::DistributedSimulatorImpl::GetDelayLeft(ns3::EventId const & id) const [member function]
+    cls.add_method('GetDelayLeft', 
+                   'ns3::Time', 
+                   [param('ns3::EventId const &', 'id')], 
+                   is_const=True, is_virtual=True)
+    ## distributed-simulator-impl.h: ns3::Time ns3::DistributedSimulatorImpl::GetMaximumSimulationTime() const [member function]
+    cls.add_method('GetMaximumSimulationTime', 
+                   'ns3::Time', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## distributed-simulator-impl.h: uint32_t ns3::DistributedSimulatorImpl::GetSystemId() const [member function]
+    cls.add_method('GetSystemId', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## distributed-simulator-impl.h: static ns3::TypeId ns3::DistributedSimulatorImpl::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## distributed-simulator-impl.h: bool ns3::DistributedSimulatorImpl::IsExpired(ns3::EventId const & ev) const [member function]
+    cls.add_method('IsExpired', 
+                   'bool', 
+                   [param('ns3::EventId const &', 'ev')], 
+                   is_const=True, is_virtual=True)
+    ## distributed-simulator-impl.h: bool ns3::DistributedSimulatorImpl::IsFinished() const [member function]
+    cls.add_method('IsFinished', 
+                   'bool', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## distributed-simulator-impl.h: ns3::Time ns3::DistributedSimulatorImpl::Next() const [member function]
+    cls.add_method('Next', 
+                   'ns3::Time', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## distributed-simulator-impl.h: ns3::Time ns3::DistributedSimulatorImpl::Now() const [member function]
+    cls.add_method('Now', 
+                   'ns3::Time', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## distributed-simulator-impl.h: void ns3::DistributedSimulatorImpl::Remove(ns3::EventId const & ev) [member function]
+    cls.add_method('Remove', 
+                   'void', 
+                   [param('ns3::EventId const &', 'ev')], 
+                   is_virtual=True)
+    ## distributed-simulator-impl.h: void ns3::DistributedSimulatorImpl::Run() [member function]
+    cls.add_method('Run', 
+                   'void', 
+                   [], 
+                   is_virtual=True)
+    ## distributed-simulator-impl.h: void ns3::DistributedSimulatorImpl::RunOneEvent() [member function]
+    cls.add_method('RunOneEvent', 
+                   'void', 
+                   [], 
+                   is_virtual=True)
+    ## distributed-simulator-impl.h: ns3::EventId ns3::DistributedSimulatorImpl::Schedule(ns3::Time const & time, ns3::EventImpl * event) [member function]
+    cls.add_method('Schedule', 
+                   'ns3::EventId', 
+                   [param('ns3::Time const &', 'time'), param('ns3::EventImpl *', 'event')], 
+                   is_virtual=True)
+    ## distributed-simulator-impl.h: ns3::EventId ns3::DistributedSimulatorImpl::ScheduleDestroy(ns3::EventImpl * event) [member function]
+    cls.add_method('ScheduleDestroy', 
+                   'ns3::EventId', 
+                   [param('ns3::EventImpl *', 'event')], 
+                   is_virtual=True)
+    ## distributed-simulator-impl.h: ns3::EventId ns3::DistributedSimulatorImpl::ScheduleNow(ns3::EventImpl * event) [member function]
+    cls.add_method('ScheduleNow', 
+                   'ns3::EventId', 
+                   [param('ns3::EventImpl *', 'event')], 
+                   is_virtual=True)
+    ## distributed-simulator-impl.h: void ns3::DistributedSimulatorImpl::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)
+    ## distributed-simulator-impl.h: void ns3::DistributedSimulatorImpl::SetScheduler(ns3::ObjectFactory schedulerFactory) [member function]
+    cls.add_method('SetScheduler', 
+                   'void', 
+                   [param('ns3::ObjectFactory', 'schedulerFactory')], 
+                   is_virtual=True)
+    ## distributed-simulator-impl.h: void ns3::DistributedSimulatorImpl::Stop() [member function]
+    cls.add_method('Stop', 
+                   'void', 
+                   [], 
+                   is_virtual=True)
+    ## distributed-simulator-impl.h: void ns3::DistributedSimulatorImpl::Stop(ns3::Time const & time) [member function]
+    cls.add_method('Stop', 
+                   'void', 
+                   [param('ns3::Time const &', 'time')], 
+                   is_virtual=True)
+    ## distributed-simulator-impl.h: void ns3::DistributedSimulatorImpl::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   '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_nix_vector_routing.py

@@ -110,10 +110,10 @@ def register_Ns3Ipv4NixVectorRouting_methods(root_module, cls):
                    'ns3::TypeId', 
                    [], 
                    is_static=True)
-    ## ipv4-nix-vector-routing.h: void ns3::Ipv4NixVectorRouting::SetNode(ns3::Ptr<ns3::Node> arg0) [member function]
+    ## ipv4-nix-vector-routing.h: void ns3::Ipv4NixVectorRouting::SetNode(ns3::Ptr<ns3::Node> node) [member function]
     cls.add_method('SetNode', 
                    'void', 
-                   [param('ns3::Ptr< ns3::Node >', 'arg0')])
+                   [param('ns3::Ptr< ns3::Node >', 'node')])
     ## ipv4-nix-vector-routing.h: void ns3::Ipv4NixVectorRouting::DoDispose() [member function]
     cls.add_method('DoDispose', 
                    'void', 

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

@@ -73,6 +73,12 @@ def register_types(module):
     module.add_class('LlcSnapHeader', parent=root_module['ns3::Header'])
     ## queue.h: ns3::Queue [class]
     module.add_class('Queue', parent=root_module['ns3::Object'])
+    ## radiotap-header.h: ns3::RadiotapHeader [class]
+    module.add_class('RadiotapHeader', parent=root_module['ns3::Header'])
+    ## radiotap-header.h: ns3::RadiotapHeader [enumeration]
+    module.add_enum('', ['FRAME_FLAG_NONE', 'FRAME_FLAG_CFP', 'FRAME_FLAG_SHORT_PREAMBLE', 'FRAME_FLAG_WEP', 'FRAME_FLAG_FRAGMENTED', 'FRAME_FLAG_FCS_INCLUDED', 'FRAME_FLAG_DATA_PADDING', 'FRAME_FLAG_BAD_FCS', 'FRAME_FLAG_SHORT_GUARD'], outer_class=root_module['ns3::RadiotapHeader'])
+    ## radiotap-header.h: ns3::RadiotapHeader [enumeration]
+    module.add_enum('', ['CHANNEL_FLAG_NONE', 'CHANNEL_FLAG_TURBO', 'CHANNEL_FLAG_CCK', 'CHANNEL_FLAG_OFDM', 'CHANNEL_FLAG_SPECTRUM_2GHZ', 'CHANNEL_FLAG_SPECTRUM_5GHZ', 'CHANNEL_FLAG_PASSIVE', 'CHANNEL_FLAG_DYNAMIC', 'CHANNEL_FLAG_GFSK'], outer_class=root_module['ns3::RadiotapHeader'])
     ## simple-ref-count.h: ns3::SimpleRefCount<ns3::Ipv4MulticastRoute, ns3::empty, ns3::DefaultDeleter<ns3::Ipv4MulticastRoute> > [class]
     module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::Ipv4MulticastRoute', 'ns3::empty', 'ns3::DefaultDeleter<ns3::Ipv4MulticastRoute>'], 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::Ipv4Route, ns3::empty, ns3::DefaultDeleter<ns3::Ipv4Route> > [class]
@@ -92,7 +98,7 @@ def register_types(module):
     ## socket.h: ns3::Socket [class]
     module.add_class('Socket', parent=root_module['ns3::Object'])
     ## socket.h: ns3::Socket::SocketErrno [enumeration]
-    module.add_enum('SocketErrno', ['ERROR_NOTERROR', 'ERROR_ISCONN', 'ERROR_NOTCONN', 'ERROR_MSGSIZE', 'ERROR_AGAIN', 'ERROR_SHUTDOWN', 'ERROR_OPNOTSUPP', 'ERROR_AFNOSUPPORT', 'ERROR_INVAL', 'ERROR_BADF', 'ERROR_NOROUTETOHOST', 'SOCKET_ERRNO_LAST'], outer_class=root_module['ns3::Socket'])
+    module.add_enum('SocketErrno', ['ERROR_NOTERROR', 'ERROR_ISCONN', 'ERROR_NOTCONN', 'ERROR_MSGSIZE', 'ERROR_AGAIN', 'ERROR_SHUTDOWN', 'ERROR_OPNOTSUPP', 'ERROR_AFNOSUPPORT', 'ERROR_INVAL', 'ERROR_BADF', 'ERROR_NOROUTETOHOST', 'ERROR_NODEV', 'ERROR_ADDRNOTAVAIL', 'SOCKET_ERRNO_LAST'], outer_class=root_module['ns3::Socket'])
     ## socket.h: ns3::SocketAddressTag [class]
     module.add_class('SocketAddressTag', parent=root_module['ns3::Tag'])
     ## socket-factory.h: ns3::SocketFactory [class]
@@ -302,6 +308,7 @@ def register_methods(root_module):
     register_Ns3Ipv6Header_methods(root_module, root_module['ns3::Ipv6Header'])
     register_Ns3LlcSnapHeader_methods(root_module, root_module['ns3::LlcSnapHeader'])
     register_Ns3Queue_methods(root_module, root_module['ns3::Queue'])
+    register_Ns3RadiotapHeader_methods(root_module, root_module['ns3::RadiotapHeader'])
     register_Ns3Socket_methods(root_module, root_module['ns3::Socket'])
     register_Ns3SocketAddressTag_methods(root_module, root_module['ns3::SocketAddressTag'])
     register_Ns3SocketFactory_methods(root_module, root_module['ns3::SocketFactory'])
@@ -610,6 +617,11 @@ def register_Ns3Ipv4Address_methods(root_module, cls):
                    'bool', 
                    [param('ns3::Ipv4Address const &', 'other')], 
                    is_const=True)
+    ## ipv4-address.h: bool ns3::Ipv4Address::IsLocalMulticast() const [member function]
+    cls.add_method('IsLocalMulticast', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## ipv4-address.h: static bool ns3::Ipv4Address::IsMatchingType(ns3::Address const & address) [member function]
     cls.add_method('IsMatchingType', 
                    'bool', 
@@ -1864,6 +1876,110 @@ def register_Ns3Queue_methods(root_module, cls):
                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
     return
 
+def register_Ns3RadiotapHeader_methods(root_module, cls):
+    ## radiotap-header.h: ns3::RadiotapHeader::RadiotapHeader(ns3::RadiotapHeader const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::RadiotapHeader const &', 'arg0')])
+    ## radiotap-header.h: ns3::RadiotapHeader::RadiotapHeader() [constructor]
+    cls.add_constructor([])
+    ## radiotap-header.h: uint32_t ns3::RadiotapHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
+    cls.add_method('Deserialize', 
+                   'uint32_t', 
+                   [param('ns3::Buffer::Iterator', 'start')], 
+                   is_virtual=True)
+    ## radiotap-header.h: uint8_t ns3::RadiotapHeader::GetAntennaNoisePower() const [member function]
+    cls.add_method('GetAntennaNoisePower', 
+                   'uint8_t', 
+                   [], 
+                   is_const=True)
+    ## radiotap-header.h: uint8_t ns3::RadiotapHeader::GetAntennaSignalPower() const [member function]
+    cls.add_method('GetAntennaSignalPower', 
+                   'uint8_t', 
+                   [], 
+                   is_const=True)
+    ## radiotap-header.h: uint16_t ns3::RadiotapHeader::GetChannelFlags() const [member function]
+    cls.add_method('GetChannelFlags', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
+    ## radiotap-header.h: uint16_t ns3::RadiotapHeader::GetChannelFrequency() const [member function]
+    cls.add_method('GetChannelFrequency', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
+    ## radiotap-header.h: uint8_t ns3::RadiotapHeader::GetFrameFlags() const [member function]
+    cls.add_method('GetFrameFlags', 
+                   'uint8_t', 
+                   [], 
+                   is_const=True)
+    ## radiotap-header.h: ns3::TypeId ns3::RadiotapHeader::GetInstanceTypeId() const [member function]
+    cls.add_method('GetInstanceTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## radiotap-header.h: uint8_t ns3::RadiotapHeader::GetRate() const [member function]
+    cls.add_method('GetRate', 
+                   'uint8_t', 
+                   [], 
+                   is_const=True)
+    ## radiotap-header.h: uint32_t ns3::RadiotapHeader::GetSerializedSize() const [member function]
+    cls.add_method('GetSerializedSize', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## radiotap-header.h: uint64_t ns3::RadiotapHeader::GetTsft() const [member function]
+    cls.add_method('GetTsft', 
+                   'uint64_t', 
+                   [], 
+                   is_const=True)
+    ## radiotap-header.h: static ns3::TypeId ns3::RadiotapHeader::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## radiotap-header.h: void ns3::RadiotapHeader::Print(std::ostream & os) const [member function]
+    cls.add_method('Print', 
+                   'void', 
+                   [param('std::ostream &', 'os')], 
+                   is_const=True, is_virtual=True)
+    ## radiotap-header.h: void ns3::RadiotapHeader::Serialize(ns3::Buffer::Iterator start) const [member function]
+    cls.add_method('Serialize', 
+                   'void', 
+                   [param('ns3::Buffer::Iterator', 'start')], 
+                   is_const=True, is_virtual=True)
+    ## radiotap-header.h: void ns3::RadiotapHeader::SetAntennaNoisePower(int8_t noise) [member function]
+    cls.add_method('SetAntennaNoisePower', 
+                   'void', 
+                   [param('int8_t', 'noise')])
+    ## radiotap-header.h: void ns3::RadiotapHeader::SetAntennaNoisePower(double noise) [member function]
+    cls.add_method('SetAntennaNoisePower', 
+                   'void', 
+                   [param('double', 'noise')])
+    ## radiotap-header.h: void ns3::RadiotapHeader::SetAntennaSignalPower(int8_t signal) [member function]
+    cls.add_method('SetAntennaSignalPower', 
+                   'void', 
+                   [param('int8_t', 'signal')])
+    ## radiotap-header.h: void ns3::RadiotapHeader::SetAntennaSignalPower(double signal) [member function]
+    cls.add_method('SetAntennaSignalPower', 
+                   'void', 
+                   [param('double', 'signal')])
+    ## radiotap-header.h: void ns3::RadiotapHeader::SetChannelFrequencyAndFlags(uint16_t frequency, uint16_t flags) [member function]
+    cls.add_method('SetChannelFrequencyAndFlags', 
+                   'void', 
+                   [param('uint16_t', 'frequency'), param('uint16_t', 'flags')])
+    ## radiotap-header.h: void ns3::RadiotapHeader::SetFrameFlags(uint8_t flags) [member function]
+    cls.add_method('SetFrameFlags', 
+                   'void', 
+                   [param('uint8_t', 'flags')])
+    ## radiotap-header.h: void ns3::RadiotapHeader::SetRate(uint8_t rate) [member function]
+    cls.add_method('SetRate', 
+                   'void', 
+                   [param('uint8_t', 'rate')])
+    ## radiotap-header.h: void ns3::RadiotapHeader::SetTsft(uint64_t tsft) [member function]
+    cls.add_method('SetTsft', 
+                   'void', 
+                   [param('uint64_t', 'tsft')])
+    return
+
 def register_Ns3Socket_methods(root_module, cls):
     ## socket.h: ns3::Socket::Socket(ns3::Socket const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::Socket const &', 'arg0')])
@@ -4580,11 +4696,6 @@ def register_Ns3PbbPacket_methods(root_module, cls):
                    'int', 
                    [], 
                    is_const=True)
-    ## packetbb.h: void ns3::PbbPacket::SerializePacketTlv(ns3::Buffer::Iterator & start) const [member function]
-    cls.add_method('SerializePacketTlv', 
-                   'void', 
-                   [param('ns3::Buffer::Iterator &', 'start')], 
-                   is_const=True, visibility='protected')
     return
 
 def register_Ns3PbbTlv_methods(root_module, cls):
@@ -4864,6 +4975,10 @@ def register_Ns3SimpleNetDevice_methods(root_module, cls):
                    'void', 
                    [param('ns3::Callback< 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 >', 'cb')], 
                    is_virtual=True)
+    ## simple-net-device.h: void ns3::SimpleNetDevice::SetReceiveErrorModel(ns3::Ptr<ns3::ErrorModel> em) [member function]
+    cls.add_method('SetReceiveErrorModel', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::ErrorModel >', 'em')])
     ## simple-net-device.h: bool ns3::SimpleNetDevice::SupportsSendFrom() const [member function]
     cls.add_method('SupportsSendFrom', 
                    'bool', 

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

@@ -11,6 +11,8 @@ def register_types(module):
     module.add_container('std::vector< ns3::olsr::LinkTuple >', 'ns3::olsr::LinkTuple', container_type='vector')
     module.add_container('std::vector< ns3::olsr::TopologyTuple >', 'ns3::olsr::TopologyTuple', container_type='vector')
     module.add_container('std::vector< ns3::olsr::IfaceAssocTuple >', 'ns3::olsr::IfaceAssocTuple', container_type='vector')
+    module.add_container('std::vector< ns3::olsr::AssociationTuple >', 'ns3::olsr::AssociationTuple', container_type='vector')
+    module.add_container('std::vector< ns3::olsr::Association >', 'ns3::olsr::Association', container_type='vector')
     
     ## Register a nested module for the namespace Config
     
@@ -91,6 +93,10 @@ def register_types_ns3_internal(module):
 def register_types_ns3_olsr(module):
     root_module = module.get_root()
     
+    ## olsr-repositories.h: ns3::olsr::Association [struct]
+    module.add_class('Association')
+    ## olsr-repositories.h: ns3::olsr::AssociationTuple [struct]
+    module.add_class('AssociationTuple')
     ## olsr-repositories.h: ns3::olsr::DuplicateTuple [struct]
     module.add_class('DuplicateTuple')
     ## olsr-repositories.h: ns3::olsr::IfaceAssocTuple [struct]
@@ -133,24 +139,31 @@ def register_types_ns3_olsr(module):
     module.add_class('TwoHopNeighborTuple')
     module.add_container('std::vector< ns3::olsr::MessageHeader::Hello::LinkMessage >', 'ns3::olsr::MessageHeader::Hello::LinkMessage', container_type='vector')
     module.add_container('std::vector< ns3::olsr::MessageHeader::Hna::Association >', 'ns3::olsr::MessageHeader::Hna::Association', container_type='vector')
+    module.add_container('std::vector< ns3::olsr::RoutingTableEntry >', 'ns3::olsr::RoutingTableEntry', container_type='vector')
     typehandlers.add_type_alias('std::vector< ns3::olsr::DuplicateTuple, std::allocator< ns3::olsr::DuplicateTuple > >', 'ns3::olsr::DuplicateSet')
     typehandlers.add_type_alias('std::vector< ns3::olsr::DuplicateTuple, std::allocator< ns3::olsr::DuplicateTuple > >*', 'ns3::olsr::DuplicateSet*')
     typehandlers.add_type_alias('std::vector< ns3::olsr::DuplicateTuple, std::allocator< ns3::olsr::DuplicateTuple > >&', 'ns3::olsr::DuplicateSet&')
     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::AssociationTuple, std::allocator< ns3::olsr::AssociationTuple > >', 'ns3::olsr::AssociationSet')
+    typehandlers.add_type_alias('std::vector< ns3::olsr::AssociationTuple, std::allocator< ns3::olsr::AssociationTuple > >*', 'ns3::olsr::AssociationSet*')
+    typehandlers.add_type_alias('std::vector< ns3::olsr::AssociationTuple, std::allocator< ns3::olsr::AssociationTuple > >&', 'ns3::olsr::AssociationSet&')
+    typehandlers.add_type_alias('std::vector< ns3::olsr::TopologyTuple, std::allocator< ns3::olsr::TopologyTuple > >', 'ns3::olsr::TopologySet')
+    typehandlers.add_type_alias('std::vector< ns3::olsr::TopologyTuple, std::allocator< ns3::olsr::TopologyTuple > >*', 'ns3::olsr::TopologySet*')
+    typehandlers.add_type_alias('std::vector< ns3::olsr::TopologyTuple, std::allocator< ns3::olsr::TopologyTuple > >&', 'ns3::olsr::TopologySet&')
     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::vector< ns3::olsr::Association, std::allocator< ns3::olsr::Association > >', 'ns3::olsr::Associations')
+    typehandlers.add_type_alias('std::vector< ns3::olsr::Association, std::allocator< ns3::olsr::Association > >*', 'ns3::olsr::Associations*')
+    typehandlers.add_type_alias('std::vector< ns3::olsr::Association, std::allocator< ns3::olsr::Association > >&', 'ns3::olsr::Associations&')
     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&')
     typehandlers.add_type_alias('std::vector< ns3::olsr::MprSelectorTuple, std::allocator< ns3::olsr::MprSelectorTuple > >', 'ns3::olsr::MprSelectorSet')
     typehandlers.add_type_alias('std::vector< ns3::olsr::MprSelectorTuple, std::allocator< ns3::olsr::MprSelectorTuple > >*', 'ns3::olsr::MprSelectorSet*')
     typehandlers.add_type_alias('std::vector< ns3::olsr::MprSelectorTuple, std::allocator< ns3::olsr::MprSelectorTuple > >&', 'ns3::olsr::MprSelectorSet&')
-    typehandlers.add_type_alias('std::vector< ns3::olsr::TopologyTuple, std::allocator< ns3::olsr::TopologyTuple > >', 'ns3::olsr::TopologySet')
-    typehandlers.add_type_alias('std::vector< ns3::olsr::TopologyTuple, std::allocator< ns3::olsr::TopologyTuple > >*', 'ns3::olsr::TopologySet*')
-    typehandlers.add_type_alias('std::vector< ns3::olsr::TopologyTuple, std::allocator< ns3::olsr::TopologyTuple > >&', 'ns3::olsr::TopologySet&')
     typehandlers.add_type_alias('std::vector< ns3::olsr::MessageHeader, std::allocator< ns3::olsr::MessageHeader > >', 'ns3::olsr::MessageList')
     typehandlers.add_type_alias('std::vector< ns3::olsr::MessageHeader, std::allocator< ns3::olsr::MessageHeader > >*', 'ns3::olsr::MessageList*')
     typehandlers.add_type_alias('std::vector< ns3::olsr::MessageHeader, std::allocator< ns3::olsr::MessageHeader > >&', 'ns3::olsr::MessageList&')
@@ -163,6 +176,8 @@ def register_types_ns3_olsr(module):
 
 def register_methods(root_module):
     register_Ns3OlsrState_methods(root_module, root_module['ns3::OlsrState'])
+    register_Ns3OlsrAssociation_methods(root_module, root_module['ns3::olsr::Association'])
+    register_Ns3OlsrAssociationTuple_methods(root_module, root_module['ns3::olsr::AssociationTuple'])
     register_Ns3OlsrDuplicateTuple_methods(root_module, root_module['ns3::olsr::DuplicateTuple'])
     register_Ns3OlsrIfaceAssocTuple_methods(root_module, root_module['ns3::olsr::IfaceAssocTuple'])
     register_Ns3OlsrLinkTuple_methods(root_module, root_module['ns3::olsr::LinkTuple'])
@@ -188,6 +203,14 @@ def register_Ns3OlsrState_methods(root_module, cls):
     cls.add_constructor([param('ns3::OlsrState const &', 'arg0')])
     ## olsr-state.h: ns3::OlsrState::OlsrState() [constructor]
     cls.add_constructor([])
+    ## olsr-state.h: void ns3::OlsrState::EraseAssociation(ns3::olsr::Association const & tuple) [member function]
+    cls.add_method('EraseAssociation', 
+                   'void', 
+                   [param('ns3::olsr::Association const &', 'tuple')])
+    ## olsr-state.h: void ns3::OlsrState::EraseAssociationTuple(ns3::olsr::AssociationTuple const & tuple) [member function]
+    cls.add_method('EraseAssociationTuple', 
+                   'void', 
+                   [param('ns3::olsr::AssociationTuple const &', 'tuple')])
     ## olsr-state.h: void ns3::OlsrState::EraseDuplicateTuple(ns3::olsr::DuplicateTuple const & tuple) [member function]
     cls.add_method('EraseDuplicateTuple', 
                    'void', 
@@ -236,6 +259,10 @@ def register_Ns3OlsrState_methods(root_module, cls):
     cls.add_method('EraseTwoHopNeighborTuples', 
                    'void', 
                    [param('ns3::Ipv4Address const &', 'neighbor'), param('ns3::Ipv4Address const &', 'twoHopNeighbor')])
+    ## olsr-state.h: ns3::olsr::AssociationTuple * ns3::OlsrState::FindAssociationTuple(ns3::Ipv4Address const & gatewayAddr, ns3::Ipv4Address const & networkAddr, ns3::Ipv4Mask const & netmask) [member function]
+    cls.add_method('FindAssociationTuple', 
+                   'ns3::olsr::AssociationTuple *', 
+                   [param('ns3::Ipv4Address const &', 'gatewayAddr'), param('ns3::Ipv4Address const &', 'networkAddr'), param('ns3::Ipv4Mask const &', 'netmask')])
     ## olsr-state.h: ns3::olsr::DuplicateTuple * ns3::OlsrState::FindDuplicateTuple(ns3::Ipv4Address const & address, uint16_t sequenceNumber) [member function]
     cls.add_method('FindDuplicateTuple', 
                    'ns3::olsr::DuplicateTuple *', 
@@ -295,6 +322,16 @@ def register_Ns3OlsrState_methods(root_module, cls):
     cls.add_method('FindTwoHopNeighborTuple', 
                    'ns3::olsr::TwoHopNeighborTuple *', 
                    [param('ns3::Ipv4Address const &', 'neighbor'), param('ns3::Ipv4Address const &', 'twoHopNeighbor')])
+    ## olsr-state.h: ns3::olsr::AssociationSet const & ns3::OlsrState::GetAssociationSet() const [member function]
+    cls.add_method('GetAssociationSet', 
+                   'ns3::olsr::AssociationSet const &', 
+                   [], 
+                   is_const=True)
+    ## olsr-state.h: ns3::olsr::Associations const & ns3::OlsrState::GetAssociations() const [member function]
+    cls.add_method('GetAssociations', 
+                   'ns3::olsr::Associations const &', 
+                   [], 
+                   is_const=True)
     ## olsr-state.h: ns3::olsr::IfaceAssocSet const & ns3::OlsrState::GetIfaceAssocSet() const [member function]
     cls.add_method('GetIfaceAssocSet', 
                    'ns3::olsr::IfaceAssocSet const &', 
@@ -342,6 +379,14 @@ def register_Ns3OlsrState_methods(root_module, cls):
     cls.add_method('GetTwoHopNeighbors', 
                    'ns3::olsr::TwoHopNeighborSet &', 
                    [])
+    ## olsr-state.h: void ns3::OlsrState::InsertAssociation(ns3::olsr::Association const & tuple) [member function]
+    cls.add_method('InsertAssociation', 
+                   'void', 
+                   [param('ns3::olsr::Association const &', 'tuple')])
+    ## olsr-state.h: void ns3::OlsrState::InsertAssociationTuple(ns3::olsr::AssociationTuple const & tuple) [member function]
+    cls.add_method('InsertAssociationTuple', 
+                   'void', 
+                   [param('ns3::olsr::AssociationTuple const &', 'tuple')])
     ## olsr-state.h: void ns3::OlsrState::InsertDuplicateTuple(ns3::olsr::DuplicateTuple const & tuple) [member function]
     cls.add_method('InsertDuplicateTuple', 
                    'void', 
@@ -381,6 +426,36 @@ def register_Ns3OlsrState_methods(root_module, cls):
                    [param('ns3::olsr::MprSet', 'mprSet')])
     return
 
+def register_Ns3OlsrAssociation_methods(root_module, cls):
+    cls.add_output_stream_operator()
+    cls.add_binary_comparison_operator('==')
+    ## olsr-repositories.h: ns3::olsr::Association::Association() [constructor]
+    cls.add_constructor([])
+    ## olsr-repositories.h: ns3::olsr::Association::Association(ns3::olsr::Association const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::olsr::Association const &', 'arg0')])
+    ## olsr-repositories.h: ns3::olsr::Association::netmask [variable]
+    cls.add_instance_attribute('netmask', 'ns3::Ipv4Mask', is_const=False)
+    ## olsr-repositories.h: ns3::olsr::Association::networkAddr [variable]
+    cls.add_instance_attribute('networkAddr', 'ns3::Ipv4Address', is_const=False)
+    return
+
+def register_Ns3OlsrAssociationTuple_methods(root_module, cls):
+    cls.add_output_stream_operator()
+    cls.add_binary_comparison_operator('==')
+    ## olsr-repositories.h: ns3::olsr::AssociationTuple::AssociationTuple() [constructor]
+    cls.add_constructor([])
+    ## olsr-repositories.h: ns3::olsr::AssociationTuple::AssociationTuple(ns3::olsr::AssociationTuple const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::olsr::AssociationTuple const &', 'arg0')])
+    ## olsr-repositories.h: ns3::olsr::AssociationTuple::expirationTime [variable]
+    cls.add_instance_attribute('expirationTime', 'ns3::Time', is_const=False)
+    ## olsr-repositories.h: ns3::olsr::AssociationTuple::gatewayAddr [variable]
+    cls.add_instance_attribute('gatewayAddr', 'ns3::Ipv4Address', is_const=False)
+    ## olsr-repositories.h: ns3::olsr::AssociationTuple::netmask [variable]
+    cls.add_instance_attribute('netmask', 'ns3::Ipv4Mask', is_const=False)
+    ## olsr-repositories.h: ns3::olsr::AssociationTuple::networkAddr [variable]
+    cls.add_instance_attribute('networkAddr', 'ns3::Ipv4Address', is_const=False)
+    return
+
 def register_Ns3OlsrDuplicateTuple_methods(root_module, cls):
     cls.add_binary_comparison_operator('==')
     ## olsr-repositories.h: ns3::olsr::DuplicateTuple::DuplicateTuple() [constructor]
@@ -808,19 +883,41 @@ 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::AddHostNetworkAssociation(ns3::Ipv4Address networkAddr, ns3::Ipv4Mask netmask) [member function]
+    cls.add_method('AddHostNetworkAssociation', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'networkAddr'), param('ns3::Ipv4Mask', 'netmask')])
     ## olsr-routing-protocol.h: void ns3::olsr::RoutingProtocol::Dump() [member function]
     cls.add_method('Dump', 
                    'void', 
                    [])
+    ## olsr-routing-protocol.h: std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int> > ns3::olsr::RoutingProtocol::GetInterfaceExclusions() const [member function]
+    cls.add_method('GetInterfaceExclusions', 
+                   'std::set< unsigned int >', 
+                   [], 
+                   is_const=True)
+    ## olsr-routing-protocol.h: std::vector<ns3::olsr::RoutingTableEntry,std::allocator<ns3::olsr::RoutingTableEntry> > ns3::olsr::RoutingProtocol::GetRoutingTableEntries() const [member function]
+    cls.add_method('GetRoutingTableEntries', 
+                   'std::vector< ns3::olsr::RoutingTableEntry >', 
+                   [], 
+                   is_const=True)
     ## olsr-routing-protocol.h: static ns3::TypeId ns3::olsr::RoutingProtocol::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
                    [], 
                    is_static=True)
+    ## olsr-routing-protocol.h: void ns3::olsr::RoutingProtocol::SetInterfaceExclusions(std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int> > exceptions) [member function]
+    cls.add_method('SetInterfaceExclusions', 
+                   'void', 
+                   [param('std::set< unsigned int >', 'exceptions')])
     ## olsr-routing-protocol.h: void ns3::olsr::RoutingProtocol::SetMainInterface(uint32_t interface) [member function]
     cls.add_method('SetMainInterface', 
                    'void', 
                    [param('uint32_t', 'interface')])
+    ## olsr-routing-protocol.h: void ns3::olsr::RoutingProtocol::SetRoutingTableAssociation(ns3::Ptr<ns3::Ipv4StaticRouting> routingTable) [member function]
+    cls.add_method('SetRoutingTableAssociation', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Ipv4StaticRouting >', 'routingTable')])
     ## olsr-routing-protocol.h: void ns3::olsr::RoutingProtocol::DoStart() [member function]
     cls.add_method('DoStart', 
                    'void', 

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

@@ -9,6 +9,8 @@ def register_types(module):
     module.add_class('PointToPointChannel', parent=root_module['ns3::Channel'])
     ## point-to-point-net-device.h: ns3::PointToPointNetDevice [class]
     module.add_class('PointToPointNetDevice', parent=root_module['ns3::NetDevice'])
+    ## point-to-point-remote-channel.h: ns3::PointToPointRemoteChannel [class]
+    module.add_class('PointToPointRemoteChannel', parent=root_module['ns3::PointToPointChannel'])
     
     ## Register a nested module for the namespace Config
     
@@ -94,6 +96,7 @@ def register_methods(root_module):
     register_Ns3PppHeader_methods(root_module, root_module['ns3::PppHeader'])
     register_Ns3PointToPointChannel_methods(root_module, root_module['ns3::PointToPointChannel'])
     register_Ns3PointToPointNetDevice_methods(root_module, root_module['ns3::PointToPointNetDevice'])
+    register_Ns3PointToPointRemoteChannel_methods(root_module, root_module['ns3::PointToPointRemoteChannel'])
     return
 
 def register_Ns3PppHeader_methods(root_module, cls):
@@ -173,7 +176,28 @@ def register_Ns3PointToPointChannel_methods(root_module, cls):
     ## point-to-point-channel.h: bool ns3::PointToPointChannel::TransmitStart(ns3::Ptr<ns3::Packet> p, ns3::Ptr<ns3::PointToPointNetDevice> src, ns3::Time txTime) [member function]
     cls.add_method('TransmitStart', 
                    'bool', 
-                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ptr< ns3::PointToPointNetDevice >', 'src'), param('ns3::Time', 'txTime')])
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ptr< ns3::PointToPointNetDevice >', 'src'), param('ns3::Time', 'txTime')], 
+                   is_virtual=True)
+    ## point-to-point-channel.h: ns3::Time ns3::PointToPointChannel::GetDelay() const [member function]
+    cls.add_method('GetDelay', 
+                   'ns3::Time', 
+                   [], 
+                   is_const=True, visibility='protected')
+    ## point-to-point-channel.h: ns3::Ptr<ns3::PointToPointNetDevice> ns3::PointToPointChannel::GetDestination(uint32_t i) const [member function]
+    cls.add_method('GetDestination', 
+                   'ns3::Ptr< ns3::PointToPointNetDevice >', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True, visibility='protected')
+    ## point-to-point-channel.h: ns3::Ptr<ns3::PointToPointNetDevice> ns3::PointToPointChannel::GetSource(uint32_t i) const [member function]
+    cls.add_method('GetSource', 
+                   'ns3::Ptr< ns3::PointToPointNetDevice >', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True, visibility='protected')
+    ## point-to-point-channel.h: bool ns3::PointToPointChannel::IsInitialized() const [member function]
+    cls.add_method('IsInitialized', 
+                   'bool', 
+                   [], 
+                   is_const=True, visibility='protected')
     return
 
 def register_Ns3PointToPointNetDevice_methods(root_module, cls):
@@ -205,11 +229,6 @@ def register_Ns3PointToPointNetDevice_methods(root_module, cls):
                    'ns3::Ptr< ns3::Channel >', 
                    [], 
                    is_const=True, is_virtual=True)
-    ## point-to-point-net-device.h: uint16_t ns3::PointToPointNetDevice::GetFrameSize() const [member function]
-    cls.add_method('GetFrameSize', 
-                   'uint16_t', 
-                   [], 
-                   is_const=True)
     ## point-to-point-net-device.h: uint32_t ns3::PointToPointNetDevice::GetIfIndex() const [member function]
     cls.add_method('GetIfIndex', 
                    'uint32_t', 
@@ -235,6 +254,11 @@ def register_Ns3PointToPointNetDevice_methods(root_module, cls):
                    'ns3::Ptr< ns3::Node >', 
                    [], 
                    is_const=True, is_virtual=True)
+    ## point-to-point-net-device.h: ns3::Ptr<ns3::Queue> ns3::PointToPointNetDevice::GetQueue() const [member function]
+    cls.add_method('GetQueue', 
+                   'ns3::Ptr< ns3::Queue >', 
+                   [], 
+                   is_const=True)
     ## point-to-point-net-device.h: static ns3::TypeId ns3::PointToPointNetDevice::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -293,10 +317,6 @@ def register_Ns3PointToPointNetDevice_methods(root_module, cls):
     cls.add_method('SetDataRate', 
                    'void', 
                    [param('ns3::DataRate', 'bps')])
-    ## point-to-point-net-device.h: void ns3::PointToPointNetDevice::SetFrameSize(uint16_t frameSize) [member function]
-    cls.add_method('SetFrameSize', 
-                   'void', 
-                   [param('uint16_t', 'frameSize')])
     ## point-to-point-net-device.h: void ns3::PointToPointNetDevice::SetIfIndex(uint32_t const index) [member function]
     cls.add_method('SetIfIndex', 
                    'void', 
@@ -346,6 +366,23 @@ def register_Ns3PointToPointNetDevice_methods(root_module, cls):
                    visibility='private', is_virtual=True)
     return
 
+def register_Ns3PointToPointRemoteChannel_methods(root_module, cls):
+    ## point-to-point-remote-channel.h: ns3::PointToPointRemoteChannel::PointToPointRemoteChannel(ns3::PointToPointRemoteChannel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::PointToPointRemoteChannel const &', 'arg0')])
+    ## point-to-point-remote-channel.h: ns3::PointToPointRemoteChannel::PointToPointRemoteChannel() [constructor]
+    cls.add_constructor([])
+    ## point-to-point-remote-channel.h: static ns3::TypeId ns3::PointToPointRemoteChannel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## point-to-point-remote-channel.h: bool ns3::PointToPointRemoteChannel::TransmitStart(ns3::Ptr<ns3::Packet> p, ns3::Ptr<ns3::PointToPointNetDevice> src, ns3::Time txTime) [member function]
+    cls.add_method('TransmitStart', 
+                   'bool', 
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ptr< ns3::PointToPointNetDevice >', 'src'), param('ns3::Time', 'txTime')], 
+                   is_virtual=True)
+    return
+
 def register_functions(root_module):
     module = root_module
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)

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

@@ -317,6 +317,11 @@ def register_Ns3Simulator_methods(root_module, cls):
                    'ns3::Time', 
                    [], 
                    is_static=True)
+    ## simulator.h: static uint32_t ns3::Simulator::GetSystemId() [member function]
+    cls.add_method('GetSystemId', 
+                   'uint32_t', 
+                   [], 
+                   is_static=True)
     ## simulator.h: static bool ns3::Simulator::IsExpired(ns3::EventId const & id) [member function]
     cls.add_method('IsExpired', 
                    'bool', 
@@ -331,7 +336,7 @@ def register_Ns3Simulator_methods(root_module, cls):
     cls.add_method('Next', 
                    'ns3::Time', 
                    [], 
-                   is_static=True)
+                   is_static=True, deprecated=True)
     ## simulator.h: static ns3::Time ns3::Simulator::Now() [member function]
     cls.add_method('Now', 
                    'ns3::Time', 
@@ -346,7 +351,7 @@ def register_Ns3Simulator_methods(root_module, cls):
     cls.add_method('RunOneEvent', 
                    'void', 
                    [], 
-                   is_static=True)
+                   is_static=True, deprecated=True)
     ## simulator.h: static void ns3::Simulator::SetImplementation(ns3::Ptr<ns3::SimulatorImpl> impl) [member function]
     cls.add_method('SetImplementation', 
                    'void', 
@@ -795,6 +800,11 @@ def register_Ns3SimulatorImpl_methods(root_module, cls):
                    'ns3::Time', 
                    [], 
                    is_pure_virtual=True, is_const=True, is_virtual=True)
+    ## simulator-impl.h: uint32_t ns3::SimulatorImpl::GetSystemId() const [member function]
+    cls.add_method('GetSystemId', 
+                   'uint32_t', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     ## simulator-impl.h: bool ns3::SimulatorImpl::IsExpired(ns3::EventId const & ev) const [member function]
     cls.add_method('IsExpired', 
                    'bool', 
@@ -1129,6 +1139,11 @@ def register_Ns3DefaultSimulatorImpl_methods(root_module, cls):
                    'ns3::Time', 
                    [], 
                    is_const=True, is_virtual=True)
+    ## default-simulator-impl.h: uint32_t ns3::DefaultSimulatorImpl::GetSystemId() const [member function]
+    cls.add_method('GetSystemId', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## default-simulator-impl.h: static ns3::TypeId ns3::DefaultSimulatorImpl::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1423,6 +1438,11 @@ def register_Ns3RealtimeSimulatorImpl_methods(root_module, cls):
                    'ns3::RealtimeSimulatorImpl::SynchronizationMode', 
                    [], 
                    is_const=True)
+    ## realtime-simulator-impl.h: uint32_t ns3::RealtimeSimulatorImpl::GetSystemId() const [member function]
+    cls.add_method('GetSystemId', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## realtime-simulator-impl.h: static ns3::TypeId ns3::RealtimeSimulatorImpl::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 

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

@@ -13,8 +13,12 @@ def register_types(module):
     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'], root_module['ns3::StatisticalSummary']])
     ## 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]
@@ -116,7 +120,9 @@ def register_methods(root_module):
     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 >'])
@@ -364,6 +370,67 @@ 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: long int ns3::MinMaxAvgTotalCalculator<unsigned int>::getCount() const [member function]
+    cls.add_method('getCount', 
+                   'long int', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## basic-data-calculators.h: double ns3::MinMaxAvgTotalCalculator<unsigned int>::getMax() const [member function]
+    cls.add_method('getMax', 
+                   'double', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## basic-data-calculators.h: double ns3::MinMaxAvgTotalCalculator<unsigned int>::getMean() const [member function]
+    cls.add_method('getMean', 
+                   'double', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## basic-data-calculators.h: double ns3::MinMaxAvgTotalCalculator<unsigned int>::getMin() const [member function]
+    cls.add_method('getMin', 
+                   'double', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## basic-data-calculators.h: double ns3::MinMaxAvgTotalCalculator<unsigned int>::getSqrSum() const [member function]
+    cls.add_method('getSqrSum', 
+                   'double', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## basic-data-calculators.h: double ns3::MinMaxAvgTotalCalculator<unsigned int>::getStddev() const [member function]
+    cls.add_method('getStddev', 
+                   'double', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## basic-data-calculators.h: double ns3::MinMaxAvgTotalCalculator<unsigned int>::getSum() const [member function]
+    cls.add_method('getSum', 
+                   'double', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## basic-data-calculators.h: double ns3::MinMaxAvgTotalCalculator<unsigned int>::getVariance() const [member function]
+    cls.add_method('getVariance', 
+                   'double', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## 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')])
@@ -381,6 +448,26 @@ 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')])

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

@@ -0,0 +1,262 @@
+from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandlers
+
+def register_types(module):
+    root_module = module.get_root()
+    
+    ## topology-reader.h: ns3::TopologyReader [class]
+    module.add_class('TopologyReader', parent=root_module['ns3::Object'])
+    ## topology-reader.h: ns3::TopologyReader::Link [class]
+    module.add_class('Link', outer_class=root_module['ns3::TopologyReader'])
+    ## inet-topology-reader.h: ns3::InetTopologyReader [class]
+    module.add_class('InetTopologyReader', parent=root_module['ns3::TopologyReader'])
+    ## orbis-topology-reader.h: ns3::OrbisTopologyReader [class]
+    module.add_class('OrbisTopologyReader', parent=root_module['ns3::TopologyReader'])
+    
+    ## 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_Ns3TopologyReader_methods(root_module, root_module['ns3::TopologyReader'])
+    register_Ns3TopologyReaderLink_methods(root_module, root_module['ns3::TopologyReader::Link'])
+    register_Ns3InetTopologyReader_methods(root_module, root_module['ns3::InetTopologyReader'])
+    register_Ns3OrbisTopologyReader_methods(root_module, root_module['ns3::OrbisTopologyReader'])
+    return
+
+def register_Ns3TopologyReader_methods(root_module, cls):
+    ## topology-reader.h: ns3::TopologyReader::TopologyReader() [constructor]
+    cls.add_constructor([])
+    ## topology-reader.h: void ns3::TopologyReader::AddLink(ns3::TopologyReader::Link link) [member function]
+    cls.add_method('AddLink', 
+                   'void', 
+                   [param('ns3::TopologyReader::Link', 'link')])
+    ## topology-reader.h: std::string ns3::TopologyReader::GetFileName() const [member function]
+    cls.add_method('GetFileName', 
+                   'std::string', 
+                   [], 
+                   is_const=True)
+    ## topology-reader.h: static ns3::TypeId ns3::TopologyReader::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## topology-reader.h: std::_List_const_iterator<ns3::TopologyReader::Link> ns3::TopologyReader::LinksBegin() const [member function]
+    cls.add_method('LinksBegin', 
+                   'std::_List_const_iterator< ns3::TopologyReader::Link >', 
+                   [], 
+                   is_const=True)
+    ## topology-reader.h: bool ns3::TopologyReader::LinksEmpty() const [member function]
+    cls.add_method('LinksEmpty', 
+                   'bool', 
+                   [], 
+                   is_const=True)
+    ## topology-reader.h: std::_List_const_iterator<ns3::TopologyReader::Link> ns3::TopologyReader::LinksEnd() const [member function]
+    cls.add_method('LinksEnd', 
+                   'std::_List_const_iterator< ns3::TopologyReader::Link >', 
+                   [], 
+                   is_const=True)
+    ## topology-reader.h: int ns3::TopologyReader::LinksSize() const [member function]
+    cls.add_method('LinksSize', 
+                   'int', 
+                   [], 
+                   is_const=True)
+    ## topology-reader.h: ns3::NodeContainer ns3::TopologyReader::Read() [member function]
+    cls.add_method('Read', 
+                   'ns3::NodeContainer', 
+                   [], 
+                   is_pure_virtual=True, is_virtual=True)
+    ## topology-reader.h: void ns3::TopologyReader::SetFileName(std::string const fileName) [member function]
+    cls.add_method('SetFileName', 
+                   'void', 
+                   [param('std::string const', 'fileName')])
+    return
+
+def register_Ns3TopologyReaderLink_methods(root_module, cls):
+    ## topology-reader.h: ns3::TopologyReader::Link::Link(ns3::TopologyReader::Link const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::TopologyReader::Link const &', 'arg0')])
+    ## topology-reader.h: ns3::TopologyReader::Link::Link(ns3::Ptr<ns3::Node> fromPtr, std::string fromName, ns3::Ptr<ns3::Node> toPtr, std::string toName) [constructor]
+    cls.add_constructor([param('ns3::Ptr< ns3::Node >', 'fromPtr'), param('std::string', 'fromName'), param('ns3::Ptr< ns3::Node >', 'toPtr'), param('std::string', 'toName')])
+    ## topology-reader.h: std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > ns3::TopologyReader::Link::AttributesBegin() [member function]
+    cls.add_method('AttributesBegin', 
+                   'std::_Rb_tree_const_iterator< std::pair< std::basic_string< char, std::char_traits< char >, std::allocator< char > > const, std::basic_string< char, std::char_traits< char >, std::allocator< char > > > >', 
+                   [])
+    ## topology-reader.h: std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > ns3::TopologyReader::Link::AttributesEnd() [member function]
+    cls.add_method('AttributesEnd', 
+                   'std::_Rb_tree_const_iterator< std::pair< std::basic_string< char, std::char_traits< char >, std::allocator< char > > const, std::basic_string< char, std::char_traits< char >, std::allocator< char > > > >', 
+                   [])
+    ## topology-reader.h: std::string ns3::TopologyReader::Link::GetAttribute(std::string name) [member function]
+    cls.add_method('GetAttribute', 
+                   'std::string', 
+                   [param('std::string', 'name')])
+    ## topology-reader.h: bool ns3::TopologyReader::Link::GetAttributeFailSafe(std::string name, std::string & value) [member function]
+    cls.add_method('GetAttributeFailSafe', 
+                   'bool', 
+                   [param('std::string', 'name'), param('std::string &', 'value')])
+    ## topology-reader.h: ns3::Ptr<ns3::Node> ns3::TopologyReader::Link::GetFromNode() const [member function]
+    cls.add_method('GetFromNode', 
+                   'ns3::Ptr< ns3::Node >', 
+                   [], 
+                   is_const=True)
+    ## topology-reader.h: std::string ns3::TopologyReader::Link::GetFromNodeName() const [member function]
+    cls.add_method('GetFromNodeName', 
+                   'std::string', 
+                   [], 
+                   is_const=True)
+    ## topology-reader.h: ns3::Ptr<ns3::Node> ns3::TopologyReader::Link::GetToNode() const [member function]
+    cls.add_method('GetToNode', 
+                   'ns3::Ptr< ns3::Node >', 
+                   [], 
+                   is_const=True)
+    ## topology-reader.h: std::string ns3::TopologyReader::Link::GetToNodeName() const [member function]
+    cls.add_method('GetToNodeName', 
+                   'std::string', 
+                   [], 
+                   is_const=True)
+    ## topology-reader.h: void ns3::TopologyReader::Link::SetAttribute(std::string name, std::string & value) [member function]
+    cls.add_method('SetAttribute', 
+                   'void', 
+                   [param('std::string', 'name'), param('std::string &', 'value')])
+    return
+
+def register_Ns3InetTopologyReader_methods(root_module, cls):
+    ## inet-topology-reader.h: static ns3::TypeId ns3::InetTopologyReader::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## inet-topology-reader.h: ns3::InetTopologyReader::InetTopologyReader() [constructor]
+    cls.add_constructor([])
+    ## inet-topology-reader.h: ns3::NodeContainer ns3::InetTopologyReader::Read() [member function]
+    cls.add_method('Read', 
+                   'ns3::NodeContainer', 
+                   [], 
+                   is_virtual=True)
+    return
+
+def register_Ns3OrbisTopologyReader_methods(root_module, cls):
+    ## orbis-topology-reader.h: static ns3::TypeId ns3::OrbisTopologyReader::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## orbis-topology-reader.h: ns3::OrbisTopologyReader::OrbisTopologyReader() [constructor]
+    cls.add_constructor([])
+    ## orbis-topology-reader.h: ns3::NodeContainer ns3::OrbisTopologyReader::Read() [member function]
+    cls.add_method('Read', 
+                   'ns3::NodeContainer', 
+                   [], 
+                   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/ns3modulegen_generated.py

@@ -17,6 +17,7 @@ import ns3_module_simulator
 import ns3_module_test
 import ns3_module_common
 import ns3_module_mobility
+import ns3_module_mpi
 import ns3_module_contrib
 import ns3_module_node
 import ns3_module_bridge
@@ -31,9 +32,11 @@ import ns3_module_point_to_point
 import ns3_module_static_routing
 import ns3_module_stats
 import ns3_module_tap_bridge
+import ns3_module_topology_read
 import ns3_module_v4ping
 import ns3_module_virtual_net_device
 import ns3_module_wifi
+import ns3_module_wimax
 import ns3_module_aodv
 import ns3_module_flow_monitor
 import ns3_module_nix_vector_routing
@@ -109,6 +112,17 @@ def register_types(module):
         ns3_module_mobility__local.register_types(module)
     
     root_module.end_section('ns3_module_mobility')
+    root_module.begin_section('ns3_module_mpi')
+    ns3_module_mpi.register_types(module)
+    
+    try:
+        import ns3_module_mpi__local
+    except ImportError:
+        pass
+    else:
+        ns3_module_mpi__local.register_types(module)
+    
+    root_module.end_section('ns3_module_mpi')
     root_module.begin_section('ns3_module_contrib')
     ns3_module_contrib.register_types(module)
     
@@ -263,6 +277,17 @@ def register_types(module):
         ns3_module_tap_bridge__local.register_types(module)
     
     root_module.end_section('ns3_module_tap_bridge')
+    root_module.begin_section('ns3_module_topology_read')
+    ns3_module_topology_read.register_types(module)
+    
+    try:
+        import ns3_module_topology_read__local
+    except ImportError:
+        pass
+    else:
+        ns3_module_topology_read__local.register_types(module)
+    
+    root_module.end_section('ns3_module_topology_read')
     root_module.begin_section('ns3_module_v4ping')
     ns3_module_v4ping.register_types(module)
     
@@ -296,6 +321,17 @@ def register_types(module):
         ns3_module_wifi__local.register_types(module)
     
     root_module.end_section('ns3_module_wifi')
+    root_module.begin_section('ns3_module_wimax')
+    ns3_module_wimax.register_types(module)
+    
+    try:
+        import ns3_module_wimax__local
+    except ImportError:
+        pass
+    else:
+        ns3_module_wimax__local.register_types(module)
+    
+    root_module.end_section('ns3_module_wimax')
     root_module.begin_section('ns3_module_aodv')
     ns3_module_aodv.register_types(module)
     
@@ -430,6 +466,11 @@ def register_types(module):
     root_module.end_section('ns3_module_flame')
     module.add_container('std::vector< unsigned int >', 'unsigned int', container_type='vector')
     module.add_container('std::vector< bool >', 'bool', container_type='vector')
+    module.add_container('std::vector< ns3::ServiceFlow * >', 'ns3::ServiceFlow *', container_type='vector')
+    module.add_container('ns3::bvec', 'bool', container_type='vector')
+    module.add_container('std::vector< ns3::SSRecord * >', 'ns3::SSRecord *', container_type='vector')
+    module.add_container('std::map< std::string, std::string >', ('std::string', 'std::string'), container_type='map')
+    module.add_container('std::list< std::pair< ns3::OfdmDlMapIe *, ns3::Ptr< ns3::PacketBurst > > >', 'std::pair< ns3::OfdmDlMapIe *, ns3::Ptr< ns3::PacketBurst > >', container_type='list')
     module.add_container('std::vector< unsigned long long >', 'long long unsigned int', container_type='vector')
     module.add_container('std::list< unsigned int >', 'unsigned int', container_type='list')
     module.add_container('std::list< std::pair< ns3::Ptr< ns3::Packet >, ns3::AmsduSubframeHeader > >', 'std::pair< ns3::Ptr< ns3::Packet >, ns3::AmsduSubframeHeader >', container_type='list')
@@ -515,6 +556,7 @@ def register_types_ns3_internal(module):
 def register_types_ns3_olsr(module):
     root_module = module.get_root()
     
+    module.add_container('std::set< unsigned int >', 'unsigned int', container_type='set')
 
 def register_methods(root_module):
     root_module.begin_section('ns3_module_core')
@@ -572,6 +614,17 @@ def register_methods(root_module):
         ns3_module_mobility__local.register_methods(root_module)
     
     root_module.end_section('ns3_module_mobility')
+    root_module.begin_section('ns3_module_mpi')
+    ns3_module_mpi.register_methods(root_module)
+    
+    try:
+        import ns3_module_mpi__local
+    except ImportError:
+        pass
+    else:
+        ns3_module_mpi__local.register_methods(root_module)
+    
+    root_module.end_section('ns3_module_mpi')
     root_module.begin_section('ns3_module_contrib')
     ns3_module_contrib.register_methods(root_module)
     
@@ -726,6 +779,17 @@ def register_methods(root_module):
         ns3_module_tap_bridge__local.register_methods(root_module)
     
     root_module.end_section('ns3_module_tap_bridge')
+    root_module.begin_section('ns3_module_topology_read')
+    ns3_module_topology_read.register_methods(root_module)
+    
+    try:
+        import ns3_module_topology_read__local
+    except ImportError:
+        pass
+    else:
+        ns3_module_topology_read__local.register_methods(root_module)
+    
+    root_module.end_section('ns3_module_topology_read')
     root_module.begin_section('ns3_module_v4ping')
     ns3_module_v4ping.register_methods(root_module)
     
@@ -759,6 +823,17 @@ def register_methods(root_module):
         ns3_module_wifi__local.register_methods(root_module)
     
     root_module.end_section('ns3_module_wifi')
+    root_module.begin_section('ns3_module_wimax')
+    ns3_module_wimax.register_methods(root_module)
+    
+    try:
+        import ns3_module_wimax__local
+    except ImportError:
+        pass
+    else:
+        ns3_module_wimax__local.register_methods(root_module)
+    
+    root_module.end_section('ns3_module_wimax')
     root_module.begin_section('ns3_module_aodv')
     ns3_module_aodv.register_methods(root_module)
     
@@ -950,6 +1025,17 @@ def register_functions(root_module):
         ns3_module_mobility__local.register_functions(root_module)
     
     root_module.end_section('ns3_module_mobility')
+    root_module.begin_section('ns3_module_mpi')
+    ns3_module_mpi.register_functions(root_module)
+    
+    try:
+        import ns3_module_mpi__local
+    except ImportError:
+        pass
+    else:
+        ns3_module_mpi__local.register_functions(root_module)
+    
+    root_module.end_section('ns3_module_mpi')
     root_module.begin_section('ns3_module_contrib')
     ns3_module_contrib.register_functions(root_module)
     
@@ -1104,6 +1190,17 @@ def register_functions(root_module):
         ns3_module_tap_bridge__local.register_functions(root_module)
     
     root_module.end_section('ns3_module_tap_bridge')
+    root_module.begin_section('ns3_module_topology_read')
+    ns3_module_topology_read.register_functions(root_module)
+    
+    try:
+        import ns3_module_topology_read__local
+    except ImportError:
+        pass
+    else:
+        ns3_module_topology_read__local.register_functions(root_module)
+    
+    root_module.end_section('ns3_module_topology_read')
     root_module.begin_section('ns3_module_v4ping')
     ns3_module_v4ping.register_functions(root_module)
     
@@ -1137,6 +1234,17 @@ def register_functions(root_module):
         ns3_module_wifi__local.register_functions(root_module)
     
     root_module.end_section('ns3_module_wifi')
+    root_module.begin_section('ns3_module_wimax')
+    ns3_module_wimax.register_functions(root_module)
+    
+    try:
+        import ns3_module_wimax__local
+    except ImportError:
+        pass
+    else:
+        ns3_module_wimax__local.register_functions(root_module)
+    
+    root_module.end_section('ns3_module_wimax')
     root_module.begin_section('ns3_module_aodv')
     ns3_module_aodv.register_functions(root_module)
     

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

@@ -1,6 +1,7 @@
 callback_classes = [
     ['void', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['bool', 'ns3::Ptr<ns3::Packet>', 'ns3::Address const&', 'ns3::Address const&', 'unsigned short', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
+    ['void', 'ns3::Ptr<ns3::PacketBurst const>', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['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'],
@@ -10,8 +11,11 @@ callback_classes = [
     ['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'],
+    ['void', 'bool', 'unsigned long', '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::Mac48Address', 'unsigned char', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
+    ['void', 'ns3::Mac48Address', 'unsigned char', 'bool', 'ns3::empty', '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'],

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

@@ -387,6 +387,11 @@ def register_Ns3AodvRerrHeader_methods(root_module, cls):
                    'uint32_t', 
                    [], 
                    is_const=True, is_virtual=True)
+    ## aodv-packet.h: static ns3::TypeId ns3::aodv::RerrHeader::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## aodv-packet.h: void ns3::aodv::RerrHeader::Print(std::ostream & os) const [member function]
     cls.add_method('Print', 
                    'void', 
@@ -535,6 +540,10 @@ def register_Ns3AodvRoutingTable_methods(root_module, cls):
     cls.add_method('LookupRoute', 
                    'bool', 
                    [param('ns3::Ipv4Address', 'dst'), param('ns3::aodv::RoutingTableEntry &', 'rt')])
+    ## aodv-rtable.h: bool ns3::aodv::RoutingTable::LookupValidRoute(ns3::Ipv4Address dst, ns3::aodv::RoutingTableEntry & rt) [member function]
+    cls.add_method('LookupValidRoute', 
+                   'bool', 
+                   [param('ns3::Ipv4Address', 'dst'), param('ns3::aodv::RoutingTableEntry &', 'rt')])
     ## aodv-rtable.h: bool ns3::aodv::RoutingTable::MarkLinkAsUnidirectional(ns3::Ipv4Address neighbor, ns3::Time blacklistTimeout) [member function]
     cls.add_method('MarkLinkAsUnidirectional', 
                    'bool', 
@@ -744,6 +753,11 @@ def register_Ns3AodvRrepAckHeader_methods(root_module, cls):
                    'uint32_t', 
                    [], 
                    is_const=True, is_virtual=True)
+    ## aodv-packet.h: static ns3::TypeId ns3::aodv::RrepAckHeader::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## aodv-packet.h: void ns3::aodv::RrepAckHeader::Print(std::ostream & os) const [member function]
     cls.add_method('Print', 
                    'void', 
@@ -813,6 +827,11 @@ def register_Ns3AodvRrepHeader_methods(root_module, cls):
                    'uint32_t', 
                    [], 
                    is_const=True, is_virtual=True)
+    ## aodv-packet.h: static ns3::TypeId ns3::aodv::RrepHeader::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## aodv-packet.h: void ns3::aodv::RrepHeader::Print(std::ostream & os) const [member function]
     cls.add_method('Print', 
                    'void', 
@@ -894,9 +913,9 @@ def register_Ns3AodvRreqHeader_methods(root_module, cls):
                    'uint8_t', 
                    [], 
                    is_const=True)
-    ## aodv-packet.h: uint8_t ns3::aodv::RreqHeader::GetId() const [member function]
+    ## aodv-packet.h: uint32_t ns3::aodv::RreqHeader::GetId() const [member function]
     cls.add_method('GetId', 
-                   'uint8_t', 
+                   'uint32_t', 
                    [], 
                    is_const=True)
     ## aodv-packet.h: ns3::TypeId ns3::aodv::RreqHeader::GetInstanceTypeId() const [member function]
@@ -919,6 +938,11 @@ def register_Ns3AodvRreqHeader_methods(root_module, cls):
                    'uint32_t', 
                    [], 
                    is_const=True, is_virtual=True)
+    ## aodv-packet.h: static ns3::TypeId ns3::aodv::RreqHeader::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## aodv-packet.h: bool ns3::aodv::RreqHeader::GetUnknownSeqno() const [member function]
     cls.add_method('GetUnknownSeqno', 
                    'bool', 
@@ -999,6 +1023,11 @@ def register_Ns3AodvTypeHeader_methods(root_module, cls):
                    'uint32_t', 
                    [], 
                    is_const=True, is_virtual=True)
+    ## aodv-packet.h: static ns3::TypeId ns3::aodv::TypeHeader::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## aodv-packet.h: bool ns3::aodv::TypeHeader::IsValid() const [member function]
     cls.add_method('IsValid', 
                    'bool', 

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

@@ -47,28 +47,56 @@ def register_types(module):
     module.add_class('Chunk', parent=root_module['ns3::ObjectBase'])
     ## 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'))
+    ## pcap-file-wrapper.h: ns3::PcapFileWrapper [class]
+    module.add_class('PcapFileWrapper', parent=root_module['ns3::Object'])
+    ## propagation-delay-model.h: ns3::PropagationDelayModel [class]
+    module.add_class('PropagationDelayModel', parent=root_module['ns3::Object'])
+    ## propagation-loss-model.h: ns3::PropagationLossModel [class]
+    module.add_class('PropagationLossModel', parent=root_module['ns3::Object'])
+    ## propagation-delay-model.h: ns3::RandomPropagationDelayModel [class]
+    module.add_class('RandomPropagationDelayModel', parent=root_module['ns3::PropagationDelayModel'])
+    ## propagation-loss-model.h: ns3::RandomPropagationLossModel [class]
+    module.add_class('RandomPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> > [class]
+    module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::OutputStreamWrapper', 'ns3::empty', 'ns3::DefaultDeleter<ns3::OutputStreamWrapper>'], 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'))
+    ## propagation-loss-model.h: ns3::ThreeLogDistancePropagationLossModel [class]
+    module.add_class('ThreeLogDistancePropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
     ## 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'])
+    ## propagation-loss-model.h: ns3::TwoRayGroundPropagationLossModel [class]
+    module.add_class('TwoRayGroundPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
+    ## propagation-delay-model.h: ns3::ConstantSpeedPropagationDelayModel [class]
+    module.add_class('ConstantSpeedPropagationDelayModel', parent=root_module['ns3::PropagationDelayModel'])
+    ## cost231-propagation-loss-model.h: ns3::Cost231PropagationLossModel [class]
+    module.add_class('Cost231PropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
+    ## cost231-propagation-loss-model.h: ns3::Cost231PropagationLossModel::Environment [enumeration]
+    module.add_enum('Environment', ['SubUrban', 'MediumCity', 'Metropolitan'], outer_class=root_module['ns3::Cost231PropagationLossModel'])
     ## 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'])
+    ## propagation-loss-model.h: ns3::FixedRssLossModel [class]
+    module.add_class('FixedRssLossModel', parent=root_module['ns3::PropagationLossModel'])
+    ## propagation-loss-model.h: ns3::FriisPropagationLossModel [class]
+    module.add_class('FriisPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
+    ## jakes-propagation-loss-model.h: ns3::JakesPropagationLossModel [class]
+    module.add_class('JakesPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
     ## error-model.h: ns3::ListErrorModel [class]
     module.add_class('ListErrorModel', parent=root_module['ns3::ErrorModel'])
+    ## propagation-loss-model.h: ns3::LogDistancePropagationLossModel [class]
+    module.add_class('LogDistancePropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
+    ## propagation-loss-model.h: ns3::MatrixPropagationLossModel [class]
+    module.add_class('MatrixPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
+    ## propagation-loss-model.h: ns3::NakagamiPropagationLossModel [class]
+    module.add_class('NakagamiPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
     ## nix-vector.h: ns3::NixVector [class]
     module.add_class('NixVector', parent=root_module['ns3::Object'])
+    ## output-stream-wrapper.h: ns3::OutputStreamWrapper [class]
+    module.add_class('OutputStreamWrapper', parent=root_module['ns3::SimpleRefCount< ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> >'])
     ## 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]
@@ -175,14 +203,28 @@ def register_methods(root_module):
     register_Ns3TagBuffer_methods(root_module, root_module['ns3::TagBuffer'])
     register_Ns3Chunk_methods(root_module, root_module['ns3::Chunk'])
     register_Ns3Header_methods(root_module, root_module['ns3::Header'])
-    register_Ns3PcapWriter_methods(root_module, root_module['ns3::PcapWriter'])
+    register_Ns3PcapFileWrapper_methods(root_module, root_module['ns3::PcapFileWrapper'])
+    register_Ns3PropagationDelayModel_methods(root_module, root_module['ns3::PropagationDelayModel'])
+    register_Ns3PropagationLossModel_methods(root_module, root_module['ns3::PropagationLossModel'])
+    register_Ns3RandomPropagationDelayModel_methods(root_module, root_module['ns3::RandomPropagationDelayModel'])
+    register_Ns3RandomPropagationLossModel_methods(root_module, root_module['ns3::RandomPropagationLossModel'])
+    register_Ns3ThreeLogDistancePropagationLossModel_methods(root_module, root_module['ns3::ThreeLogDistancePropagationLossModel'])
     register_Ns3Trailer_methods(root_module, root_module['ns3::Trailer'])
-    register_Ns3AsciiWriter_methods(root_module, root_module['ns3::AsciiWriter'])
+    register_Ns3TwoRayGroundPropagationLossModel_methods(root_module, root_module['ns3::TwoRayGroundPropagationLossModel'])
+    register_Ns3ConstantSpeedPropagationDelayModel_methods(root_module, root_module['ns3::ConstantSpeedPropagationDelayModel'])
+    register_Ns3Cost231PropagationLossModel_methods(root_module, root_module['ns3::Cost231PropagationLossModel'])
     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_Ns3FixedRssLossModel_methods(root_module, root_module['ns3::FixedRssLossModel'])
+    register_Ns3FriisPropagationLossModel_methods(root_module, root_module['ns3::FriisPropagationLossModel'])
+    register_Ns3JakesPropagationLossModel_methods(root_module, root_module['ns3::JakesPropagationLossModel'])
     register_Ns3ListErrorModel_methods(root_module, root_module['ns3::ListErrorModel'])
+    register_Ns3LogDistancePropagationLossModel_methods(root_module, root_module['ns3::LogDistancePropagationLossModel'])
+    register_Ns3MatrixPropagationLossModel_methods(root_module, root_module['ns3::MatrixPropagationLossModel'])
+    register_Ns3NakagamiPropagationLossModel_methods(root_module, root_module['ns3::NakagamiPropagationLossModel'])
     register_Ns3NixVector_methods(root_module, root_module['ns3::NixVector'])
+    register_Ns3OutputStreamWrapper_methods(root_module, root_module['ns3::OutputStreamWrapper'])
     register_Ns3Packet_methods(root_module, root_module['ns3::Packet'])
     register_Ns3RateErrorModel_methods(root_module, root_module['ns3::RateErrorModel'])
     return
@@ -194,6 +236,8 @@ def register_Ns3Buffer_methods(root_module, cls):
     cls.add_constructor([])
     ## buffer.h: ns3::Buffer::Buffer(uint32_t dataSize) [constructor]
     cls.add_constructor([param('uint32_t', 'dataSize')])
+    ## buffer.h: ns3::Buffer::Buffer(uint32_t dataSize, bool initialize) [constructor]
+    cls.add_constructor([param('uint32_t', 'dataSize'), param('bool', 'initialize')])
     ## buffer.h: bool ns3::Buffer::AddAtEnd(uint32_t end) [member function]
     cls.add_method('AddAtEnd', 
                    'bool', 
@@ -216,6 +260,11 @@ def register_Ns3Buffer_methods(root_module, cls):
                    'void', 
                    [param('std::ostream *', 'os'), param('uint32_t', 'size')], 
                    is_const=True)
+    ## buffer.h: uint32_t ns3::Buffer::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)
     ## buffer.h: ns3::Buffer ns3::Buffer::CreateFragment(uint32_t start, uint32_t length) const [member function]
     cls.add_method('CreateFragment', 
                    'ns3::Buffer', 
@@ -226,6 +275,10 @@ def register_Ns3Buffer_methods(root_module, cls):
                    'ns3::Buffer', 
                    [], 
                    is_const=True)
+    ## buffer.h: uint32_t ns3::Buffer::Deserialize(uint8_t * buffer, uint32_t size) [member function]
+    cls.add_method('Deserialize', 
+                   'uint32_t', 
+                   [param('uint8_t *', 'buffer'), param('uint32_t', 'size')])
     ## buffer.h: ns3::Buffer::Iterator ns3::Buffer::End() const [member function]
     cls.add_method('End', 
                    'ns3::Buffer::Iterator', 
@@ -241,6 +294,11 @@ def register_Ns3Buffer_methods(root_module, cls):
                    'int32_t', 
                    [], 
                    is_const=True)
+    ## buffer.h: uint32_t ns3::Buffer::GetSerializedSize() const [member function]
+    cls.add_method('GetSerializedSize', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## buffer.h: uint32_t ns3::Buffer::GetSize() const [member function]
     cls.add_method('GetSize', 
                    'uint32_t', 
@@ -259,6 +317,11 @@ def register_Ns3Buffer_methods(root_module, cls):
     cls.add_method('RemoveAtStart', 
                    'void', 
                    [param('uint32_t', 'start')])
+    ## buffer.h: uint32_t ns3::Buffer::Serialize(uint8_t * buffer, uint32_t maxSize) const [member function]
+    cls.add_method('Serialize', 
+                   'uint32_t', 
+                   [param('uint8_t *', 'buffer'), param('uint32_t', 'maxSize')], 
+                   is_const=True)
     return
 
 def register_Ns3BufferIterator_methods(root_module, cls):
@@ -544,8 +607,8 @@ def register_Ns3DataRate_methods(root_module, cls):
     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')])
+    ## packet-metadata.h: ns3::PacketMetadata::PacketMetadata(uint64_t uid, uint32_t size) [constructor]
+    cls.add_constructor([param('uint64_t', 'uid'), param('uint32_t', 'size')])
     ## packet-metadata.h: ns3::PacketMetadata::PacketMetadata(ns3::PacketMetadata const & o) [copy constructor]
     cls.add_constructor([param('ns3::PacketMetadata const &', 'o')])
     ## packet-metadata.h: void ns3::PacketMetadata::AddAtEnd(ns3::PacketMetadata const & o) [member function]
@@ -574,10 +637,10 @@ def register_Ns3PacketMetadata_methods(root_module, cls):
                    'ns3::PacketMetadata', 
                    [param('uint32_t', 'start'), param('uint32_t', 'end')], 
                    is_const=True)
-    ## packet-metadata.h: uint32_t ns3::PacketMetadata::Deserialize(ns3::Buffer::Iterator i) [member function]
+    ## packet-metadata.h: uint32_t ns3::PacketMetadata::Deserialize(uint8_t * buffer, uint32_t size) [member function]
     cls.add_method('Deserialize', 
                    'uint32_t', 
-                   [param('ns3::Buffer::Iterator', 'i')])
+                   [param('uint8_t *', 'buffer'), param('uint32_t', 'size')])
     ## packet-metadata.h: static void ns3::PacketMetadata::Enable() [member function]
     cls.add_method('Enable', 
                    'void', 
@@ -593,9 +656,9 @@ def register_Ns3PacketMetadata_methods(root_module, cls):
                    'uint32_t', 
                    [], 
                    is_const=True)
-    ## packet-metadata.h: uint32_t ns3::PacketMetadata::GetUid() const [member function]
+    ## packet-metadata.h: uint64_t ns3::PacketMetadata::GetUid() const [member function]
     cls.add_method('GetUid', 
-                   'uint32_t', 
+                   'uint64_t', 
                    [], 
                    is_const=True)
     ## packet-metadata.h: void ns3::PacketMetadata::RemoveAtEnd(uint32_t end) [member function]
@@ -614,10 +677,10 @@ def register_Ns3PacketMetadata_methods(root_module, cls):
     cls.add_method('RemoveTrailer', 
                    'void', 
                    [param('ns3::Trailer const &', 'trailer'), param('uint32_t', 'size')])
-    ## packet-metadata.h: void ns3::PacketMetadata::Serialize(ns3::Buffer::Iterator i, uint32_t size) const [member function]
+    ## packet-metadata.h: uint32_t ns3::PacketMetadata::Serialize(uint8_t * buffer, uint32_t maxSize) const [member function]
     cls.add_method('Serialize', 
-                   'void', 
-                   [param('ns3::Buffer::Iterator', 'i'), param('uint32_t', 'size')], 
+                   'uint32_t', 
+                   [param('uint8_t *', 'buffer'), param('uint32_t', 'maxSize')], 
                    is_const=True)
     return
 
@@ -731,10 +794,12 @@ def register_Ns3PacketTagListTagData_methods(root_module, cls):
     return
 
 def register_Ns3PcapFile_methods(root_module, cls):
-    ## pcap-file.h: ns3::PcapFile::PcapFile(ns3::PcapFile const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::PcapFile const &', 'arg0')])
     ## pcap-file.h: ns3::PcapFile::PcapFile() [constructor]
     cls.add_constructor([])
+    ## pcap-file.h: void ns3::PcapFile::Clear() [member function]
+    cls.add_method('Clear', 
+                   'void', 
+                   [])
     ## pcap-file.h: void ns3::PcapFile::Close() [member function]
     cls.add_method('Close', 
                    'void', 
@@ -744,6 +809,16 @@ def register_Ns3PcapFile_methods(root_module, cls):
                    '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: bool ns3::PcapFile::Eof() const [member function]
+    cls.add_method('Eof', 
+                   'bool', 
+                   [], 
+                   is_const=True)
+    ## pcap-file.h: bool ns3::PcapFile::Fail() const [member function]
+    cls.add_method('Fail', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## pcap-file.h: uint32_t ns3::PcapFile::GetDataLinkType() [member function]
     cls.add_method('GetDataLinkType', 
                    'uint32_t', 
@@ -776,22 +851,30 @@ def register_Ns3PcapFile_methods(root_module, cls):
     cls.add_method('GetVersionMinor', 
                    'uint16_t', 
                    [])
-    ## pcap-file.h: bool ns3::PcapFile::Init(uint32_t dataLinkType, uint32_t snapLen=ns3::PcapFile::SNAPLEN_DEFAULT, int32_t timeZoneCorrection=ns3::PcapFile::ZONE_DEFAULT, bool swapMode=false) [member function]
+    ## pcap-file.h: void ns3::PcapFile::Init(uint32_t dataLinkType, uint32_t snapLen=ns3::PcapFile::SNAPLEN_DEFAULT, int32_t timeZoneCorrection=ns3::PcapFile::ZONE_DEFAULT, bool swapMode=false) [member function]
     cls.add_method('Init', 
-                   'bool', 
+                   'void', 
                    [param('uint32_t', 'dataLinkType'), param('uint32_t', 'snapLen', default_value='ns3::PcapFile::SNAPLEN_DEFAULT'), param('int32_t', 'timeZoneCorrection', default_value='ns3::PcapFile::ZONE_DEFAULT'), param('bool', 'swapMode', default_value='false')])
-    ## pcap-file.h: bool ns3::PcapFile::Open(std::string const & filename, std::string const & mode) [member function]
+    ## pcap-file.h: void ns3::PcapFile::Open(std::string const & filename, std::_Ios_Openmode mode) [member function]
     cls.add_method('Open', 
-                   'bool', 
-                   [param('std::string const &', 'filename'), param('std::string const &', 'mode')])
-    ## pcap-file.h: bool ns3::PcapFile::Read(uint8_t * const data, uint32_t maxBytes, uint32_t & tsSec, uint32_t & tsUsec, uint32_t & inclLen, uint32_t & origLen, uint32_t & readLen) [member function]
+                   'void', 
+                   [param('std::string const &', 'filename'), param('std::_Ios_Openmode', 'mode')])
+    ## pcap-file.h: void ns3::PcapFile::Read(uint8_t * const data, uint32_t maxBytes, uint32_t & tsSec, uint32_t & tsUsec, uint32_t & inclLen, uint32_t & origLen, uint32_t & readLen) [member function]
     cls.add_method('Read', 
-                   'bool', 
+                   'void', 
                    [param('uint8_t * const', 'data'), param('uint32_t', 'maxBytes'), param('uint32_t &', 'tsSec'), param('uint32_t &', 'tsUsec'), param('uint32_t &', 'inclLen'), param('uint32_t &', 'origLen'), param('uint32_t &', 'readLen')])
-    ## pcap-file.h: bool ns3::PcapFile::Write(uint32_t tsSec, uint32_t tsUsec, uint8_t const * const data, uint32_t totalLen) [member function]
+    ## pcap-file.h: void ns3::PcapFile::Write(uint32_t tsSec, uint32_t tsUsec, uint8_t const * const data, uint32_t totalLen) [member function]
     cls.add_method('Write', 
-                   'bool', 
+                   'void', 
                    [param('uint32_t', 'tsSec'), param('uint32_t', 'tsUsec'), param('uint8_t const * const', 'data'), param('uint32_t', 'totalLen')])
+    ## pcap-file.h: void ns3::PcapFile::Write(uint32_t tsSec, uint32_t tsUsec, ns3::Ptr<ns3::Packet const> p) [member function]
+    cls.add_method('Write', 
+                   'void', 
+                   [param('uint32_t', 'tsSec'), param('uint32_t', 'tsUsec'), param('ns3::Ptr< ns3::Packet const >', 'p')])
+    ## pcap-file.h: void ns3::PcapFile::Write(uint32_t tsSec, uint32_t tsUsec, ns3::Header & header, ns3::Ptr<ns3::Packet const> p) [member function]
+    cls.add_method('Write', 
+                   'void', 
+                   [param('uint32_t', 'tsSec'), param('uint32_t', 'tsUsec'), param('ns3::Header &', 'header'), param('ns3::Ptr< ns3::Packet const >', 'p')])
     ## pcap-file.h: ns3::PcapFile::SNAPLEN_DEFAULT [variable]
     cls.add_static_attribute('SNAPLEN_DEFAULT', 'uint32_t const', is_const=True)
     ## pcap-file.h: ns3::PcapFile::ZONE_DEFAULT [variable]
@@ -948,56 +1031,168 @@ def register_Ns3Header_methods(root_module, cls):
                    is_pure_virtual=True, is_const=True, is_virtual=True)
     return
 
-def register_Ns3PcapWriter_methods(root_module, cls):
-    ## pcap-writer.h: ns3::PcapWriter::PcapWriter(ns3::PcapWriter const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::PcapWriter const &', 'arg0')])
-    ## pcap-writer.h: ns3::PcapWriter::PcapWriter() [constructor]
-    cls.add_constructor([])
-    ## pcap-writer.h: static ns3::TypeId ns3::PcapWriter::GetTypeId() [member function]
+def register_Ns3PcapFileWrapper_methods(root_module, cls):
+    ## pcap-file-wrapper.h: static ns3::TypeId ns3::PcapFileWrapper::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
                    [], 
                    is_static=True)
-    ## pcap-writer.h: void ns3::PcapWriter::Open(std::string const & name) [member function]
+    ## pcap-file-wrapper.h: ns3::PcapFileWrapper::PcapFileWrapper() [constructor]
+    cls.add_constructor([])
+    ## pcap-file-wrapper.h: bool ns3::PcapFileWrapper::Fail() const [member function]
+    cls.add_method('Fail', 
+                   'bool', 
+                   [], 
+                   is_const=True)
+    ## pcap-file-wrapper.h: bool ns3::PcapFileWrapper::Eof() const [member function]
+    cls.add_method('Eof', 
+                   'bool', 
+                   [], 
+                   is_const=True)
+    ## pcap-file-wrapper.h: void ns3::PcapFileWrapper::Clear() [member function]
+    cls.add_method('Clear', 
+                   'void', 
+                   [])
+    ## pcap-file-wrapper.h: void ns3::PcapFileWrapper::Open(std::string const & filename, std::_Ios_Openmode mode) [member function]
     cls.add_method('Open', 
                    'void', 
-                   [param('std::string const &', 'name')])
-    ## pcap-writer.h: void ns3::PcapWriter::SetCaptureSize(uint32_t size) [member function]
-    cls.add_method('SetCaptureSize', 
-                   'void', 
-                   [param('uint32_t', 'size')])
-    ## pcap-writer.h: void ns3::PcapWriter::WriteEthernetHeader() [member function]
-    cls.add_method('WriteEthernetHeader', 
+                   [param('std::string const &', 'filename'), param('std::_Ios_Openmode', 'mode')])
+    ## pcap-file-wrapper.h: void ns3::PcapFileWrapper::Close() [member function]
+    cls.add_method('Close', 
                    'void', 
                    [])
-    ## pcap-writer.h: void ns3::PcapWriter::WriteIpHeader() [member function]
-    cls.add_method('WriteIpHeader', 
+    ## pcap-file-wrapper.h: void ns3::PcapFileWrapper::Init(uint32_t dataLinkType, uint32_t snapLen=std::numeric_limits<unsigned int>::max(), int32_t tzCorrection=ns3::PcapFile::ZONE_DEFAULT) [member function]
+    cls.add_method('Init', 
                    'void', 
+                   [param('uint32_t', 'dataLinkType'), param('uint32_t', 'snapLen', default_value='std::numeric_limits<unsigned int>::max()'), param('int32_t', 'tzCorrection', default_value='ns3::PcapFile::ZONE_DEFAULT')])
+    ## pcap-file-wrapper.h: void ns3::PcapFileWrapper::Write(ns3::Time t, ns3::Ptr<ns3::Packet const> p) [member function]
+    cls.add_method('Write', 
+                   'void', 
+                   [param('ns3::Time', 't'), param('ns3::Ptr< ns3::Packet const >', 'p')])
+    ## pcap-file-wrapper.h: void ns3::PcapFileWrapper::Write(ns3::Time t, ns3::Header & header, ns3::Ptr<ns3::Packet const> p) [member function]
+    cls.add_method('Write', 
+                   'void', 
+                   [param('ns3::Time', 't'), param('ns3::Header &', 'header'), param('ns3::Ptr< ns3::Packet const >', 'p')])
+    ## pcap-file-wrapper.h: void ns3::PcapFileWrapper::Write(ns3::Time t, uint8_t const * buffer, uint32_t length) [member function]
+    cls.add_method('Write', 
+                   'void', 
+                   [param('ns3::Time', 't'), param('uint8_t const *', 'buffer'), param('uint32_t', 'length')])
+    ## pcap-file-wrapper.h: uint32_t ns3::PcapFileWrapper::GetMagic() [member function]
+    cls.add_method('GetMagic', 
+                   'uint32_t', 
                    [])
-    ## pcap-writer.h: void ns3::PcapWriter::WritePacket(ns3::Ptr<ns3::Packet const> packet) [member function]
-    cls.add_method('WritePacket', 
-                   'void', 
-                   [param('ns3::Ptr< ns3::Packet const >', 'packet')])
-    ## pcap-writer.h: void ns3::PcapWriter::WritePppHeader() [member function]
-    cls.add_method('WritePppHeader', 
-                   'void', 
+    ## pcap-file-wrapper.h: uint16_t ns3::PcapFileWrapper::GetVersionMajor() [member function]
+    cls.add_method('GetVersionMajor', 
+                   'uint16_t', 
                    [])
-    ## pcap-writer.h: void ns3::PcapWriter::WriteWifiHeader() [member function]
-    cls.add_method('WriteWifiHeader', 
-                   'void', 
+    ## pcap-file-wrapper.h: uint16_t ns3::PcapFileWrapper::GetVersionMinor() [member function]
+    cls.add_method('GetVersionMinor', 
+                   'uint16_t', 
                    [])
-    ## pcap-writer.h: void ns3::PcapWriter::WriteWifiMonitorPacket(ns3::Ptr<ns3::Packet const> packet, uint16_t channelFreqMhz, uint16_t channelNumber, uint32_t rate, bool isShortPreamble, bool isTx, double signalDbm, double noiseDbm) [member function]
-    cls.add_method('WriteWifiMonitorPacket', 
-                   'void', 
-                   [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('uint16_t', 'channelFreqMhz'), param('uint16_t', 'channelNumber'), param('uint32_t', 'rate'), param('bool', 'isShortPreamble'), param('bool', 'isTx'), param('double', 'signalDbm'), param('double', 'noiseDbm')])
-    ## pcap-writer.h: void ns3::PcapWriter::WriteWifiPrismHeader() [member function]
-    cls.add_method('WriteWifiPrismHeader', 
-                   'void', 
+    ## pcap-file-wrapper.h: int32_t ns3::PcapFileWrapper::GetTimeZoneOffset() [member function]
+    cls.add_method('GetTimeZoneOffset', 
+                   'int32_t', 
                    [])
-    ## pcap-writer.h: void ns3::PcapWriter::WriteWifiRadiotapHeader() [member function]
-    cls.add_method('WriteWifiRadiotapHeader', 
-                   'void', 
+    ## pcap-file-wrapper.h: uint32_t ns3::PcapFileWrapper::GetSigFigs() [member function]
+    cls.add_method('GetSigFigs', 
+                   'uint32_t', 
                    [])
+    ## pcap-file-wrapper.h: uint32_t ns3::PcapFileWrapper::GetSnapLen() [member function]
+    cls.add_method('GetSnapLen', 
+                   'uint32_t', 
+                   [])
+    ## pcap-file-wrapper.h: uint32_t ns3::PcapFileWrapper::GetDataLinkType() [member function]
+    cls.add_method('GetDataLinkType', 
+                   'uint32_t', 
+                   [])
+    return
+
+def register_Ns3PropagationDelayModel_methods(root_module, cls):
+    ## propagation-delay-model.h: ns3::PropagationDelayModel::PropagationDelayModel() [constructor]
+    cls.add_constructor([])
+    ## propagation-delay-model.h: ns3::PropagationDelayModel::PropagationDelayModel(ns3::PropagationDelayModel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::PropagationDelayModel const &', 'arg0')])
+    ## propagation-delay-model.h: ns3::Time ns3::PropagationDelayModel::GetDelay(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('GetDelay', 
+                   'ns3::Time', 
+                   [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
+    ## propagation-delay-model.h: static ns3::TypeId ns3::PropagationDelayModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    return
+
+def register_Ns3PropagationLossModel_methods(root_module, cls):
+    ## propagation-loss-model.h: static ns3::TypeId ns3::PropagationLossModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## propagation-loss-model.h: ns3::PropagationLossModel::PropagationLossModel() [constructor]
+    cls.add_constructor([])
+    ## propagation-loss-model.h: void ns3::PropagationLossModel::SetNext(ns3::Ptr<ns3::PropagationLossModel> next) [member function]
+    cls.add_method('SetNext', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::PropagationLossModel >', 'next')])
+    ## propagation-loss-model.h: double ns3::PropagationLossModel::CalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('CalcRxPower', 
+                   'double', 
+                   [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True)
+    ## propagation-loss-model.h: double ns3::PropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('DoCalcRxPower', 
+                   'double', 
+                   [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
+    return
+
+def register_Ns3RandomPropagationDelayModel_methods(root_module, cls):
+    ## propagation-delay-model.h: ns3::RandomPropagationDelayModel::RandomPropagationDelayModel(ns3::RandomPropagationDelayModel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::RandomPropagationDelayModel const &', 'arg0')])
+    ## propagation-delay-model.h: ns3::RandomPropagationDelayModel::RandomPropagationDelayModel() [constructor]
+    cls.add_constructor([])
+    ## propagation-delay-model.h: ns3::Time ns3::RandomPropagationDelayModel::GetDelay(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('GetDelay', 
+                   'ns3::Time', 
+                   [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True, is_virtual=True)
+    ## propagation-delay-model.h: static ns3::TypeId ns3::RandomPropagationDelayModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    return
+
+def register_Ns3RandomPropagationLossModel_methods(root_module, cls):
+    ## propagation-loss-model.h: static ns3::TypeId ns3::RandomPropagationLossModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## propagation-loss-model.h: ns3::RandomPropagationLossModel::RandomPropagationLossModel() [constructor]
+    cls.add_constructor([])
+    ## propagation-loss-model.h: double ns3::RandomPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('DoCalcRxPower', 
+                   'double', 
+                   [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True, visibility='private', is_virtual=True)
+    return
+
+def register_Ns3ThreeLogDistancePropagationLossModel_methods(root_module, cls):
+    ## propagation-loss-model.h: static ns3::TypeId ns3::ThreeLogDistancePropagationLossModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## propagation-loss-model.h: ns3::ThreeLogDistancePropagationLossModel::ThreeLogDistancePropagationLossModel() [constructor]
+    cls.add_constructor([])
+    ## propagation-loss-model.h: double ns3::ThreeLogDistancePropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('DoCalcRxPower', 
+                   'double', 
+                   [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True, visibility='private', is_virtual=True)
     return
 
 def register_Ns3Trailer_methods(root_module, cls):
@@ -1033,18 +1228,157 @@ 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')], 
+def register_Ns3TwoRayGroundPropagationLossModel_methods(root_module, cls):
+    ## propagation-loss-model.h: static ns3::TypeId ns3::TwoRayGroundPropagationLossModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
                    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', 
+    ## propagation-loss-model.h: ns3::TwoRayGroundPropagationLossModel::TwoRayGroundPropagationLossModel() [constructor]
+    cls.add_constructor([])
+    ## propagation-loss-model.h: void ns3::TwoRayGroundPropagationLossModel::SetLambda(double frequency, double speed) [member function]
+    cls.add_method('SetLambda', 
                    'void', 
-                   [param('ns3::AsciiWriter::Type', 'type'), param('std::string', 'message'), param('ns3::Ptr< ns3::Packet const >', 'p')])
+                   [param('double', 'frequency'), param('double', 'speed')])
+    ## propagation-loss-model.h: void ns3::TwoRayGroundPropagationLossModel::SetLambda(double lambda) [member function]
+    cls.add_method('SetLambda', 
+                   'void', 
+                   [param('double', 'lambda')])
+    ## propagation-loss-model.h: void ns3::TwoRayGroundPropagationLossModel::SetSystemLoss(double systemLoss) [member function]
+    cls.add_method('SetSystemLoss', 
+                   'void', 
+                   [param('double', 'systemLoss')])
+    ## propagation-loss-model.h: void ns3::TwoRayGroundPropagationLossModel::SetMinDistance(double minDistance) [member function]
+    cls.add_method('SetMinDistance', 
+                   'void', 
+                   [param('double', 'minDistance')])
+    ## propagation-loss-model.h: double ns3::TwoRayGroundPropagationLossModel::GetMinDistance() const [member function]
+    cls.add_method('GetMinDistance', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## propagation-loss-model.h: double ns3::TwoRayGroundPropagationLossModel::GetLambda() const [member function]
+    cls.add_method('GetLambda', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## propagation-loss-model.h: double ns3::TwoRayGroundPropagationLossModel::GetSystemLoss() const [member function]
+    cls.add_method('GetSystemLoss', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## propagation-loss-model.h: void ns3::TwoRayGroundPropagationLossModel::SetHeightAboveZ(double heightAboveZ) [member function]
+    cls.add_method('SetHeightAboveZ', 
+                   'void', 
+                   [param('double', 'heightAboveZ')])
+    ## propagation-loss-model.h: double ns3::TwoRayGroundPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('DoCalcRxPower', 
+                   'double', 
+                   [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True, visibility='private', is_virtual=True)
+    return
+
+def register_Ns3ConstantSpeedPropagationDelayModel_methods(root_module, cls):
+    ## propagation-delay-model.h: ns3::ConstantSpeedPropagationDelayModel::ConstantSpeedPropagationDelayModel(ns3::ConstantSpeedPropagationDelayModel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::ConstantSpeedPropagationDelayModel const &', 'arg0')])
+    ## propagation-delay-model.h: ns3::ConstantSpeedPropagationDelayModel::ConstantSpeedPropagationDelayModel() [constructor]
+    cls.add_constructor([])
+    ## propagation-delay-model.h: ns3::Time ns3::ConstantSpeedPropagationDelayModel::GetDelay(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('GetDelay', 
+                   'ns3::Time', 
+                   [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True, is_virtual=True)
+    ## propagation-delay-model.h: double ns3::ConstantSpeedPropagationDelayModel::GetSpeed() const [member function]
+    cls.add_method('GetSpeed', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## propagation-delay-model.h: static ns3::TypeId ns3::ConstantSpeedPropagationDelayModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## propagation-delay-model.h: void ns3::ConstantSpeedPropagationDelayModel::SetSpeed(double speed) [member function]
+    cls.add_method('SetSpeed', 
+                   'void', 
+                   [param('double', 'speed')])
+    return
+
+def register_Ns3Cost231PropagationLossModel_methods(root_module, cls):
+    ## cost231-propagation-loss-model.h: static ns3::TypeId ns3::Cost231PropagationLossModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## cost231-propagation-loss-model.h: ns3::Cost231PropagationLossModel::Cost231PropagationLossModel() [constructor]
+    cls.add_constructor([])
+    ## cost231-propagation-loss-model.h: double ns3::Cost231PropagationLossModel::GetLoss(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('GetLoss', 
+                   'double', 
+                   [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True)
+    ## cost231-propagation-loss-model.h: void ns3::Cost231PropagationLossModel::SetBSAntennaHeight(double height) [member function]
+    cls.add_method('SetBSAntennaHeight', 
+                   'void', 
+                   [param('double', 'height')])
+    ## cost231-propagation-loss-model.h: void ns3::Cost231PropagationLossModel::SetSSAntennaHeight(double height) [member function]
+    cls.add_method('SetSSAntennaHeight', 
+                   'void', 
+                   [param('double', 'height')])
+    ## cost231-propagation-loss-model.h: void ns3::Cost231PropagationLossModel::SetEnvironment(ns3::Cost231PropagationLossModel::Environment env) [member function]
+    cls.add_method('SetEnvironment', 
+                   'void', 
+                   [param('ns3::Cost231PropagationLossModel::Environment', 'env')])
+    ## cost231-propagation-loss-model.h: void ns3::Cost231PropagationLossModel::SetLambda(double lambda) [member function]
+    cls.add_method('SetLambda', 
+                   'void', 
+                   [param('double', 'lambda')])
+    ## cost231-propagation-loss-model.h: void ns3::Cost231PropagationLossModel::SetMinDistance(double minDistance) [member function]
+    cls.add_method('SetMinDistance', 
+                   'void', 
+                   [param('double', 'minDistance')])
+    ## cost231-propagation-loss-model.h: double ns3::Cost231PropagationLossModel::GetBSAntennaHeight() const [member function]
+    cls.add_method('GetBSAntennaHeight', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## cost231-propagation-loss-model.h: double ns3::Cost231PropagationLossModel::GetSSAntennaHeight() const [member function]
+    cls.add_method('GetSSAntennaHeight', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## cost231-propagation-loss-model.h: ns3::Cost231PropagationLossModel::Environment ns3::Cost231PropagationLossModel::GetEnvironment() const [member function]
+    cls.add_method('GetEnvironment', 
+                   'ns3::Cost231PropagationLossModel::Environment', 
+                   [], 
+                   is_const=True)
+    ## cost231-propagation-loss-model.h: double ns3::Cost231PropagationLossModel::GetMinDistance() const [member function]
+    cls.add_method('GetMinDistance', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## cost231-propagation-loss-model.h: double ns3::Cost231PropagationLossModel::GetLambda() const [member function]
+    cls.add_method('GetLambda', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## cost231-propagation-loss-model.h: void ns3::Cost231PropagationLossModel::SetLambda(double frequency, double speed) [member function]
+    cls.add_method('SetLambda', 
+                   'void', 
+                   [param('double', 'frequency'), param('double', 'speed')])
+    ## cost231-propagation-loss-model.h: double ns3::Cost231PropagationLossModel::GetShadowing() [member function]
+    cls.add_method('GetShadowing', 
+                   'double', 
+                   [])
+    ## cost231-propagation-loss-model.h: void ns3::Cost231PropagationLossModel::SetShadowing(double shadowing) [member function]
+    cls.add_method('SetShadowing', 
+                   'void', 
+                   [param('double', 'shadowing')])
+    ## cost231-propagation-loss-model.h: double ns3::Cost231PropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('DoCalcRxPower', 
+                   'double', 
+                   [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True, visibility='private', is_virtual=True)
     return
 
 def register_Ns3DataRateChecker_methods(root_module, cls):
@@ -1130,6 +1464,104 @@ def register_Ns3ErrorModel_methods(root_module, cls):
                    is_pure_virtual=True, visibility='private', is_virtual=True)
     return
 
+def register_Ns3FixedRssLossModel_methods(root_module, cls):
+    ## propagation-loss-model.h: static ns3::TypeId ns3::FixedRssLossModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## propagation-loss-model.h: ns3::FixedRssLossModel::FixedRssLossModel() [constructor]
+    cls.add_constructor([])
+    ## propagation-loss-model.h: void ns3::FixedRssLossModel::SetRss(double rss) [member function]
+    cls.add_method('SetRss', 
+                   'void', 
+                   [param('double', 'rss')])
+    ## propagation-loss-model.h: double ns3::FixedRssLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('DoCalcRxPower', 
+                   'double', 
+                   [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True, visibility='private', is_virtual=True)
+    return
+
+def register_Ns3FriisPropagationLossModel_methods(root_module, cls):
+    ## propagation-loss-model.h: static ns3::TypeId ns3::FriisPropagationLossModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## propagation-loss-model.h: ns3::FriisPropagationLossModel::FriisPropagationLossModel() [constructor]
+    cls.add_constructor([])
+    ## propagation-loss-model.h: void ns3::FriisPropagationLossModel::SetLambda(double frequency, double speed) [member function]
+    cls.add_method('SetLambda', 
+                   'void', 
+                   [param('double', 'frequency'), param('double', 'speed')])
+    ## propagation-loss-model.h: void ns3::FriisPropagationLossModel::SetLambda(double lambda) [member function]
+    cls.add_method('SetLambda', 
+                   'void', 
+                   [param('double', 'lambda')])
+    ## propagation-loss-model.h: void ns3::FriisPropagationLossModel::SetSystemLoss(double systemLoss) [member function]
+    cls.add_method('SetSystemLoss', 
+                   'void', 
+                   [param('double', 'systemLoss')])
+    ## propagation-loss-model.h: void ns3::FriisPropagationLossModel::SetMinDistance(double minDistance) [member function]
+    cls.add_method('SetMinDistance', 
+                   'void', 
+                   [param('double', 'minDistance')])
+    ## propagation-loss-model.h: double ns3::FriisPropagationLossModel::GetMinDistance() const [member function]
+    cls.add_method('GetMinDistance', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## propagation-loss-model.h: double ns3::FriisPropagationLossModel::GetLambda() const [member function]
+    cls.add_method('GetLambda', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## propagation-loss-model.h: double ns3::FriisPropagationLossModel::GetSystemLoss() const [member function]
+    cls.add_method('GetSystemLoss', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## propagation-loss-model.h: double ns3::FriisPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('DoCalcRxPower', 
+                   'double', 
+                   [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True, visibility='private', is_virtual=True)
+    return
+
+def register_Ns3JakesPropagationLossModel_methods(root_module, cls):
+    ## jakes-propagation-loss-model.h: ns3::JakesPropagationLossModel::JakesPropagationLossModel() [constructor]
+    cls.add_constructor([])
+    ## jakes-propagation-loss-model.h: uint8_t ns3::JakesPropagationLossModel::GetNOscillators() const [member function]
+    cls.add_method('GetNOscillators', 
+                   'uint8_t', 
+                   [], 
+                   is_const=True)
+    ## jakes-propagation-loss-model.h: uint8_t ns3::JakesPropagationLossModel::GetNRays() const [member function]
+    cls.add_method('GetNRays', 
+                   'uint8_t', 
+                   [], 
+                   is_const=True)
+    ## jakes-propagation-loss-model.h: static ns3::TypeId ns3::JakesPropagationLossModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## jakes-propagation-loss-model.h: void ns3::JakesPropagationLossModel::SetNOscillators(uint8_t nOscillators) [member function]
+    cls.add_method('SetNOscillators', 
+                   'void', 
+                   [param('uint8_t', 'nOscillators')])
+    ## jakes-propagation-loss-model.h: void ns3::JakesPropagationLossModel::SetNRays(uint8_t nRays) [member function]
+    cls.add_method('SetNRays', 
+                   'void', 
+                   [param('uint8_t', 'nRays')])
+    ## jakes-propagation-loss-model.h: double ns3::JakesPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('DoCalcRxPower', 
+                   'double', 
+                   [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True, visibility='private', is_virtual=True)
+    return
+
 def register_Ns3ListErrorModel_methods(root_module, cls):
     ## error-model.h: ns3::ListErrorModel::ListErrorModel(ns3::ListErrorModel const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::ListErrorModel const &', 'arg0')])
@@ -1161,6 +1593,72 @@ def register_Ns3ListErrorModel_methods(root_module, cls):
                    visibility='private', is_virtual=True)
     return
 
+def register_Ns3LogDistancePropagationLossModel_methods(root_module, cls):
+    ## propagation-loss-model.h: static ns3::TypeId ns3::LogDistancePropagationLossModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## propagation-loss-model.h: ns3::LogDistancePropagationLossModel::LogDistancePropagationLossModel() [constructor]
+    cls.add_constructor([])
+    ## propagation-loss-model.h: void ns3::LogDistancePropagationLossModel::SetPathLossExponent(double n) [member function]
+    cls.add_method('SetPathLossExponent', 
+                   'void', 
+                   [param('double', 'n')])
+    ## propagation-loss-model.h: double ns3::LogDistancePropagationLossModel::GetPathLossExponent() const [member function]
+    cls.add_method('GetPathLossExponent', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    ## propagation-loss-model.h: void ns3::LogDistancePropagationLossModel::SetReference(double referenceDistance, double referenceLoss) [member function]
+    cls.add_method('SetReference', 
+                   'void', 
+                   [param('double', 'referenceDistance'), param('double', 'referenceLoss')])
+    ## propagation-loss-model.h: double ns3::LogDistancePropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('DoCalcRxPower', 
+                   'double', 
+                   [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True, visibility='private', is_virtual=True)
+    return
+
+def register_Ns3MatrixPropagationLossModel_methods(root_module, cls):
+    ## propagation-loss-model.h: static ns3::TypeId ns3::MatrixPropagationLossModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## propagation-loss-model.h: ns3::MatrixPropagationLossModel::MatrixPropagationLossModel() [constructor]
+    cls.add_constructor([])
+    ## propagation-loss-model.h: void ns3::MatrixPropagationLossModel::SetLoss(ns3::Ptr<ns3::Node> a, ns3::Ptr<ns3::Node> b, double loss, bool symmetric=true) [member function]
+    cls.add_method('SetLoss', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Node >', 'a'), param('ns3::Ptr< ns3::Node >', 'b'), param('double', 'loss'), param('bool', 'symmetric', default_value='true')])
+    ## propagation-loss-model.h: void ns3::MatrixPropagationLossModel::SetDefaultLoss(double arg0) [member function]
+    cls.add_method('SetDefaultLoss', 
+                   'void', 
+                   [param('double', 'arg0')])
+    ## propagation-loss-model.h: double ns3::MatrixPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('DoCalcRxPower', 
+                   'double', 
+                   [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True, visibility='private', is_virtual=True)
+    return
+
+def register_Ns3NakagamiPropagationLossModel_methods(root_module, cls):
+    ## propagation-loss-model.h: static ns3::TypeId ns3::NakagamiPropagationLossModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## propagation-loss-model.h: ns3::NakagamiPropagationLossModel::NakagamiPropagationLossModel() [constructor]
+    cls.add_constructor([])
+    ## propagation-loss-model.h: double ns3::NakagamiPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('DoCalcRxPower', 
+                   'double', 
+                   [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True, visibility='private', is_virtual=True)
+    return
+
 def register_Ns3NixVector_methods(root_module, cls):
     cls.add_output_stream_operator()
     ## nix-vector.h: ns3::NixVector::NixVector() [constructor]
@@ -1181,10 +1679,10 @@ def register_Ns3NixVector_methods(root_module, cls):
                    'ns3::Ptr< ns3::NixVector >', 
                    [], 
                    is_const=True)
-    ## nix-vector.h: uint32_t ns3::NixVector::Deserialize(ns3::Buffer::Iterator i) [member function]
+    ## nix-vector.h: uint32_t ns3::NixVector::Deserialize(uint32_t * buffer, uint32_t size) [member function]
     cls.add_method('Deserialize', 
                    'uint32_t', 
-                   [param('ns3::Buffer::Iterator', 'i')])
+                   [param('uint32_t *', 'buffer'), param('uint32_t', 'size')])
     ## nix-vector.h: void ns3::NixVector::DumpNixVector(std::ostream & os) const [member function]
     cls.add_method('DumpNixVector', 
                    'void', 
@@ -1208,13 +1706,28 @@ def register_Ns3NixVector_methods(root_module, cls):
                    'ns3::TypeId', 
                    [], 
                    is_static=True)
-    ## nix-vector.h: void ns3::NixVector::Serialize(ns3::Buffer::Iterator i, uint32_t size) const [member function]
+    ## nix-vector.h: uint32_t ns3::NixVector::Serialize(uint32_t * buffer, uint32_t maxSize) const [member function]
     cls.add_method('Serialize', 
-                   'void', 
-                   [param('ns3::Buffer::Iterator', 'i'), param('uint32_t', 'size')], 
+                   'uint32_t', 
+                   [param('uint32_t *', 'buffer'), param('uint32_t', 'maxSize')], 
                    is_const=True)
     return
 
+def register_Ns3OutputStreamWrapper_methods(root_module, cls):
+    ## output-stream-wrapper.h: ns3::OutputStreamWrapper::OutputStreamWrapper(ns3::OutputStreamWrapper const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::OutputStreamWrapper const &', 'arg0')])
+    ## output-stream-wrapper.h: ns3::OutputStreamWrapper::OutputStreamWrapper() [constructor]
+    cls.add_constructor([])
+    ## output-stream-wrapper.h: std::ostream * ns3::OutputStreamWrapper::GetStream() [member function]
+    cls.add_method('GetStream', 
+                   'std::ostream *', 
+                   [])
+    ## output-stream-wrapper.h: void ns3::OutputStreamWrapper::SetStream(std::ostream * ostream) [member function]
+    cls.add_method('SetStream', 
+                   'void', 
+                   [param('std::ostream *', 'ostream')])
+    return
+
 def register_Ns3Packet_methods(root_module, cls):
     cls.add_output_stream_operator()
     ## packet.h: ns3::Packet::Packet() [constructor]
@@ -1223,6 +1736,8 @@ def register_Ns3Packet_methods(root_module, cls):
     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, bool magic) [constructor]
+    cls.add_constructor([param('uint8_t const *', 'buffer'), param('uint32_t', 'size'), param('bool', 'magic')])
     ## 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]
@@ -1276,10 +1791,6 @@ def register_Ns3Packet_methods(root_module, cls):
                    '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', 
@@ -1310,14 +1821,19 @@ def register_Ns3Packet_methods(root_module, cls):
                    'ns3::PacketTagIterator', 
                    [], 
                    is_const=True)
+    ## packet.h: uint32_t ns3::Packet::GetSerializedSize() const [member function]
+    cls.add_method('GetSerializedSize', 
+                   'uint32_t', 
+                   [], 
+                   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]
+    ## packet.h: uint64_t ns3::Packet::GetUid() const [member function]
     cls.add_method('GetUid', 
-                   'uint32_t', 
+                   'uint64_t', 
                    [], 
                    is_const=True)
     ## packet.h: uint8_t const * ns3::Packet::PeekData() const [member function]
@@ -1382,10 +1898,10 @@ def register_Ns3Packet_methods(root_module, cls):
     cls.add_method('RemoveTrailer', 
                    'uint32_t', 
                    [param('ns3::Trailer &', 'trailer')])
-    ## packet.h: ns3::Buffer ns3::Packet::Serialize() const [member function]
+    ## packet.h: uint32_t ns3::Packet::Serialize(uint8_t * buffer, uint32_t maxSize) const [member function]
     cls.add_method('Serialize', 
-                   'ns3::Buffer', 
-                   [], 
+                   'uint32_t', 
+                   [param('uint8_t *', 'buffer'), param('uint32_t', 'maxSize')], 
                    is_const=True)
     ## packet.h: void ns3::Packet::SetNixVector(ns3::Ptr<ns3::NixVector> arg0) [member function]
     cls.add_method('SetNixVector', 

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

@@ -93,6 +93,8 @@ def register_types(module):
     module.add_class('Vector3D')
     ## random-variable.h: ns3::WeibullVariable [class]
     module.add_class('WeibullVariable', parent=root_module['ns3::RandomVariable'])
+    ## random-variable.h: ns3::ZetaVariable [class]
+    module.add_class('ZetaVariable', parent=root_module['ns3::RandomVariable'])
     ## random-variable.h: ns3::ZipfVariable [class]
     module.add_class('ZipfVariable', parent=root_module['ns3::RandomVariable'])
     ## empty.h: ns3::empty [class]
@@ -203,17 +205,10 @@ def register_types(module):
     module.add_class('Vector3DChecker', parent=root_module['ns3::AttributeChecker'])
     ## vector.h: ns3::Vector3DValue [class]
     module.add_class('Vector3DValue', parent=root_module['ns3::AttributeValue'])
-    ## traced-value.h: ns3::TracedValue<unsigned int> [class]
-    module.add_class('TracedValue', template_parameters=['unsigned int'])
-    ## traced-value.h: ns3::TracedValue<unsigned int> [class]
-    root_module['ns3::TracedValue< unsigned int >'].implicitly_converts_to(root_module['ns3::IntegerValue'])
-    ## traced-value.h: ns3::TracedValue<unsigned int> [class]
-    root_module['ns3::TracedValue< unsigned int >'].implicitly_converts_to(root_module['ns3::UintegerValue'])
-    ## traced-value.h: ns3::TracedValue<unsigned int> [class]
-    root_module['ns3::TracedValue< unsigned int >'].implicitly_converts_to(root_module['ns3::BooleanValue'])
-    ## traced-value.h: ns3::TracedValue<unsigned int> [class]
-    root_module['ns3::TracedValue< unsigned int >'].implicitly_converts_to(root_module['ns3::EnumValue'])
     module.add_container('std::list< ns3::Ptr< ns3::Packet > >', 'ns3::Ptr< ns3::Packet >', container_type='list')
+    module.add_container('std::list< ns3::Ptr< ns3::UlJob > >', 'ns3::Ptr< ns3::UlJob >', container_type='list')
+    module.add_container('std::list< ns3::Ptr< ns3::Packet const > >', 'ns3::Ptr< ns3::Packet const >', container_type='list')
+    module.add_container('std::vector< ns3::Ptr< ns3::WimaxConnection > >', 'ns3::Ptr< ns3::WimaxConnection >', container_type='vector')
     module.add_container('std::vector< ns3::Ptr< ns3::FlowProbe > >', 'ns3::Ptr< ns3::FlowProbe >', container_type='vector')
     module.add_container('std::list< ns3::Ptr< ns3::RadvdPrefix > >', 'ns3::Ptr< ns3::RadvdPrefix >', container_type='list')
     module.add_container('std::vector< ns3::Ptr< ns3::NetDevice > >', 'ns3::Ptr< ns3::NetDevice >', container_type='vector')
@@ -351,6 +346,7 @@ def register_methods(root_module):
     register_Ns3Vector2D_methods(root_module, root_module['ns3::Vector2D'])
     register_Ns3Vector3D_methods(root_module, root_module['ns3::Vector3D'])
     register_Ns3WeibullVariable_methods(root_module, root_module['ns3::WeibullVariable'])
+    register_Ns3ZetaVariable_methods(root_module, root_module['ns3::ZetaVariable'])
     register_Ns3ZipfVariable_methods(root_module, root_module['ns3::ZipfVariable'])
     register_Ns3Empty_methods(root_module, root_module['ns3::empty'])
     register_Ns3ConstantVariable_methods(root_module, root_module['ns3::ConstantVariable'])
@@ -365,7 +361,6 @@ def register_methods(root_module):
     register_Ns3Object_methods(root_module, root_module['ns3::Object'])
     register_Ns3ObjectAggregateIterator_methods(root_module, root_module['ns3::Object::AggregateIterator'])
     register_Ns3ParetoVariable_methods(root_module, root_module['ns3::ParetoVariable'])
-    register_Ns3SimpleRefCount__Ns3AsciiWriter_Ns3Empty_Ns3DefaultDeleter__lt__ns3AsciiWriter__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AsciiWriter, ns3::empty, ns3::DefaultDeleter<ns3::AsciiWriter> >'])
     register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >'])
     register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeChecker__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> >'])
     register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeValue__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> >'])
@@ -379,6 +374,7 @@ def register_methods(root_module):
     register_Ns3SimpleRefCount__Ns3Ipv6MulticastRoute_Ns3Empty_Ns3DefaultDeleter__lt__ns3Ipv6MulticastRoute__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::Ipv6MulticastRoute, ns3::empty, ns3::DefaultDeleter<ns3::Ipv6MulticastRoute> >'])
     register_Ns3SimpleRefCount__Ns3Ipv6Route_Ns3Empty_Ns3DefaultDeleter__lt__ns3Ipv6Route__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::Ipv6Route, ns3::empty, ns3::DefaultDeleter<ns3::Ipv6Route> >'])
     register_Ns3SimpleRefCount__Ns3MeshWifiInterfaceMacPlugin_Ns3Empty_Ns3DefaultDeleter__lt__ns3MeshWifiInterfaceMacPlugin__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::MeshWifiInterfaceMacPlugin, ns3::empty, ns3::DefaultDeleter<ns3::MeshWifiInterfaceMacPlugin> >'])
+    register_Ns3SimpleRefCount__Ns3OutputStreamWrapper_Ns3Empty_Ns3DefaultDeleter__lt__ns3OutputStreamWrapper__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> >'])
     register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Packet__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> >'])
     register_Ns3SimpleRefCount__Ns3PbbAddressBlock_Ns3Empty_Ns3DefaultDeleter__lt__ns3PbbAddressBlock__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::PbbAddressBlock, ns3::empty, ns3::DefaultDeleter<ns3::PbbAddressBlock> >'])
     register_Ns3SimpleRefCount__Ns3PbbMessage_Ns3Empty_Ns3DefaultDeleter__lt__ns3PbbMessage__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::PbbMessage, ns3::empty, ns3::DefaultDeleter<ns3::PbbMessage> >'])
@@ -425,7 +421,6 @@ def register_methods(root_module):
     register_Ns3Vector2DValue_methods(root_module, root_module['ns3::Vector2DValue'])
     register_Ns3Vector3DChecker_methods(root_module, root_module['ns3::Vector3DChecker'])
     register_Ns3Vector3DValue_methods(root_module, root_module['ns3::Vector3DValue'])
-    register_Ns3TracedValue__Unsigned_int_methods(root_module, root_module['ns3::TracedValue< unsigned int >'])
     register_Ns3ConfigMatchContainer_methods(root_module, root_module['ns3::Config::MatchContainer'])
     return
 
@@ -1575,11 +1570,20 @@ def register_Ns3WeibullVariable_methods(root_module, cls):
     cls.add_constructor([param('double', 'm'), param('double', 's'), param('double', 'b')])
     return
 
+def register_Ns3ZetaVariable_methods(root_module, cls):
+    ## random-variable.h: ns3::ZetaVariable::ZetaVariable(ns3::ZetaVariable const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::ZetaVariable const &', 'arg0')])
+    ## random-variable.h: ns3::ZetaVariable::ZetaVariable(double alpha) [constructor]
+    cls.add_constructor([param('double', 'alpha')])
+    ## random-variable.h: ns3::ZetaVariable::ZetaVariable() [constructor]
+    cls.add_constructor([])
+    return
+
 def register_Ns3ZipfVariable_methods(root_module, cls):
     ## random-variable.h: ns3::ZipfVariable::ZipfVariable(ns3::ZipfVariable const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::ZipfVariable const &', 'arg0')])
-    ## random-variable.h: ns3::ZipfVariable::ZipfVariable(long int n, double alpha) [constructor]
-    cls.add_constructor([param('long int', 'n'), param('double', 'alpha')])
+    ## random-variable.h: ns3::ZipfVariable::ZipfVariable(long int N, double alpha) [constructor]
+    cls.add_constructor([param('long int', 'N'), param('double', 'alpha')])
     ## random-variable.h: ns3::ZipfVariable::ZipfVariable() [constructor]
     cls.add_constructor([])
     return
@@ -1778,18 +1782,10 @@ def register_Ns3ParetoVariable_methods(root_module, cls):
     cls.add_constructor([param('double', 'm'), param('double', 's')])
     ## random-variable.h: ns3::ParetoVariable::ParetoVariable(double m, double s, double b) [constructor]
     cls.add_constructor([param('double', 'm'), param('double', 's'), param('double', 'b')])
-    return
-
-def register_Ns3SimpleRefCount__Ns3AsciiWriter_Ns3Empty_Ns3DefaultDeleter__lt__ns3AsciiWriter__gt___methods(root_module, cls):
-    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::AsciiWriter, ns3::empty, ns3::DefaultDeleter<ns3::AsciiWriter> >::SimpleRefCount() [constructor]
-    cls.add_constructor([])
-    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::AsciiWriter, ns3::empty, ns3::DefaultDeleter<ns3::AsciiWriter> >::SimpleRefCount(ns3::SimpleRefCount<ns3::AsciiWriter, ns3::empty, ns3::DefaultDeleter<ns3::AsciiWriter> > const & o) [copy constructor]
-    cls.add_constructor([param('ns3::SimpleRefCount< ns3::AsciiWriter, ns3::empty, ns3::DefaultDeleter< ns3::AsciiWriter > > const &', 'o')])
-    ## simple-ref-count.h: static void ns3::SimpleRefCount<ns3::AsciiWriter, ns3::empty, ns3::DefaultDeleter<ns3::AsciiWriter> >::Cleanup() [member function]
-    cls.add_method('Cleanup', 
-                   'void', 
-                   [], 
-                   is_static=True)
+    ## random-variable.h: ns3::ParetoVariable::ParetoVariable(std::pair<double,double> params) [constructor]
+    cls.add_constructor([param('std::pair< double, double >', 'params')])
+    ## random-variable.h: ns3::ParetoVariable::ParetoVariable(std::pair<double,double> params, double b) [constructor]
+    cls.add_constructor([param('std::pair< double, double >', 'params'), param('double', 'b')])
     return
 
 def register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, cls):
@@ -1948,6 +1944,18 @@ def register_Ns3SimpleRefCount__Ns3MeshWifiInterfaceMacPlugin_Ns3Empty_Ns3Defaul
                    is_static=True)
     return
 
+def register_Ns3SimpleRefCount__Ns3OutputStreamWrapper_Ns3Empty_Ns3DefaultDeleter__lt__ns3OutputStreamWrapper__gt___methods(root_module, cls):
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> >::SimpleRefCount() [constructor]
+    cls.add_constructor([])
+    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> >::SimpleRefCount(ns3::SimpleRefCount<ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> > const & o) [copy constructor]
+    cls.add_constructor([param('ns3::SimpleRefCount< ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter< ns3::OutputStreamWrapper > > const &', 'o')])
+    ## simple-ref-count.h: static void ns3::SimpleRefCount<ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> >::Cleanup() [member function]
+    cls.add_method('Cleanup', 
+                   'void', 
+                   [], 
+                   is_static=True)
+    return
+
 def register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Packet__gt___methods(root_module, cls):
     ## simple-ref-count.h: ns3::SimpleRefCount<ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> >::SimpleRefCount() [constructor]
     cls.add_constructor([])
@@ -2898,48 +2906,6 @@ def register_Ns3Vector3DValue_methods(root_module, cls):
                    [param('ns3::Vector3D const &', 'value')])
     return
 
-def register_Ns3TracedValue__Unsigned_int_methods(root_module, cls):
-    ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue() [constructor]
-    cls.add_constructor([])
-    ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::TracedValue<unsigned int> const & o) [copy constructor]
-    cls.add_constructor([param('ns3::TracedValue< unsigned int > const &', 'o')])
-    ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(unsigned int const & v) [constructor]
-    cls.add_constructor([param('unsigned int const &', 'v')])
-    ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::IntegerValue const & value) [constructor]
-    cls.add_constructor([param('ns3::IntegerValue const &', 'value')])
-    ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::UintegerValue const & value) [constructor]
-    cls.add_constructor([param('ns3::UintegerValue const &', 'value')])
-    ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::BooleanValue const & value) [constructor]
-    cls.add_constructor([param('ns3::BooleanValue const &', 'value')])
-    ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::EnumValue const & value) [constructor]
-    cls.add_constructor([param('ns3::EnumValue const &', 'value')])
-    ## traced-value.h: void ns3::TracedValue<unsigned int>::Connect(ns3::CallbackBase const & cb, std::basic_string<char,std::char_traits<char>,std::allocator<char> > path) [member function]
-    cls.add_method('Connect', 
-                   'void', 
-                   [param('ns3::CallbackBase const &', 'cb'), param('std::string', 'path')])
-    ## traced-value.h: void ns3::TracedValue<unsigned int>::ConnectWithoutContext(ns3::CallbackBase const & cb) [member function]
-    cls.add_method('ConnectWithoutContext', 
-                   'void', 
-                   [param('ns3::CallbackBase const &', 'cb')])
-    ## traced-value.h: void ns3::TracedValue<unsigned int>::Disconnect(ns3::CallbackBase const & cb, std::basic_string<char,std::char_traits<char>,std::allocator<char> > path) [member function]
-    cls.add_method('Disconnect', 
-                   'void', 
-                   [param('ns3::CallbackBase const &', 'cb'), param('std::string', 'path')])
-    ## traced-value.h: void ns3::TracedValue<unsigned int>::DisconnectWithoutContext(ns3::CallbackBase const & cb) [member function]
-    cls.add_method('DisconnectWithoutContext', 
-                   'void', 
-                   [param('ns3::CallbackBase const &', 'cb')])
-    ## traced-value.h: unsigned int ns3::TracedValue<unsigned int>::Get() const [member function]
-    cls.add_method('Get', 
-                   'unsigned int', 
-                   [], 
-                   is_const=True)
-    ## traced-value.h: void ns3::TracedValue<unsigned int>::Set(unsigned int const & v) [member function]
-    cls.add_method('Set', 
-                   'void', 
-                   [param('unsigned int const &', 'v')])
-    return
-
 def register_Ns3ConfigMatchContainer_methods(root_module, cls):
     ## config.h: ns3::Config::MatchContainer::MatchContainer(ns3::Config::MatchContainer const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::Config::MatchContainer const &', 'arg0')])
@@ -3043,6 +3009,21 @@ def register_functions(root_module):
     module.add_function('MakeBooleanChecker', 
                         'ns3::Ptr< ns3::AttributeChecker const >', 
                         [])
+    ## callback.h: extern ns3::Callback<void,ns3::Ptr<const ns3::Packet>,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ns3::MakeBoundCallback(void (*)( ::ns3::Ptr<ns3::OutputStreamWrapper>,::ns3::Ptr<ns3::Packet const> ) * fnPtr, ns3::Ptr<ns3::OutputStreamWrapper> a) [free function]
+    module.add_function('MakeBoundCallback', 
+                        'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 
+                        [param('void ( * ) ( ns3::Ptr< ns3::OutputStreamWrapper >, ns3::Ptr< ns3::Packet const > ) *', 'fnPtr'), param('ns3::Ptr< ns3::OutputStreamWrapper >', 'a')], 
+                        template_parameters=['void', 'ns3::Ptr<ns3::OutputStreamWrapper>', 'ns3::Ptr<ns3::OutputStreamWrapper>', 'ns3::Ptr<ns3::Packet const>'])
+    ## callback.h: extern ns3::Callback<void,ns3::Ptr<const ns3::Packet>,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ns3::MakeBoundCallback(void (*)( ::ns3::Ptr<ns3::PcapFileWrapper>,::ns3::Ptr<ns3::Packet const> ) * fnPtr, ns3::Ptr<ns3::PcapFileWrapper> a) [free function]
+    module.add_function('MakeBoundCallback', 
+                        'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 
+                        [param('void ( * ) ( ns3::Ptr< ns3::PcapFileWrapper >, ns3::Ptr< ns3::Packet const > ) *', 'fnPtr'), param('ns3::Ptr< ns3::PcapFileWrapper >', 'a')], 
+                        template_parameters=['void', 'ns3::Ptr<ns3::PcapFileWrapper>', 'ns3::Ptr<ns3::PcapFileWrapper>', 'ns3::Ptr<ns3::Packet const>'])
+    ## callback.h: extern ns3::Callback<void,std::basic_string<char, std::char_traits<char>, std::allocator<char> >,ns3::Ptr<const ns3::Packet>,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ns3::MakeBoundCallback(void (*)( ::ns3::Ptr<ns3::OutputStreamWrapper>,::std::basic_string<char,std::char_traits<char>,std::allocator<char> >,::ns3::Ptr<ns3::Packet const> ) * fnPtr, ns3::Ptr<ns3::OutputStreamWrapper> a) [free function]
+    module.add_function('MakeBoundCallback', 
+                        'ns3::Callback< void, std::basic_string< char, std::char_traits< char >, std::allocator< char > >, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 
+                        [param('void ( * ) ( ns3::Ptr< ns3::OutputStreamWrapper >, std::string, ns3::Ptr< ns3::Packet const > ) *', 'fnPtr'), param('ns3::Ptr< ns3::OutputStreamWrapper >', 'a')], 
+                        template_parameters=['void', 'ns3::Ptr<ns3::OutputStreamWrapper>', 'ns3::Ptr<ns3::OutputStreamWrapper>', 'std::string', 'ns3::Ptr<ns3::Packet const>'])
     ## callback.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeCallbackChecker() [free function]
     module.add_function('MakeCallbackChecker', 
                         'ns3::Ptr< ns3::AttributeChecker const >', 

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

@@ -266,6 +266,11 @@ def register_Ns3CsmaNetDevice_methods(root_module, cls):
     cls.add_method('SetQueue', 
                    'void', 
                    [param('ns3::Ptr< ns3::Queue >', 'queue')])
+    ## csma-net-device.h: ns3::Ptr<ns3::Queue> ns3::CsmaNetDevice::GetQueue() const [member function]
+    cls.add_method('GetQueue', 
+                   'ns3::Ptr< ns3::Queue >', 
+                   [], 
+                   is_const=True)
     ## csma-net-device.h: void ns3::CsmaNetDevice::SetReceiveErrorModel(ns3::Ptr<ns3::ErrorModel> em) [member function]
     cls.add_method('SetReceiveErrorModel', 
                    'void', 
@@ -290,15 +295,6 @@ def register_Ns3CsmaNetDevice_methods(root_module, cls):
     cls.add_method('SetReceiveEnable', 
                    'void', 
                    [param('bool', 'enable')])
-    ## csma-net-device.h: void ns3::CsmaNetDevice::SetFrameSize(uint16_t frameSize) [member function]
-    cls.add_method('SetFrameSize', 
-                   'void', 
-                   [param('uint16_t', 'frameSize')])
-    ## csma-net-device.h: uint16_t ns3::CsmaNetDevice::GetFrameSize() const [member function]
-    cls.add_method('GetFrameSize', 
-                   'uint16_t', 
-                   [], 
-                   is_const=True)
     ## csma-net-device.h: void ns3::CsmaNetDevice::SetEncapsulationMode(ns3::CsmaNetDevice::EncapsulationMode mode) [member function]
     cls.add_method('SetEncapsulationMode', 
                    'void', 
@@ -432,11 +428,6 @@ def register_Ns3CsmaNetDevice_methods(root_module, cls):
                    'void', 
                    [], 
                    visibility='protected', is_virtual=True)
-    ## csma-net-device.h: ns3::Ptr<ns3::Queue> ns3::CsmaNetDevice::GetQueue() const [member function]
-    cls.add_method('GetQueue', 
-                   'ns3::Ptr< ns3::Queue >', 
-                   [], 
-                   is_const=True, visibility='protected')
     ## csma-net-device.h: void ns3::CsmaNetDevice::AddHeader(ns3::Ptr<ns3::Packet> p, ns3::Mac48Address source, ns3::Mac48Address dest, uint16_t protocolNumber) [member function]
     cls.add_method('AddHeader', 
                    'void', 

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

@@ -147,6 +147,11 @@ def register_Ns3EmuNetDevice_methods(root_module, cls):
                    'ns3::Ptr< ns3::Node >', 
                    [], 
                    is_const=True, is_virtual=True)
+    ## emu-net-device.h: ns3::Ptr<ns3::Queue> ns3::EmuNetDevice::GetQueue() const [member function]
+    cls.add_method('GetQueue', 
+                   'ns3::Ptr< ns3::Queue >', 
+                   [], 
+                   is_const=True)
     ## emu-net-device.h: static ns3::TypeId ns3::EmuNetDevice::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 

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

@@ -290,6 +290,8 @@ def register_Ns3FlowMonitorFlowStats_methods(root_module, cls):
     cls.add_instance_attribute('delayHistogram', 'ns3::Histogram', is_const=False)
     ## flow-monitor.h: ns3::FlowMonitor::FlowStats::delaySum [variable]
     cls.add_instance_attribute('delaySum', 'ns3::Time', is_const=False)
+    ## flow-monitor.h: ns3::FlowMonitor::FlowStats::flowInterruptionsHistogram [variable]
+    cls.add_instance_attribute('flowInterruptionsHistogram', 'ns3::Histogram', is_const=False)
     ## flow-monitor.h: ns3::FlowMonitor::FlowStats::jitterHistogram [variable]
     cls.add_instance_attribute('jitterHistogram', 'ns3::Histogram', is_const=False)
     ## flow-monitor.h: ns3::FlowMonitor::FlowStats::jitterSum [variable]

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

@@ -331,7 +331,7 @@ def register_Ns3GlobalRouter_methods(root_module, cls):
                    [])
     ## global-router-interface.h: ns3::Ipv4RoutingTableEntry * ns3::GlobalRouter::GetInjectedRoute(uint32_t i) [member function]
     cls.add_method('GetInjectedRoute', 
-                   'ns3::Ipv4RoutingTableEntry *', 
+                   retval('ns3::Ipv4RoutingTableEntry *', caller_owns_return=False), 
                    [param('uint32_t', 'i')])
     ## global-router-interface.h: void ns3::GlobalRouter::RemoveInjectedRoute(uint32_t i) [member function]
     cls.add_method('RemoveInjectedRoute', 
@@ -379,7 +379,7 @@ def register_Ns3Ipv4GlobalRouting_methods(root_module, cls):
                    [])
     ## ipv4-global-routing.h: ns3::Ipv4RoutingTableEntry * ns3::Ipv4GlobalRouting::GetRoute(uint32_t i) [member function]
     cls.add_method('GetRoute', 
-                   'ns3::Ipv4RoutingTableEntry *', 
+                   retval('ns3::Ipv4RoutingTableEntry *', caller_owns_return=False), 
                    [param('uint32_t', 'i')])
     ## ipv4-global-routing.h: static ns3::TypeId ns3::Ipv4GlobalRouting::GetTypeId() [member function]
     cls.add_method('GetTypeId', 

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

@@ -59,6 +59,8 @@ def register_types(module):
     module.add_class('Icmpv6TooBig', parent=root_module['ns3::Icmpv6Header'])
     ## ipv6-extension-header.h: ns3::Ipv6ExtensionHeader [class]
     module.add_class('Ipv6ExtensionHeader', parent=root_module['ns3::Header'])
+    ## ipv6-extension-header.h: ns3::Ipv6ExtensionHopByHopHeader [class]
+    module.add_class('Ipv6ExtensionHopByHopHeader', parent=[root_module['ns3::Ipv6ExtensionHeader'], root_module['ns3::OptionField']])
     ## ipv6-extension-header.h: ns3::Ipv6ExtensionRoutingHeader [class]
     module.add_class('Ipv6ExtensionRoutingHeader', parent=root_module['ns3::Ipv6ExtensionHeader'])
     ## ipv6-option-header.h: ns3::Ipv6OptionHeader [class]
@@ -101,12 +103,16 @@ def register_types(module):
     module.add_enum('RxStatus', ['RX_OK', 'RX_CSUM_FAILED', 'RX_ENDPOINT_CLOSED', 'RX_ENDPOINT_UNREACH'], outer_class=root_module['ns3::Ipv4L4Protocol'])
     ## ipv6-extension-header.h: ns3::Ipv6ExtensionAHHeader [class]
     module.add_class('Ipv6ExtensionAHHeader', parent=root_module['ns3::Ipv6ExtensionHeader'])
+    ## ipv6-extension-header.h: ns3::Ipv6ExtensionDestinationHeader [class]
+    module.add_class('Ipv6ExtensionDestinationHeader', parent=[root_module['ns3::Ipv6ExtensionHeader'], root_module['ns3::OptionField']])
     ## ipv6-extension-header.h: ns3::Ipv6ExtensionESPHeader [class]
     module.add_class('Ipv6ExtensionESPHeader', parent=root_module['ns3::Ipv6ExtensionHeader'])
     ## ipv6-extension-header.h: ns3::Ipv6ExtensionFragmentHeader [class]
     module.add_class('Ipv6ExtensionFragmentHeader', parent=root_module['ns3::Ipv6ExtensionHeader'])
     ## ipv6-extension-header.h: ns3::Ipv6ExtensionLooseRoutingHeader [class]
     module.add_class('Ipv6ExtensionLooseRoutingHeader', parent=root_module['ns3::Ipv6ExtensionRoutingHeader'])
+    ## ipv6-interface.h: ns3::Ipv6Interface [class]
+    module.add_class('Ipv6Interface', parent=root_module['ns3::Object'])
     ## ipv6-l3-protocol.h: ns3::Ipv6L3Protocol [class]
     module.add_class('Ipv6L3Protocol', parent=root_module['ns3::Ipv6'])
     ## ipv6-l3-protocol.h: ns3::Ipv6L3Protocol::DropReason [enumeration]
@@ -231,6 +237,7 @@ def register_methods(root_module):
     register_Ns3Icmpv6TimeExceeded_methods(root_module, root_module['ns3::Icmpv6TimeExceeded'])
     register_Ns3Icmpv6TooBig_methods(root_module, root_module['ns3::Icmpv6TooBig'])
     register_Ns3Ipv6ExtensionHeader_methods(root_module, root_module['ns3::Ipv6ExtensionHeader'])
+    register_Ns3Ipv6ExtensionHopByHopHeader_methods(root_module, root_module['ns3::Ipv6ExtensionHopByHopHeader'])
     register_Ns3Ipv6ExtensionRoutingHeader_methods(root_module, root_module['ns3::Ipv6ExtensionRoutingHeader'])
     register_Ns3Ipv6OptionHeader_methods(root_module, root_module['ns3::Ipv6OptionHeader'])
     register_Ns3Ipv6OptionHeaderAlignment_methods(root_module, root_module['ns3::Ipv6OptionHeader::Alignment'])
@@ -249,9 +256,11 @@ def register_methods(root_module):
     register_Ns3Ipv4L3Protocol_methods(root_module, root_module['ns3::Ipv4L3Protocol'])
     register_Ns3Ipv4L4Protocol_methods(root_module, root_module['ns3::Ipv4L4Protocol'])
     register_Ns3Ipv6ExtensionAHHeader_methods(root_module, root_module['ns3::Ipv6ExtensionAHHeader'])
+    register_Ns3Ipv6ExtensionDestinationHeader_methods(root_module, root_module['ns3::Ipv6ExtensionDestinationHeader'])
     register_Ns3Ipv6ExtensionESPHeader_methods(root_module, root_module['ns3::Ipv6ExtensionESPHeader'])
     register_Ns3Ipv6ExtensionFragmentHeader_methods(root_module, root_module['ns3::Ipv6ExtensionFragmentHeader'])
     register_Ns3Ipv6ExtensionLooseRoutingHeader_methods(root_module, root_module['ns3::Ipv6ExtensionLooseRoutingHeader'])
+    register_Ns3Ipv6Interface_methods(root_module, root_module['ns3::Ipv6Interface'])
     register_Ns3Ipv6L3Protocol_methods(root_module, root_module['ns3::Ipv6L3Protocol'])
     register_Ns3Ipv6L4Protocol_methods(root_module, root_module['ns3::Ipv6L4Protocol'])
     register_Ns3NdiscCache_methods(root_module, root_module['ns3::NdiscCache'])
@@ -1481,6 +1490,43 @@ def register_Ns3Ipv6ExtensionHeader_methods(root_module, cls):
                    [param('uint8_t', 'nextHeader')])
     return
 
+def register_Ns3Ipv6ExtensionHopByHopHeader_methods(root_module, cls):
+    ## ipv6-extension-header.h: ns3::Ipv6ExtensionHopByHopHeader::Ipv6ExtensionHopByHopHeader(ns3::Ipv6ExtensionHopByHopHeader const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::Ipv6ExtensionHopByHopHeader const &', 'arg0')])
+    ## ipv6-extension-header.h: ns3::Ipv6ExtensionHopByHopHeader::Ipv6ExtensionHopByHopHeader() [constructor]
+    cls.add_constructor([])
+    ## ipv6-extension-header.h: uint32_t ns3::Ipv6ExtensionHopByHopHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
+    cls.add_method('Deserialize', 
+                   'uint32_t', 
+                   [param('ns3::Buffer::Iterator', 'start')], 
+                   is_virtual=True)
+    ## ipv6-extension-header.h: ns3::TypeId ns3::Ipv6ExtensionHopByHopHeader::GetInstanceTypeId() const [member function]
+    cls.add_method('GetInstanceTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## ipv6-extension-header.h: uint32_t ns3::Ipv6ExtensionHopByHopHeader::GetSerializedSize() const [member function]
+    cls.add_method('GetSerializedSize', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## ipv6-extension-header.h: static ns3::TypeId ns3::Ipv6ExtensionHopByHopHeader::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## ipv6-extension-header.h: void ns3::Ipv6ExtensionHopByHopHeader::Print(std::ostream & os) const [member function]
+    cls.add_method('Print', 
+                   'void', 
+                   [param('std::ostream &', 'os')], 
+                   is_const=True, is_virtual=True)
+    ## ipv6-extension-header.h: void ns3::Ipv6ExtensionHopByHopHeader::Serialize(ns3::Buffer::Iterator start) const [member function]
+    cls.add_method('Serialize', 
+                   'void', 
+                   [param('ns3::Buffer::Iterator', 'start')], 
+                   is_const=True, is_virtual=True)
+    return
+
 def register_Ns3Ipv6ExtensionRoutingHeader_methods(root_module, cls):
     ## ipv6-extension-header.h: ns3::Ipv6ExtensionRoutingHeader::Ipv6ExtensionRoutingHeader(ns3::Ipv6ExtensionRoutingHeader const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::Ipv6ExtensionRoutingHeader const &', 'arg0')])
@@ -2616,6 +2662,43 @@ def register_Ns3Ipv6ExtensionAHHeader_methods(root_module, cls):
                    is_const=True, is_virtual=True)
     return
 
+def register_Ns3Ipv6ExtensionDestinationHeader_methods(root_module, cls):
+    ## ipv6-extension-header.h: ns3::Ipv6ExtensionDestinationHeader::Ipv6ExtensionDestinationHeader(ns3::Ipv6ExtensionDestinationHeader const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::Ipv6ExtensionDestinationHeader const &', 'arg0')])
+    ## ipv6-extension-header.h: ns3::Ipv6ExtensionDestinationHeader::Ipv6ExtensionDestinationHeader() [constructor]
+    cls.add_constructor([])
+    ## ipv6-extension-header.h: uint32_t ns3::Ipv6ExtensionDestinationHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
+    cls.add_method('Deserialize', 
+                   'uint32_t', 
+                   [param('ns3::Buffer::Iterator', 'start')], 
+                   is_virtual=True)
+    ## ipv6-extension-header.h: ns3::TypeId ns3::Ipv6ExtensionDestinationHeader::GetInstanceTypeId() const [member function]
+    cls.add_method('GetInstanceTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## ipv6-extension-header.h: uint32_t ns3::Ipv6ExtensionDestinationHeader::GetSerializedSize() const [member function]
+    cls.add_method('GetSerializedSize', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## ipv6-extension-header.h: static ns3::TypeId ns3::Ipv6ExtensionDestinationHeader::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## ipv6-extension-header.h: void ns3::Ipv6ExtensionDestinationHeader::Print(std::ostream & os) const [member function]
+    cls.add_method('Print', 
+                   'void', 
+                   [param('std::ostream &', 'os')], 
+                   is_const=True, is_virtual=True)
+    ## ipv6-extension-header.h: void ns3::Ipv6ExtensionDestinationHeader::Serialize(ns3::Buffer::Iterator start) const [member function]
+    cls.add_method('Serialize', 
+                   'void', 
+                   [param('ns3::Buffer::Iterator', 'start')], 
+                   is_const=True, is_virtual=True)
+    return
+
 def register_Ns3Ipv6ExtensionESPHeader_methods(root_module, cls):
     ## ipv6-extension-header.h: ns3::Ipv6ExtensionESPHeader::Ipv6ExtensionESPHeader(ns3::Ipv6ExtensionESPHeader const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::Ipv6ExtensionESPHeader const &', 'arg0')])
@@ -2776,6 +2859,147 @@ def register_Ns3Ipv6ExtensionLooseRoutingHeader_methods(root_module, cls):
                    [param('std::vector< ns3::Ipv6Address >', 'routersAddress')])
     return
 
+def register_Ns3Ipv6Interface_methods(root_module, cls):
+    ## ipv6-interface.h: ns3::Ipv6Interface::Ipv6Interface(ns3::Ipv6Interface const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::Ipv6Interface const &', 'arg0')])
+    ## ipv6-interface.h: ns3::Ipv6Interface::Ipv6Interface() [constructor]
+    cls.add_constructor([])
+    ## ipv6-interface.h: bool ns3::Ipv6Interface::AddAddress(ns3::Ipv6InterfaceAddress iface) [member function]
+    cls.add_method('AddAddress', 
+                   'bool', 
+                   [param('ns3::Ipv6InterfaceAddress', 'iface')])
+    ## ipv6-interface.h: ns3::Ipv6InterfaceAddress ns3::Ipv6Interface::GetAddress(uint32_t index) const [member function]
+    cls.add_method('GetAddress', 
+                   'ns3::Ipv6InterfaceAddress', 
+                   [param('uint32_t', 'index')], 
+                   is_const=True)
+    ## ipv6-interface.h: ns3::Ipv6InterfaceAddress ns3::Ipv6Interface::GetAddressMatchingDestination(ns3::Ipv6Address dst) [member function]
+    cls.add_method('GetAddressMatchingDestination', 
+                   'ns3::Ipv6InterfaceAddress', 
+                   [param('ns3::Ipv6Address', 'dst')])
+    ## ipv6-interface.h: uint16_t ns3::Ipv6Interface::GetBaseReachableTime() const [member function]
+    cls.add_method('GetBaseReachableTime', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
+    ## ipv6-interface.h: uint8_t ns3::Ipv6Interface::GetCurHopLimit() const [member function]
+    cls.add_method('GetCurHopLimit', 
+                   'uint8_t', 
+                   [], 
+                   is_const=True)
+    ## ipv6-interface.h: ns3::Ptr<ns3::NetDevice> ns3::Ipv6Interface::GetDevice() const [member function]
+    cls.add_method('GetDevice', 
+                   'ns3::Ptr< ns3::NetDevice >', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## ipv6-interface.h: ns3::Ipv6InterfaceAddress ns3::Ipv6Interface::GetLinkLocalAddress() const [member function]
+    cls.add_method('GetLinkLocalAddress', 
+                   'ns3::Ipv6InterfaceAddress', 
+                   [], 
+                   is_const=True)
+    ## ipv6-interface.h: uint16_t ns3::Ipv6Interface::GetMetric() const [member function]
+    cls.add_method('GetMetric', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
+    ## ipv6-interface.h: uint32_t ns3::Ipv6Interface::GetNAddresses() const [member function]
+    cls.add_method('GetNAddresses', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
+    ## ipv6-interface.h: uint16_t ns3::Ipv6Interface::GetReachableTime() const [member function]
+    cls.add_method('GetReachableTime', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
+    ## ipv6-interface.h: uint16_t ns3::Ipv6Interface::GetRetransTimer() const [member function]
+    cls.add_method('GetRetransTimer', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
+    ## ipv6-interface.h: static ns3::TypeId ns3::Ipv6Interface::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## ipv6-interface.h: bool ns3::Ipv6Interface::IsDown() const [member function]
+    cls.add_method('IsDown', 
+                   'bool', 
+                   [], 
+                   is_const=True)
+    ## ipv6-interface.h: bool ns3::Ipv6Interface::IsForwarding() const [member function]
+    cls.add_method('IsForwarding', 
+                   'bool', 
+                   [], 
+                   is_const=True)
+    ## ipv6-interface.h: bool ns3::Ipv6Interface::IsUp() const [member function]
+    cls.add_method('IsUp', 
+                   'bool', 
+                   [], 
+                   is_const=True)
+    ## ipv6-interface.h: ns3::Ipv6InterfaceAddress ns3::Ipv6Interface::RemoveAddress(uint32_t index) [member function]
+    cls.add_method('RemoveAddress', 
+                   'ns3::Ipv6InterfaceAddress', 
+                   [param('uint32_t', 'index')])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::Send(ns3::Ptr<ns3::Packet> p, ns3::Ipv6Address dest) [member function]
+    cls.add_method('Send', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv6Address', 'dest')])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::SetBaseReachableTime(uint16_t baseReachableTime) [member function]
+    cls.add_method('SetBaseReachableTime', 
+                   'void', 
+                   [param('uint16_t', 'baseReachableTime')])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::SetCurHopLimit(uint8_t curHopLimit) [member function]
+    cls.add_method('SetCurHopLimit', 
+                   'void', 
+                   [param('uint8_t', 'curHopLimit')])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::SetDevice(ns3::Ptr<ns3::NetDevice> device) [member function]
+    cls.add_method('SetDevice', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::NetDevice >', 'device')])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::SetDown() [member function]
+    cls.add_method('SetDown', 
+                   'void', 
+                   [])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::SetForwarding(bool forward) [member function]
+    cls.add_method('SetForwarding', 
+                   'void', 
+                   [param('bool', 'forward')])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::SetMetric(uint16_t metric) [member function]
+    cls.add_method('SetMetric', 
+                   'void', 
+                   [param('uint16_t', 'metric')])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::SetNode(ns3::Ptr<ns3::Node> node) [member function]
+    cls.add_method('SetNode', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Node >', 'node')])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::SetNsDadUid(ns3::Ipv6Address address, uint32_t uid) [member function]
+    cls.add_method('SetNsDadUid', 
+                   'void', 
+                   [param('ns3::Ipv6Address', 'address'), param('uint32_t', 'uid')])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::SetReachableTime(uint16_t reachableTime) [member function]
+    cls.add_method('SetReachableTime', 
+                   'void', 
+                   [param('uint16_t', 'reachableTime')])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::SetRetransTimer(uint16_t retransTimer) [member function]
+    cls.add_method('SetRetransTimer', 
+                   'void', 
+                   [param('uint16_t', 'retransTimer')])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::SetState(ns3::Ipv6Address address, ns3::Ipv6InterfaceAddress::State_e state) [member function]
+    cls.add_method('SetState', 
+                   'void', 
+                   [param('ns3::Ipv6Address', 'address'), param('ns3::Ipv6InterfaceAddress::State_e', 'state')])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::SetUp() [member function]
+    cls.add_method('SetUp', 
+                   'void', 
+                   [])
+    ## ipv6-interface.h: void ns3::Ipv6Interface::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
+    return
+
 def register_Ns3Ipv6L3Protocol_methods(root_module, cls):
     ## ipv6-l3-protocol.h: ns3::Ipv6L3Protocol::PROT_NUMBER [variable]
     cls.add_static_attribute('PROT_NUMBER', 'uint16_t const', is_const=True)
@@ -3430,10 +3654,6 @@ def register_Ns3Icmpv6L4Protocol_methods(root_module, cls):
     cls.add_method('DoDAD', 
                    'void', 
                    [param('ns3::Ipv6Address', 'target'), param('ns3::Ptr< ns3::Ipv6Interface >', 'interface')])
-    ## icmpv6-l4-protocol.h: void ns3::Icmpv6L4Protocol::DoDad(ns3::Ipv6Address addr, ns3::Ptr<ns3::Ipv6Interface> interface) [member function]
-    cls.add_method('DoDad', 
-                   'void', 
-                   [param('ns3::Ipv6Address', 'addr'), param('ns3::Ptr< ns3::Ipv6Interface >', 'interface')])
     ## icmpv6-l4-protocol.h: ns3::Ptr<ns3::Packet> ns3::Icmpv6L4Protocol::ForgeEchoRequest(ns3::Ipv6Address src, ns3::Ipv6Address dst, uint16_t id, uint16_t seq, ns3::Ptr<ns3::Packet> data) [member function]
     cls.add_method('ForgeEchoRequest', 
                    'ns3::Ptr< ns3::Packet >', 

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

@@ -111,7 +111,7 @@ def register_Ns3Ipv4ListRouting_methods(root_module, cls):
     ## ipv4-list-routing.h: ns3::Ptr<ns3::Ipv4RoutingProtocol> ns3::Ipv4ListRouting::GetRoutingProtocol(uint32_t index, int16_t & priority) const [member function]
     cls.add_method('GetRoutingProtocol', 
                    'ns3::Ptr< ns3::Ipv4RoutingProtocol >', 
-                   [param('uint32_t', 'index'), param('int16_t &', 'priority')], 
+                   [param('uint32_t', 'index'), param('int16_t &', 'priority', direction=2)], 
                    is_const=True, is_virtual=True)
     ## ipv4-list-routing.h: static ns3::TypeId ns3::Ipv4ListRouting::GetTypeId() [member function]
     cls.add_method('GetTypeId', 

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

@@ -385,6 +385,11 @@ def register_Ns3MeshWifiInterfaceMac_methods(root_module, cls):
                    'ns3::TypeId', 
                    [], 
                    is_static=True)
+    ## mesh-wifi-interface-mac.h: ns3::Ptr<ns3::WifiPhy> ns3::MeshWifiInterfaceMac::GetWifiPhy() const [member function]
+    cls.add_method('GetWifiPhy', 
+                   'ns3::Ptr< ns3::WifiPhy >', 
+                   [], 
+                   is_const=True)
     ## mesh-wifi-interface-mac.h: void ns3::MeshWifiInterfaceMac::InstallPlugin(ns3::Ptr<ns3::MeshWifiInterfaceMacPlugin> plugin) [member function]
     cls.add_method('InstallPlugin', 
                    'void', 
@@ -509,6 +514,11 @@ def register_Ns3MeshWifiInterfaceMac_methods(root_module, cls):
                    'void', 
                    [], 
                    visibility='private', is_virtual=True)
+    ## mesh-wifi-interface-mac.h: void ns3::MeshWifiInterfaceMac::DoStart() [member function]
+    cls.add_method('DoStart', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
     ## mesh-wifi-interface-mac.h: void ns3::MeshWifiInterfaceMac::ForwardUp(ns3::Ptr<ns3::Packet> packet, ns3::Mac48Address src, ns3::Mac48Address dst) [member function]
     cls.add_method('ForwardUp', 
                    'void', 

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

@@ -3,8 +3,12 @@ from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandler
 def register_types(module):
     root_module = module.get_root()
     
+    ## box.h: ns3::Box [class]
+    module.add_class('Box')
+    ## box.h: ns3::Box::Side [enumeration]
+    module.add_enum('Side', ['RIGHT', 'LEFT', 'TOP', 'BOTTOM', 'UP', 'DOWN'], outer_class=root_module['ns3::Box'])
     ## constant-velocity-helper.h: ns3::ConstantVelocityHelper [class]
-    module.add_class('ConstantVelocityHelper', allow_subclassing=False)
+    module.add_class('ConstantVelocityHelper')
     ## rectangle.h: ns3::Rectangle [class]
     module.add_class('Rectangle')
     ## rectangle.h: ns3::Rectangle::Side [enumeration]
@@ -13,12 +17,18 @@ def register_types(module):
     module.add_class('Waypoint')
     ## position-allocator.h: ns3::PositionAllocator [class]
     module.add_class('PositionAllocator', parent=root_module['ns3::Object'])
+    ## position-allocator.h: ns3::RandomBoxPositionAllocator [class]
+    module.add_class('RandomBoxPositionAllocator', parent=root_module['ns3::PositionAllocator'])
     ## 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'])
     ## position-allocator.h: ns3::UniformDiscPositionAllocator [class]
     module.add_class('UniformDiscPositionAllocator', parent=root_module['ns3::PositionAllocator'])
+    ## box.h: ns3::BoxChecker [class]
+    module.add_class('BoxChecker', parent=root_module['ns3::AttributeChecker'])
+    ## box.h: ns3::BoxValue [class]
+    module.add_class('BoxValue', parent=root_module['ns3::AttributeValue'])
     ## position-allocator.h: ns3::GridPositionAllocator [class]
     module.add_class('GridPositionAllocator', parent=root_module['ns3::PositionAllocator'])
     ## position-allocator.h: ns3::GridPositionAllocator::LayoutType [enumeration]
@@ -39,6 +49,8 @@ def register_types(module):
     module.add_class('RectangleChecker', parent=root_module['ns3::AttributeChecker'])
     ## rectangle.h: ns3::RectangleValue [class]
     module.add_class('RectangleValue', parent=root_module['ns3::AttributeValue'])
+    ## steady-state-random-waypoint-mobility-model.h: ns3::SteadyStateRandomWaypointMobilityModel [class]
+    module.add_class('SteadyStateRandomWaypointMobilityModel', parent=root_module['ns3::MobilityModel'])
     ## waypoint.h: ns3::WaypointChecker [class]
     module.add_class('WaypointChecker', parent=root_module['ns3::AttributeChecker'])
     ## waypoint-mobility-model.h: ns3::WaypointMobilityModel [class]
@@ -51,6 +63,8 @@ def register_types(module):
     module.add_class('ConstantPositionMobilityModel', parent=root_module['ns3::MobilityModel'])
     ## constant-velocity-mobility-model.h: ns3::ConstantVelocityMobilityModel [class]
     module.add_class('ConstantVelocityMobilityModel', parent=root_module['ns3::MobilityModel'])
+    ## gauss-markov-mobility-model.h: ns3::GaussMarkovMobilityModel [class]
+    module.add_class('GaussMarkovMobilityModel', parent=root_module['ns3::MobilityModel'])
     ## hierarchical-mobility-model.h: ns3::HierarchicalMobilityModel [class]
     module.add_class('HierarchicalMobilityModel', parent=root_module['ns3::MobilityModel'])
     
@@ -135,13 +149,17 @@ def register_types_ns3_olsr(module):
     
 
 def register_methods(root_module):
+    register_Ns3Box_methods(root_module, root_module['ns3::Box'])
     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_Ns3RandomBoxPositionAllocator_methods(root_module, root_module['ns3::RandomBoxPositionAllocator'])
     register_Ns3RandomDiscPositionAllocator_methods(root_module, root_module['ns3::RandomDiscPositionAllocator'])
     register_Ns3RandomRectanglePositionAllocator_methods(root_module, root_module['ns3::RandomRectanglePositionAllocator'])
     register_Ns3UniformDiscPositionAllocator_methods(root_module, root_module['ns3::UniformDiscPositionAllocator'])
+    register_Ns3BoxChecker_methods(root_module, root_module['ns3::BoxChecker'])
+    register_Ns3BoxValue_methods(root_module, root_module['ns3::BoxValue'])
     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'])
@@ -150,15 +168,54 @@ def register_methods(root_module):
     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_Ns3SteadyStateRandomWaypointMobilityModel_methods(root_module, root_module['ns3::SteadyStateRandomWaypointMobilityModel'])
     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'])
+    register_Ns3GaussMarkovMobilityModel_methods(root_module, root_module['ns3::GaussMarkovMobilityModel'])
     register_Ns3HierarchicalMobilityModel_methods(root_module, root_module['ns3::HierarchicalMobilityModel'])
     return
 
+def register_Ns3Box_methods(root_module, cls):
+    cls.add_output_stream_operator()
+    ## box.h: ns3::Box::Box(ns3::Box const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::Box const &', 'arg0')])
+    ## box.h: ns3::Box::Box(double _xMin, double _xMax, double _yMin, double _yMax, double _zMin, double _zMax) [constructor]
+    cls.add_constructor([param('double', '_xMin'), param('double', '_xMax'), param('double', '_yMin'), param('double', '_yMax'), param('double', '_zMin'), param('double', '_zMax')])
+    ## box.h: ns3::Box::Box() [constructor]
+    cls.add_constructor([])
+    ## box.h: ns3::Vector ns3::Box::CalculateIntersection(ns3::Vector const & current, ns3::Vector const & speed) const [member function]
+    cls.add_method('CalculateIntersection', 
+                   'ns3::Vector', 
+                   [param('ns3::Vector const &', 'current'), param('ns3::Vector const &', 'speed')], 
+                   is_const=True)
+    ## box.h: ns3::Box::Side ns3::Box::GetClosestSide(ns3::Vector const & position) const [member function]
+    cls.add_method('GetClosestSide', 
+                   'ns3::Box::Side', 
+                   [param('ns3::Vector const &', 'position')], 
+                   is_const=True)
+    ## box.h: bool ns3::Box::IsInside(ns3::Vector const & position) const [member function]
+    cls.add_method('IsInside', 
+                   'bool', 
+                   [param('ns3::Vector const &', 'position')], 
+                   is_const=True)
+    ## box.h: ns3::Box::xMax [variable]
+    cls.add_instance_attribute('xMax', 'double', is_const=False)
+    ## box.h: ns3::Box::xMin [variable]
+    cls.add_instance_attribute('xMin', 'double', is_const=False)
+    ## box.h: ns3::Box::yMax [variable]
+    cls.add_instance_attribute('yMax', 'double', is_const=False)
+    ## box.h: ns3::Box::yMin [variable]
+    cls.add_instance_attribute('yMin', 'double', is_const=False)
+    ## box.h: ns3::Box::zMax [variable]
+    cls.add_instance_attribute('zMax', 'double', is_const=False)
+    ## box.h: ns3::Box::zMin [variable]
+    cls.add_instance_attribute('zMin', 'double', is_const=False)
+    return
+
 def register_Ns3ConstantVelocityHelper_methods(root_module, cls):
     ## constant-velocity-helper.h: ns3::ConstantVelocityHelper::ConstantVelocityHelper(ns3::ConstantVelocityHelper const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::ConstantVelocityHelper const &', 'arg0')])
@@ -204,6 +261,11 @@ def register_Ns3ConstantVelocityHelper_methods(root_module, cls):
                    'void', 
                    [param('ns3::Rectangle const &', 'rectangle')], 
                    is_const=True)
+    ## constant-velocity-helper.h: void ns3::ConstantVelocityHelper::UpdateWithBounds(ns3::Box const & bounds) const [member function]
+    cls.add_method('UpdateWithBounds', 
+                   'void', 
+                   [param('ns3::Box const &', 'bounds')], 
+                   is_const=True)
     return
 
 def register_Ns3Rectangle_methods(root_module, cls):
@@ -270,6 +332,35 @@ def register_Ns3PositionAllocator_methods(root_module, cls):
                    is_static=True)
     return
 
+def register_Ns3RandomBoxPositionAllocator_methods(root_module, cls):
+    ## position-allocator.h: ns3::RandomBoxPositionAllocator::RandomBoxPositionAllocator(ns3::RandomBoxPositionAllocator const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::RandomBoxPositionAllocator const &', 'arg0')])
+    ## position-allocator.h: ns3::RandomBoxPositionAllocator::RandomBoxPositionAllocator() [constructor]
+    cls.add_constructor([])
+    ## position-allocator.h: ns3::Vector ns3::RandomBoxPositionAllocator::GetNext() const [member function]
+    cls.add_method('GetNext', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## position-allocator.h: static ns3::TypeId ns3::RandomBoxPositionAllocator::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## position-allocator.h: void ns3::RandomBoxPositionAllocator::SetX(ns3::RandomVariable x) [member function]
+    cls.add_method('SetX', 
+                   'void', 
+                   [param('ns3::RandomVariable', 'x')])
+    ## position-allocator.h: void ns3::RandomBoxPositionAllocator::SetY(ns3::RandomVariable y) [member function]
+    cls.add_method('SetY', 
+                   'void', 
+                   [param('ns3::RandomVariable', 'y')])
+    ## position-allocator.h: void ns3::RandomBoxPositionAllocator::SetZ(ns3::RandomVariable z) [member function]
+    cls.add_method('SetZ', 
+                   'void', 
+                   [param('ns3::RandomVariable', 'z')])
+    return
+
 def register_Ns3RandomDiscPositionAllocator_methods(root_module, cls):
     ## position-allocator.h: ns3::RandomDiscPositionAllocator::RandomDiscPositionAllocator(ns3::RandomDiscPositionAllocator const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::RandomDiscPositionAllocator const &', 'arg0')])
@@ -357,6 +448,46 @@ def register_Ns3UniformDiscPositionAllocator_methods(root_module, cls):
                    [param('double', 'y')])
     return
 
+def register_Ns3BoxChecker_methods(root_module, cls):
+    ## box.h: ns3::BoxChecker::BoxChecker() [constructor]
+    cls.add_constructor([])
+    ## box.h: ns3::BoxChecker::BoxChecker(ns3::BoxChecker const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::BoxChecker const &', 'arg0')])
+    return
+
+def register_Ns3BoxValue_methods(root_module, cls):
+    ## box.h: ns3::BoxValue::BoxValue() [constructor]
+    cls.add_constructor([])
+    ## box.h: ns3::BoxValue::BoxValue(ns3::BoxValue const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::BoxValue const &', 'arg0')])
+    ## box.h: ns3::BoxValue::BoxValue(ns3::Box const & value) [constructor]
+    cls.add_constructor([param('ns3::Box const &', 'value')])
+    ## box.h: ns3::Ptr<ns3::AttributeValue> ns3::BoxValue::Copy() const [member function]
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## box.h: bool ns3::BoxValue::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)
+    ## box.h: ns3::Box ns3::BoxValue::Get() const [member function]
+    cls.add_method('Get', 
+                   'ns3::Box', 
+                   [], 
+                   is_const=True)
+    ## box.h: std::string ns3::BoxValue::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)
+    ## box.h: void ns3::BoxValue::Set(ns3::Box const & value) [member function]
+    cls.add_method('Set', 
+                   'void', 
+                   [param('ns3::Box const &', 'value')])
+    return
+
 def register_Ns3GridPositionAllocator_methods(root_module, cls):
     ## position-allocator.h: ns3::GridPositionAllocator::GridPositionAllocator(ns3::GridPositionAllocator const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::GridPositionAllocator const &', 'arg0')])
@@ -646,6 +777,38 @@ def register_Ns3RectangleValue_methods(root_module, cls):
                    [param('ns3::Rectangle const &', 'value')])
     return
 
+def register_Ns3SteadyStateRandomWaypointMobilityModel_methods(root_module, cls):
+    ## steady-state-random-waypoint-mobility-model.h: ns3::SteadyStateRandomWaypointMobilityModel::SteadyStateRandomWaypointMobilityModel(ns3::SteadyStateRandomWaypointMobilityModel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::SteadyStateRandomWaypointMobilityModel const &', 'arg0')])
+    ## steady-state-random-waypoint-mobility-model.h: ns3::SteadyStateRandomWaypointMobilityModel::SteadyStateRandomWaypointMobilityModel() [constructor]
+    cls.add_constructor([])
+    ## steady-state-random-waypoint-mobility-model.h: static ns3::TypeId ns3::SteadyStateRandomWaypointMobilityModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## steady-state-random-waypoint-mobility-model.h: void ns3::SteadyStateRandomWaypointMobilityModel::DoStart() [member function]
+    cls.add_method('DoStart', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
+    ## steady-state-random-waypoint-mobility-model.h: ns3::Vector ns3::SteadyStateRandomWaypointMobilityModel::DoGetPosition() const [member function]
+    cls.add_method('DoGetPosition', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, visibility='private', is_virtual=True)
+    ## steady-state-random-waypoint-mobility-model.h: ns3::Vector ns3::SteadyStateRandomWaypointMobilityModel::DoGetVelocity() const [member function]
+    cls.add_method('DoGetVelocity', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, visibility='private', is_virtual=True)
+    ## steady-state-random-waypoint-mobility-model.h: void ns3::SteadyStateRandomWaypointMobilityModel::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_Ns3WaypointChecker_methods(root_module, cls):
     ## waypoint.h: ns3::WaypointChecker::WaypointChecker() [constructor]
     cls.add_constructor([])
@@ -825,6 +988,38 @@ def register_Ns3ConstantVelocityMobilityModel_methods(root_module, cls):
                    visibility='private', is_virtual=True)
     return
 
+def register_Ns3GaussMarkovMobilityModel_methods(root_module, cls):
+    ## gauss-markov-mobility-model.h: ns3::GaussMarkovMobilityModel::GaussMarkovMobilityModel(ns3::GaussMarkovMobilityModel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::GaussMarkovMobilityModel const &', 'arg0')])
+    ## gauss-markov-mobility-model.h: ns3::GaussMarkovMobilityModel::GaussMarkovMobilityModel() [constructor]
+    cls.add_constructor([])
+    ## gauss-markov-mobility-model.h: static ns3::TypeId ns3::GaussMarkovMobilityModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## gauss-markov-mobility-model.h: void ns3::GaussMarkovMobilityModel::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
+    ## gauss-markov-mobility-model.h: ns3::Vector ns3::GaussMarkovMobilityModel::DoGetPosition() const [member function]
+    cls.add_method('DoGetPosition', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, visibility='private', is_virtual=True)
+    ## gauss-markov-mobility-model.h: ns3::Vector ns3::GaussMarkovMobilityModel::DoGetVelocity() const [member function]
+    cls.add_method('DoGetVelocity', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, visibility='private', is_virtual=True)
+    ## gauss-markov-mobility-model.h: void ns3::GaussMarkovMobilityModel::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_Ns3HierarchicalMobilityModel_methods(root_module, cls):
     ## hierarchical-mobility-model.h: ns3::HierarchicalMobilityModel::HierarchicalMobilityModel(ns3::HierarchicalMobilityModel const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::HierarchicalMobilityModel const &', 'arg0')])
@@ -872,6 +1067,10 @@ def register_Ns3HierarchicalMobilityModel_methods(root_module, cls):
 
 def register_functions(root_module):
     module = root_module
+    ## box.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeBoxChecker() [free function]
+    module.add_function('MakeBoxChecker', 
+                        'ns3::Ptr< ns3::AttributeChecker const >', 
+                        [])
     ## rectangle.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeRectangleChecker() [free function]
     module.add_function('MakeRectangleChecker', 
                         'ns3::Ptr< ns3::AttributeChecker const >', 

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

@@ -0,0 +1,355 @@
+from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandlers
+
+def register_types(module):
+    root_module = module.get_root()
+    
+    ## distributed-simulator-impl.h: ns3::LbtsMessage [class]
+    module.add_class('LbtsMessage')
+    ## mpi-interface.h: ns3::MpiInterface [class]
+    module.add_class('MpiInterface')
+    ## mpi-interface.h: ns3::SentBuffer [class]
+    module.add_class('SentBuffer')
+    ## distributed-simulator-impl.h: ns3::DistributedSimulatorImpl [class]
+    module.add_class('DistributedSimulatorImpl', parent=root_module['ns3::SimulatorImpl'])
+    
+    ## 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_Ns3LbtsMessage_methods(root_module, root_module['ns3::LbtsMessage'])
+    register_Ns3MpiInterface_methods(root_module, root_module['ns3::MpiInterface'])
+    register_Ns3SentBuffer_methods(root_module, root_module['ns3::SentBuffer'])
+    register_Ns3DistributedSimulatorImpl_methods(root_module, root_module['ns3::DistributedSimulatorImpl'])
+    return
+
+def register_Ns3LbtsMessage_methods(root_module, cls):
+    ## distributed-simulator-impl.h: ns3::LbtsMessage::LbtsMessage(ns3::LbtsMessage const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::LbtsMessage const &', 'arg0')])
+    ## distributed-simulator-impl.h: ns3::LbtsMessage::LbtsMessage() [constructor]
+    cls.add_constructor([])
+    ## distributed-simulator-impl.h: ns3::LbtsMessage::LbtsMessage(uint32_t rxc, uint32_t txc, uint32_t id, ns3::Time const & t) [constructor]
+    cls.add_constructor([param('uint32_t', 'rxc'), param('uint32_t', 'txc'), param('uint32_t', 'id'), param('ns3::Time const &', 't')])
+    ## distributed-simulator-impl.h: uint32_t ns3::LbtsMessage::GetMyId() [member function]
+    cls.add_method('GetMyId', 
+                   'uint32_t', 
+                   [])
+    ## distributed-simulator-impl.h: uint32_t ns3::LbtsMessage::GetRxCount() [member function]
+    cls.add_method('GetRxCount', 
+                   'uint32_t', 
+                   [])
+    ## distributed-simulator-impl.h: ns3::Time ns3::LbtsMessage::GetSmallestTime() [member function]
+    cls.add_method('GetSmallestTime', 
+                   'ns3::Time', 
+                   [])
+    ## distributed-simulator-impl.h: uint32_t ns3::LbtsMessage::GetTxCount() [member function]
+    cls.add_method('GetTxCount', 
+                   'uint32_t', 
+                   [])
+    return
+
+def register_Ns3MpiInterface_methods(root_module, cls):
+    ## mpi-interface.h: ns3::MpiInterface::MpiInterface() [constructor]
+    cls.add_constructor([])
+    ## mpi-interface.h: ns3::MpiInterface::MpiInterface(ns3::MpiInterface const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::MpiInterface const &', 'arg0')])
+    ## mpi-interface.h: static void ns3::MpiInterface::Destroy() [member function]
+    cls.add_method('Destroy', 
+                   'void', 
+                   [], 
+                   is_static=True)
+    ## mpi-interface.h: static void ns3::MpiInterface::Enable(int * arg0, char * * * arg1) [member function]
+    cls.add_method('Enable', 
+                   'void', 
+                   [param('int *', 'arg0'), param('char * * *', 'arg1')], 
+                   is_static=True)
+    ## mpi-interface.h: static uint32_t ns3::MpiInterface::GetRxCount() [member function]
+    cls.add_method('GetRxCount', 
+                   'uint32_t', 
+                   [], 
+                   is_static=True)
+    ## mpi-interface.h: static uint32_t ns3::MpiInterface::GetSize() [member function]
+    cls.add_method('GetSize', 
+                   'uint32_t', 
+                   [], 
+                   is_static=True)
+    ## mpi-interface.h: static uint32_t ns3::MpiInterface::GetSystemId() [member function]
+    cls.add_method('GetSystemId', 
+                   'uint32_t', 
+                   [], 
+                   is_static=True)
+    ## mpi-interface.h: static uint32_t ns3::MpiInterface::GetTxCount() [member function]
+    cls.add_method('GetTxCount', 
+                   'uint32_t', 
+                   [], 
+                   is_static=True)
+    ## mpi-interface.h: static bool ns3::MpiInterface::IsEnabled() [member function]
+    cls.add_method('IsEnabled', 
+                   'bool', 
+                   [], 
+                   is_static=True)
+    ## mpi-interface.h: static void ns3::MpiInterface::ReceiveMessages() [member function]
+    cls.add_method('ReceiveMessages', 
+                   'void', 
+                   [], 
+                   is_static=True)
+    ## mpi-interface.h: static void ns3::MpiInterface::SendPacket(ns3::Ptr<ns3::Packet> arg0, ns3::Time const & arg1, uint32_t arg2, uint32_t arg3) [member function]
+    cls.add_method('SendPacket', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Packet >', 'arg0'), param('ns3::Time const &', 'arg1'), param('uint32_t', 'arg2'), param('uint32_t', 'arg3')], 
+                   is_static=True)
+    ## mpi-interface.h: static void ns3::MpiInterface::TestSendComplete() [member function]
+    cls.add_method('TestSendComplete', 
+                   'void', 
+                   [], 
+                   is_static=True)
+    return
+
+def register_Ns3SentBuffer_methods(root_module, cls):
+    ## mpi-interface.h: ns3::SentBuffer::SentBuffer(ns3::SentBuffer const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::SentBuffer const &', 'arg0')])
+    ## mpi-interface.h: ns3::SentBuffer::SentBuffer() [constructor]
+    cls.add_constructor([])
+    ## mpi-interface.h: uint8_t * ns3::SentBuffer::GetBuffer() [member function]
+    cls.add_method('GetBuffer', 
+                   'uint8_t *', 
+                   [])
+    ## mpi-interface.h: MPI_Request * ns3::SentBuffer::GetRequest() [member function]
+    cls.add_method('GetRequest', 
+                   'MPI_Request *', 
+                   [])
+    ## mpi-interface.h: void ns3::SentBuffer::SetBuffer(uint8_t * arg0) [member function]
+    cls.add_method('SetBuffer', 
+                   'void', 
+                   [param('uint8_t *', 'arg0')])
+    return
+
+def register_Ns3DistributedSimulatorImpl_methods(root_module, cls):
+    ## distributed-simulator-impl.h: ns3::DistributedSimulatorImpl::DistributedSimulatorImpl(ns3::DistributedSimulatorImpl const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::DistributedSimulatorImpl const &', 'arg0')])
+    ## distributed-simulator-impl.h: ns3::DistributedSimulatorImpl::DistributedSimulatorImpl() [constructor]
+    cls.add_constructor([])
+    ## distributed-simulator-impl.h: void ns3::DistributedSimulatorImpl::Cancel(ns3::EventId const & ev) [member function]
+    cls.add_method('Cancel', 
+                   'void', 
+                   [param('ns3::EventId const &', 'ev')], 
+                   is_virtual=True)
+    ## distributed-simulator-impl.h: void ns3::DistributedSimulatorImpl::Destroy() [member function]
+    cls.add_method('Destroy', 
+                   'void', 
+                   [], 
+                   is_virtual=True)
+    ## distributed-simulator-impl.h: uint32_t ns3::DistributedSimulatorImpl::GetContext() const [member function]
+    cls.add_method('GetContext', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## distributed-simulator-impl.h: ns3::Time ns3::DistributedSimulatorImpl::GetDelayLeft(ns3::EventId const & id) const [member function]
+    cls.add_method('GetDelayLeft', 
+                   'ns3::Time', 
+                   [param('ns3::EventId const &', 'id')], 
+                   is_const=True, is_virtual=True)
+    ## distributed-simulator-impl.h: ns3::Time ns3::DistributedSimulatorImpl::GetMaximumSimulationTime() const [member function]
+    cls.add_method('GetMaximumSimulationTime', 
+                   'ns3::Time', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## distributed-simulator-impl.h: uint32_t ns3::DistributedSimulatorImpl::GetSystemId() const [member function]
+    cls.add_method('GetSystemId', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## distributed-simulator-impl.h: static ns3::TypeId ns3::DistributedSimulatorImpl::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## distributed-simulator-impl.h: bool ns3::DistributedSimulatorImpl::IsExpired(ns3::EventId const & ev) const [member function]
+    cls.add_method('IsExpired', 
+                   'bool', 
+                   [param('ns3::EventId const &', 'ev')], 
+                   is_const=True, is_virtual=True)
+    ## distributed-simulator-impl.h: bool ns3::DistributedSimulatorImpl::IsFinished() const [member function]
+    cls.add_method('IsFinished', 
+                   'bool', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## distributed-simulator-impl.h: ns3::Time ns3::DistributedSimulatorImpl::Next() const [member function]
+    cls.add_method('Next', 
+                   'ns3::Time', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## distributed-simulator-impl.h: ns3::Time ns3::DistributedSimulatorImpl::Now() const [member function]
+    cls.add_method('Now', 
+                   'ns3::Time', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## distributed-simulator-impl.h: void ns3::DistributedSimulatorImpl::Remove(ns3::EventId const & ev) [member function]
+    cls.add_method('Remove', 
+                   'void', 
+                   [param('ns3::EventId const &', 'ev')], 
+                   is_virtual=True)
+    ## distributed-simulator-impl.h: void ns3::DistributedSimulatorImpl::Run() [member function]
+    cls.add_method('Run', 
+                   'void', 
+                   [], 
+                   is_virtual=True)
+    ## distributed-simulator-impl.h: void ns3::DistributedSimulatorImpl::RunOneEvent() [member function]
+    cls.add_method('RunOneEvent', 
+                   'void', 
+                   [], 
+                   is_virtual=True)
+    ## distributed-simulator-impl.h: ns3::EventId ns3::DistributedSimulatorImpl::Schedule(ns3::Time const & time, ns3::EventImpl * event) [member function]
+    cls.add_method('Schedule', 
+                   'ns3::EventId', 
+                   [param('ns3::Time const &', 'time'), param('ns3::EventImpl *', 'event')], 
+                   is_virtual=True)
+    ## distributed-simulator-impl.h: ns3::EventId ns3::DistributedSimulatorImpl::ScheduleDestroy(ns3::EventImpl * event) [member function]
+    cls.add_method('ScheduleDestroy', 
+                   'ns3::EventId', 
+                   [param('ns3::EventImpl *', 'event')], 
+                   is_virtual=True)
+    ## distributed-simulator-impl.h: ns3::EventId ns3::DistributedSimulatorImpl::ScheduleNow(ns3::EventImpl * event) [member function]
+    cls.add_method('ScheduleNow', 
+                   'ns3::EventId', 
+                   [param('ns3::EventImpl *', 'event')], 
+                   is_virtual=True)
+    ## distributed-simulator-impl.h: void ns3::DistributedSimulatorImpl::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)
+    ## distributed-simulator-impl.h: void ns3::DistributedSimulatorImpl::SetScheduler(ns3::ObjectFactory schedulerFactory) [member function]
+    cls.add_method('SetScheduler', 
+                   'void', 
+                   [param('ns3::ObjectFactory', 'schedulerFactory')], 
+                   is_virtual=True)
+    ## distributed-simulator-impl.h: void ns3::DistributedSimulatorImpl::Stop() [member function]
+    cls.add_method('Stop', 
+                   'void', 
+                   [], 
+                   is_virtual=True)
+    ## distributed-simulator-impl.h: void ns3::DistributedSimulatorImpl::Stop(ns3::Time const & time) [member function]
+    cls.add_method('Stop', 
+                   'void', 
+                   [param('ns3::Time const &', 'time')], 
+                   is_virtual=True)
+    ## distributed-simulator-impl.h: void ns3::DistributedSimulatorImpl::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   '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_nix_vector_routing.py

@@ -110,10 +110,10 @@ def register_Ns3Ipv4NixVectorRouting_methods(root_module, cls):
                    'ns3::TypeId', 
                    [], 
                    is_static=True)
-    ## ipv4-nix-vector-routing.h: void ns3::Ipv4NixVectorRouting::SetNode(ns3::Ptr<ns3::Node> arg0) [member function]
+    ## ipv4-nix-vector-routing.h: void ns3::Ipv4NixVectorRouting::SetNode(ns3::Ptr<ns3::Node> node) [member function]
     cls.add_method('SetNode', 
                    'void', 
-                   [param('ns3::Ptr< ns3::Node >', 'arg0')])
+                   [param('ns3::Ptr< ns3::Node >', 'node')])
     ## ipv4-nix-vector-routing.h: void ns3::Ipv4NixVectorRouting::DoDispose() [member function]
     cls.add_method('DoDispose', 
                    'void', 

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

@@ -73,6 +73,12 @@ def register_types(module):
     module.add_class('LlcSnapHeader', parent=root_module['ns3::Header'])
     ## queue.h: ns3::Queue [class]
     module.add_class('Queue', parent=root_module['ns3::Object'])
+    ## radiotap-header.h: ns3::RadiotapHeader [class]
+    module.add_class('RadiotapHeader', parent=root_module['ns3::Header'])
+    ## radiotap-header.h: ns3::RadiotapHeader [enumeration]
+    module.add_enum('', ['FRAME_FLAG_NONE', 'FRAME_FLAG_CFP', 'FRAME_FLAG_SHORT_PREAMBLE', 'FRAME_FLAG_WEP', 'FRAME_FLAG_FRAGMENTED', 'FRAME_FLAG_FCS_INCLUDED', 'FRAME_FLAG_DATA_PADDING', 'FRAME_FLAG_BAD_FCS', 'FRAME_FLAG_SHORT_GUARD'], outer_class=root_module['ns3::RadiotapHeader'])
+    ## radiotap-header.h: ns3::RadiotapHeader [enumeration]
+    module.add_enum('', ['CHANNEL_FLAG_NONE', 'CHANNEL_FLAG_TURBO', 'CHANNEL_FLAG_CCK', 'CHANNEL_FLAG_OFDM', 'CHANNEL_FLAG_SPECTRUM_2GHZ', 'CHANNEL_FLAG_SPECTRUM_5GHZ', 'CHANNEL_FLAG_PASSIVE', 'CHANNEL_FLAG_DYNAMIC', 'CHANNEL_FLAG_GFSK'], outer_class=root_module['ns3::RadiotapHeader'])
     ## simple-ref-count.h: ns3::SimpleRefCount<ns3::Ipv4MulticastRoute, ns3::empty, ns3::DefaultDeleter<ns3::Ipv4MulticastRoute> > [class]
     module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::Ipv4MulticastRoute', 'ns3::empty', 'ns3::DefaultDeleter<ns3::Ipv4MulticastRoute>'], 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::Ipv4Route, ns3::empty, ns3::DefaultDeleter<ns3::Ipv4Route> > [class]
@@ -92,7 +98,7 @@ def register_types(module):
     ## socket.h: ns3::Socket [class]
     module.add_class('Socket', parent=root_module['ns3::Object'])
     ## socket.h: ns3::Socket::SocketErrno [enumeration]
-    module.add_enum('SocketErrno', ['ERROR_NOTERROR', 'ERROR_ISCONN', 'ERROR_NOTCONN', 'ERROR_MSGSIZE', 'ERROR_AGAIN', 'ERROR_SHUTDOWN', 'ERROR_OPNOTSUPP', 'ERROR_AFNOSUPPORT', 'ERROR_INVAL', 'ERROR_BADF', 'ERROR_NOROUTETOHOST', 'SOCKET_ERRNO_LAST'], outer_class=root_module['ns3::Socket'])
+    module.add_enum('SocketErrno', ['ERROR_NOTERROR', 'ERROR_ISCONN', 'ERROR_NOTCONN', 'ERROR_MSGSIZE', 'ERROR_AGAIN', 'ERROR_SHUTDOWN', 'ERROR_OPNOTSUPP', 'ERROR_AFNOSUPPORT', 'ERROR_INVAL', 'ERROR_BADF', 'ERROR_NOROUTETOHOST', 'ERROR_NODEV', 'ERROR_ADDRNOTAVAIL', 'SOCKET_ERRNO_LAST'], outer_class=root_module['ns3::Socket'])
     ## socket.h: ns3::SocketAddressTag [class]
     module.add_class('SocketAddressTag', parent=root_module['ns3::Tag'])
     ## socket-factory.h: ns3::SocketFactory [class]
@@ -302,6 +308,7 @@ def register_methods(root_module):
     register_Ns3Ipv6Header_methods(root_module, root_module['ns3::Ipv6Header'])
     register_Ns3LlcSnapHeader_methods(root_module, root_module['ns3::LlcSnapHeader'])
     register_Ns3Queue_methods(root_module, root_module['ns3::Queue'])
+    register_Ns3RadiotapHeader_methods(root_module, root_module['ns3::RadiotapHeader'])
     register_Ns3Socket_methods(root_module, root_module['ns3::Socket'])
     register_Ns3SocketAddressTag_methods(root_module, root_module['ns3::SocketAddressTag'])
     register_Ns3SocketFactory_methods(root_module, root_module['ns3::SocketFactory'])
@@ -610,6 +617,11 @@ def register_Ns3Ipv4Address_methods(root_module, cls):
                    'bool', 
                    [param('ns3::Ipv4Address const &', 'other')], 
                    is_const=True)
+    ## ipv4-address.h: bool ns3::Ipv4Address::IsLocalMulticast() const [member function]
+    cls.add_method('IsLocalMulticast', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## ipv4-address.h: static bool ns3::Ipv4Address::IsMatchingType(ns3::Address const & address) [member function]
     cls.add_method('IsMatchingType', 
                    'bool', 
@@ -1864,6 +1876,110 @@ def register_Ns3Queue_methods(root_module, cls):
                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
     return
 
+def register_Ns3RadiotapHeader_methods(root_module, cls):
+    ## radiotap-header.h: ns3::RadiotapHeader::RadiotapHeader(ns3::RadiotapHeader const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::RadiotapHeader const &', 'arg0')])
+    ## radiotap-header.h: ns3::RadiotapHeader::RadiotapHeader() [constructor]
+    cls.add_constructor([])
+    ## radiotap-header.h: uint32_t ns3::RadiotapHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
+    cls.add_method('Deserialize', 
+                   'uint32_t', 
+                   [param('ns3::Buffer::Iterator', 'start')], 
+                   is_virtual=True)
+    ## radiotap-header.h: uint8_t ns3::RadiotapHeader::GetAntennaNoisePower() const [member function]
+    cls.add_method('GetAntennaNoisePower', 
+                   'uint8_t', 
+                   [], 
+                   is_const=True)
+    ## radiotap-header.h: uint8_t ns3::RadiotapHeader::GetAntennaSignalPower() const [member function]
+    cls.add_method('GetAntennaSignalPower', 
+                   'uint8_t', 
+                   [], 
+                   is_const=True)
+    ## radiotap-header.h: uint16_t ns3::RadiotapHeader::GetChannelFlags() const [member function]
+    cls.add_method('GetChannelFlags', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
+    ## radiotap-header.h: uint16_t ns3::RadiotapHeader::GetChannelFrequency() const [member function]
+    cls.add_method('GetChannelFrequency', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
+    ## radiotap-header.h: uint8_t ns3::RadiotapHeader::GetFrameFlags() const [member function]
+    cls.add_method('GetFrameFlags', 
+                   'uint8_t', 
+                   [], 
+                   is_const=True)
+    ## radiotap-header.h: ns3::TypeId ns3::RadiotapHeader::GetInstanceTypeId() const [member function]
+    cls.add_method('GetInstanceTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## radiotap-header.h: uint8_t ns3::RadiotapHeader::GetRate() const [member function]
+    cls.add_method('GetRate', 
+                   'uint8_t', 
+                   [], 
+                   is_const=True)
+    ## radiotap-header.h: uint32_t ns3::RadiotapHeader::GetSerializedSize() const [member function]
+    cls.add_method('GetSerializedSize', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## radiotap-header.h: uint64_t ns3::RadiotapHeader::GetTsft() const [member function]
+    cls.add_method('GetTsft', 
+                   'uint64_t', 
+                   [], 
+                   is_const=True)
+    ## radiotap-header.h: static ns3::TypeId ns3::RadiotapHeader::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## radiotap-header.h: void ns3::RadiotapHeader::Print(std::ostream & os) const [member function]
+    cls.add_method('Print', 
+                   'void', 
+                   [param('std::ostream &', 'os')], 
+                   is_const=True, is_virtual=True)
+    ## radiotap-header.h: void ns3::RadiotapHeader::Serialize(ns3::Buffer::Iterator start) const [member function]
+    cls.add_method('Serialize', 
+                   'void', 
+                   [param('ns3::Buffer::Iterator', 'start')], 
+                   is_const=True, is_virtual=True)
+    ## radiotap-header.h: void ns3::RadiotapHeader::SetAntennaNoisePower(int8_t noise) [member function]
+    cls.add_method('SetAntennaNoisePower', 
+                   'void', 
+                   [param('int8_t', 'noise')])
+    ## radiotap-header.h: void ns3::RadiotapHeader::SetAntennaNoisePower(double noise) [member function]
+    cls.add_method('SetAntennaNoisePower', 
+                   'void', 
+                   [param('double', 'noise')])
+    ## radiotap-header.h: void ns3::RadiotapHeader::SetAntennaSignalPower(int8_t signal) [member function]
+    cls.add_method('SetAntennaSignalPower', 
+                   'void', 
+                   [param('int8_t', 'signal')])
+    ## radiotap-header.h: void ns3::RadiotapHeader::SetAntennaSignalPower(double signal) [member function]
+    cls.add_method('SetAntennaSignalPower', 
+                   'void', 
+                   [param('double', 'signal')])
+    ## radiotap-header.h: void ns3::RadiotapHeader::SetChannelFrequencyAndFlags(uint16_t frequency, uint16_t flags) [member function]
+    cls.add_method('SetChannelFrequencyAndFlags', 
+                   'void', 
+                   [param('uint16_t', 'frequency'), param('uint16_t', 'flags')])
+    ## radiotap-header.h: void ns3::RadiotapHeader::SetFrameFlags(uint8_t flags) [member function]
+    cls.add_method('SetFrameFlags', 
+                   'void', 
+                   [param('uint8_t', 'flags')])
+    ## radiotap-header.h: void ns3::RadiotapHeader::SetRate(uint8_t rate) [member function]
+    cls.add_method('SetRate', 
+                   'void', 
+                   [param('uint8_t', 'rate')])
+    ## radiotap-header.h: void ns3::RadiotapHeader::SetTsft(uint64_t tsft) [member function]
+    cls.add_method('SetTsft', 
+                   'void', 
+                   [param('uint64_t', 'tsft')])
+    return
+
 def register_Ns3Socket_methods(root_module, cls):
     ## socket.h: ns3::Socket::Socket(ns3::Socket const & arg0) [copy constructor]
     cls.add_constructor([param('ns3::Socket const &', 'arg0')])
@@ -4580,11 +4696,6 @@ def register_Ns3PbbPacket_methods(root_module, cls):
                    'int', 
                    [], 
                    is_const=True)
-    ## packetbb.h: void ns3::PbbPacket::SerializePacketTlv(ns3::Buffer::Iterator & start) const [member function]
-    cls.add_method('SerializePacketTlv', 
-                   'void', 
-                   [param('ns3::Buffer::Iterator &', 'start')], 
-                   is_const=True, visibility='protected')
     return
 
 def register_Ns3PbbTlv_methods(root_module, cls):
@@ -4864,6 +4975,10 @@ def register_Ns3SimpleNetDevice_methods(root_module, cls):
                    'void', 
                    [param('ns3::Callback< 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 >', 'cb')], 
                    is_virtual=True)
+    ## simple-net-device.h: void ns3::SimpleNetDevice::SetReceiveErrorModel(ns3::Ptr<ns3::ErrorModel> em) [member function]
+    cls.add_method('SetReceiveErrorModel', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::ErrorModel >', 'em')])
     ## simple-net-device.h: bool ns3::SimpleNetDevice::SupportsSendFrom() const [member function]
     cls.add_method('SupportsSendFrom', 
                    'bool', 

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

@@ -11,6 +11,8 @@ def register_types(module):
     module.add_container('std::vector< ns3::olsr::LinkTuple >', 'ns3::olsr::LinkTuple', container_type='vector')
     module.add_container('std::vector< ns3::olsr::TopologyTuple >', 'ns3::olsr::TopologyTuple', container_type='vector')
     module.add_container('std::vector< ns3::olsr::IfaceAssocTuple >', 'ns3::olsr::IfaceAssocTuple', container_type='vector')
+    module.add_container('std::vector< ns3::olsr::AssociationTuple >', 'ns3::olsr::AssociationTuple', container_type='vector')
+    module.add_container('std::vector< ns3::olsr::Association >', 'ns3::olsr::Association', container_type='vector')
     
     ## Register a nested module for the namespace Config
     
@@ -91,6 +93,10 @@ def register_types_ns3_internal(module):
 def register_types_ns3_olsr(module):
     root_module = module.get_root()
     
+    ## olsr-repositories.h: ns3::olsr::Association [struct]
+    module.add_class('Association')
+    ## olsr-repositories.h: ns3::olsr::AssociationTuple [struct]
+    module.add_class('AssociationTuple')
     ## olsr-repositories.h: ns3::olsr::DuplicateTuple [struct]
     module.add_class('DuplicateTuple')
     ## olsr-repositories.h: ns3::olsr::IfaceAssocTuple [struct]
@@ -133,24 +139,31 @@ def register_types_ns3_olsr(module):
     module.add_class('TwoHopNeighborTuple')
     module.add_container('std::vector< ns3::olsr::MessageHeader::Hello::LinkMessage >', 'ns3::olsr::MessageHeader::Hello::LinkMessage', container_type='vector')
     module.add_container('std::vector< ns3::olsr::MessageHeader::Hna::Association >', 'ns3::olsr::MessageHeader::Hna::Association', container_type='vector')
+    module.add_container('std::vector< ns3::olsr::RoutingTableEntry >', 'ns3::olsr::RoutingTableEntry', container_type='vector')
     typehandlers.add_type_alias('std::vector< ns3::olsr::DuplicateTuple, std::allocator< ns3::olsr::DuplicateTuple > >', 'ns3::olsr::DuplicateSet')
     typehandlers.add_type_alias('std::vector< ns3::olsr::DuplicateTuple, std::allocator< ns3::olsr::DuplicateTuple > >*', 'ns3::olsr::DuplicateSet*')
     typehandlers.add_type_alias('std::vector< ns3::olsr::DuplicateTuple, std::allocator< ns3::olsr::DuplicateTuple > >&', 'ns3::olsr::DuplicateSet&')
     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::AssociationTuple, std::allocator< ns3::olsr::AssociationTuple > >', 'ns3::olsr::AssociationSet')
+    typehandlers.add_type_alias('std::vector< ns3::olsr::AssociationTuple, std::allocator< ns3::olsr::AssociationTuple > >*', 'ns3::olsr::AssociationSet*')
+    typehandlers.add_type_alias('std::vector< ns3::olsr::AssociationTuple, std::allocator< ns3::olsr::AssociationTuple > >&', 'ns3::olsr::AssociationSet&')
+    typehandlers.add_type_alias('std::vector< ns3::olsr::TopologyTuple, std::allocator< ns3::olsr::TopologyTuple > >', 'ns3::olsr::TopologySet')
+    typehandlers.add_type_alias('std::vector< ns3::olsr::TopologyTuple, std::allocator< ns3::olsr::TopologyTuple > >*', 'ns3::olsr::TopologySet*')
+    typehandlers.add_type_alias('std::vector< ns3::olsr::TopologyTuple, std::allocator< ns3::olsr::TopologyTuple > >&', 'ns3::olsr::TopologySet&')
     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::vector< ns3::olsr::Association, std::allocator< ns3::olsr::Association > >', 'ns3::olsr::Associations')
+    typehandlers.add_type_alias('std::vector< ns3::olsr::Association, std::allocator< ns3::olsr::Association > >*', 'ns3::olsr::Associations*')
+    typehandlers.add_type_alias('std::vector< ns3::olsr::Association, std::allocator< ns3::olsr::Association > >&', 'ns3::olsr::Associations&')
     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&')
     typehandlers.add_type_alias('std::vector< ns3::olsr::MprSelectorTuple, std::allocator< ns3::olsr::MprSelectorTuple > >', 'ns3::olsr::MprSelectorSet')
     typehandlers.add_type_alias('std::vector< ns3::olsr::MprSelectorTuple, std::allocator< ns3::olsr::MprSelectorTuple > >*', 'ns3::olsr::MprSelectorSet*')
     typehandlers.add_type_alias('std::vector< ns3::olsr::MprSelectorTuple, std::allocator< ns3::olsr::MprSelectorTuple > >&', 'ns3::olsr::MprSelectorSet&')
-    typehandlers.add_type_alias('std::vector< ns3::olsr::TopologyTuple, std::allocator< ns3::olsr::TopologyTuple > >', 'ns3::olsr::TopologySet')
-    typehandlers.add_type_alias('std::vector< ns3::olsr::TopologyTuple, std::allocator< ns3::olsr::TopologyTuple > >*', 'ns3::olsr::TopologySet*')
-    typehandlers.add_type_alias('std::vector< ns3::olsr::TopologyTuple, std::allocator< ns3::olsr::TopologyTuple > >&', 'ns3::olsr::TopologySet&')
     typehandlers.add_type_alias('std::vector< ns3::olsr::MessageHeader, std::allocator< ns3::olsr::MessageHeader > >', 'ns3::olsr::MessageList')
     typehandlers.add_type_alias('std::vector< ns3::olsr::MessageHeader, std::allocator< ns3::olsr::MessageHeader > >*', 'ns3::olsr::MessageList*')
     typehandlers.add_type_alias('std::vector< ns3::olsr::MessageHeader, std::allocator< ns3::olsr::MessageHeader > >&', 'ns3::olsr::MessageList&')
@@ -163,6 +176,8 @@ def register_types_ns3_olsr(module):
 
 def register_methods(root_module):
     register_Ns3OlsrState_methods(root_module, root_module['ns3::OlsrState'])
+    register_Ns3OlsrAssociation_methods(root_module, root_module['ns3::olsr::Association'])
+    register_Ns3OlsrAssociationTuple_methods(root_module, root_module['ns3::olsr::AssociationTuple'])
     register_Ns3OlsrDuplicateTuple_methods(root_module, root_module['ns3::olsr::DuplicateTuple'])
     register_Ns3OlsrIfaceAssocTuple_methods(root_module, root_module['ns3::olsr::IfaceAssocTuple'])
     register_Ns3OlsrLinkTuple_methods(root_module, root_module['ns3::olsr::LinkTuple'])
@@ -188,6 +203,14 @@ def register_Ns3OlsrState_methods(root_module, cls):
     cls.add_constructor([param('ns3::OlsrState const &', 'arg0')])
     ## olsr-state.h: ns3::OlsrState::OlsrState() [constructor]
     cls.add_constructor([])
+    ## olsr-state.h: void ns3::OlsrState::EraseAssociation(ns3::olsr::Association const & tuple) [member function]
+    cls.add_method('EraseAssociation', 
+                   'void', 
+                   [param('ns3::olsr::Association const &', 'tuple')])
+    ## olsr-state.h: void ns3::OlsrState::EraseAssociationTuple(ns3::olsr::AssociationTuple const & tuple) [member function]
+    cls.add_method('EraseAssociationTuple', 
+                   'void', 
+                   [param('ns3::olsr::AssociationTuple const &', 'tuple')])
     ## olsr-state.h: void ns3::OlsrState::EraseDuplicateTuple(ns3::olsr::DuplicateTuple const & tuple) [member function]
     cls.add_method('EraseDuplicateTuple', 
                    'void', 
@@ -236,6 +259,10 @@ def register_Ns3OlsrState_methods(root_module, cls):
     cls.add_method('EraseTwoHopNeighborTuples', 
                    'void', 
                    [param('ns3::Ipv4Address const &', 'neighbor'), param('ns3::Ipv4Address const &', 'twoHopNeighbor')])
+    ## olsr-state.h: ns3::olsr::AssociationTuple * ns3::OlsrState::FindAssociationTuple(ns3::Ipv4Address const & gatewayAddr, ns3::Ipv4Address const & networkAddr, ns3::Ipv4Mask const & netmask) [member function]
+    cls.add_method('FindAssociationTuple', 
+                   'ns3::olsr::AssociationTuple *', 
+                   [param('ns3::Ipv4Address const &', 'gatewayAddr'), param('ns3::Ipv4Address const &', 'networkAddr'), param('ns3::Ipv4Mask const &', 'netmask')])
     ## olsr-state.h: ns3::olsr::DuplicateTuple * ns3::OlsrState::FindDuplicateTuple(ns3::Ipv4Address const & address, uint16_t sequenceNumber) [member function]
     cls.add_method('FindDuplicateTuple', 
                    'ns3::olsr::DuplicateTuple *', 
@@ -295,6 +322,16 @@ def register_Ns3OlsrState_methods(root_module, cls):
     cls.add_method('FindTwoHopNeighborTuple', 
                    'ns3::olsr::TwoHopNeighborTuple *', 
                    [param('ns3::Ipv4Address const &', 'neighbor'), param('ns3::Ipv4Address const &', 'twoHopNeighbor')])
+    ## olsr-state.h: ns3::olsr::AssociationSet const & ns3::OlsrState::GetAssociationSet() const [member function]
+    cls.add_method('GetAssociationSet', 
+                   'ns3::olsr::AssociationSet const &', 
+                   [], 
+                   is_const=True)
+    ## olsr-state.h: ns3::olsr::Associations const & ns3::OlsrState::GetAssociations() const [member function]
+    cls.add_method('GetAssociations', 
+                   'ns3::olsr::Associations const &', 
+                   [], 
+                   is_const=True)
     ## olsr-state.h: ns3::olsr::IfaceAssocSet const & ns3::OlsrState::GetIfaceAssocSet() const [member function]
     cls.add_method('GetIfaceAssocSet', 
                    'ns3::olsr::IfaceAssocSet const &', 
@@ -342,6 +379,14 @@ def register_Ns3OlsrState_methods(root_module, cls):
     cls.add_method('GetTwoHopNeighbors', 
                    'ns3::olsr::TwoHopNeighborSet &', 
                    [])
+    ## olsr-state.h: void ns3::OlsrState::InsertAssociation(ns3::olsr::Association const & tuple) [member function]
+    cls.add_method('InsertAssociation', 
+                   'void', 
+                   [param('ns3::olsr::Association const &', 'tuple')])
+    ## olsr-state.h: void ns3::OlsrState::InsertAssociationTuple(ns3::olsr::AssociationTuple const & tuple) [member function]
+    cls.add_method('InsertAssociationTuple', 
+                   'void', 
+                   [param('ns3::olsr::AssociationTuple const &', 'tuple')])
     ## olsr-state.h: void ns3::OlsrState::InsertDuplicateTuple(ns3::olsr::DuplicateTuple const & tuple) [member function]
     cls.add_method('InsertDuplicateTuple', 
                    'void', 
@@ -381,6 +426,36 @@ def register_Ns3OlsrState_methods(root_module, cls):
                    [param('ns3::olsr::MprSet', 'mprSet')])
     return
 
+def register_Ns3OlsrAssociation_methods(root_module, cls):
+    cls.add_output_stream_operator()
+    cls.add_binary_comparison_operator('==')
+    ## olsr-repositories.h: ns3::olsr::Association::Association() [constructor]
+    cls.add_constructor([])
+    ## olsr-repositories.h: ns3::olsr::Association::Association(ns3::olsr::Association const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::olsr::Association const &', 'arg0')])
+    ## olsr-repositories.h: ns3::olsr::Association::netmask [variable]
+    cls.add_instance_attribute('netmask', 'ns3::Ipv4Mask', is_const=False)
+    ## olsr-repositories.h: ns3::olsr::Association::networkAddr [variable]
+    cls.add_instance_attribute('networkAddr', 'ns3::Ipv4Address', is_const=False)
+    return
+
+def register_Ns3OlsrAssociationTuple_methods(root_module, cls):
+    cls.add_output_stream_operator()
+    cls.add_binary_comparison_operator('==')
+    ## olsr-repositories.h: ns3::olsr::AssociationTuple::AssociationTuple() [constructor]
+    cls.add_constructor([])
+    ## olsr-repositories.h: ns3::olsr::AssociationTuple::AssociationTuple(ns3::olsr::AssociationTuple const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::olsr::AssociationTuple const &', 'arg0')])
+    ## olsr-repositories.h: ns3::olsr::AssociationTuple::expirationTime [variable]
+    cls.add_instance_attribute('expirationTime', 'ns3::Time', is_const=False)
+    ## olsr-repositories.h: ns3::olsr::AssociationTuple::gatewayAddr [variable]
+    cls.add_instance_attribute('gatewayAddr', 'ns3::Ipv4Address', is_const=False)
+    ## olsr-repositories.h: ns3::olsr::AssociationTuple::netmask [variable]
+    cls.add_instance_attribute('netmask', 'ns3::Ipv4Mask', is_const=False)
+    ## olsr-repositories.h: ns3::olsr::AssociationTuple::networkAddr [variable]
+    cls.add_instance_attribute('networkAddr', 'ns3::Ipv4Address', is_const=False)
+    return
+
 def register_Ns3OlsrDuplicateTuple_methods(root_module, cls):
     cls.add_binary_comparison_operator('==')
     ## olsr-repositories.h: ns3::olsr::DuplicateTuple::DuplicateTuple() [constructor]
@@ -808,19 +883,41 @@ 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::AddHostNetworkAssociation(ns3::Ipv4Address networkAddr, ns3::Ipv4Mask netmask) [member function]
+    cls.add_method('AddHostNetworkAssociation', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'networkAddr'), param('ns3::Ipv4Mask', 'netmask')])
     ## olsr-routing-protocol.h: void ns3::olsr::RoutingProtocol::Dump() [member function]
     cls.add_method('Dump', 
                    'void', 
                    [])
+    ## olsr-routing-protocol.h: std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int> > ns3::olsr::RoutingProtocol::GetInterfaceExclusions() const [member function]
+    cls.add_method('GetInterfaceExclusions', 
+                   'std::set< unsigned int >', 
+                   [], 
+                   is_const=True)
+    ## olsr-routing-protocol.h: std::vector<ns3::olsr::RoutingTableEntry,std::allocator<ns3::olsr::RoutingTableEntry> > ns3::olsr::RoutingProtocol::GetRoutingTableEntries() const [member function]
+    cls.add_method('GetRoutingTableEntries', 
+                   'std::vector< ns3::olsr::RoutingTableEntry >', 
+                   [], 
+                   is_const=True)
     ## olsr-routing-protocol.h: static ns3::TypeId ns3::olsr::RoutingProtocol::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
                    [], 
                    is_static=True)
+    ## olsr-routing-protocol.h: void ns3::olsr::RoutingProtocol::SetInterfaceExclusions(std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int> > exceptions) [member function]
+    cls.add_method('SetInterfaceExclusions', 
+                   'void', 
+                   [param('std::set< unsigned int >', 'exceptions')])
     ## olsr-routing-protocol.h: void ns3::olsr::RoutingProtocol::SetMainInterface(uint32_t interface) [member function]
     cls.add_method('SetMainInterface', 
                    'void', 
                    [param('uint32_t', 'interface')])
+    ## olsr-routing-protocol.h: void ns3::olsr::RoutingProtocol::SetRoutingTableAssociation(ns3::Ptr<ns3::Ipv4StaticRouting> routingTable) [member function]
+    cls.add_method('SetRoutingTableAssociation', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Ipv4StaticRouting >', 'routingTable')])
     ## olsr-routing-protocol.h: void ns3::olsr::RoutingProtocol::DoStart() [member function]
     cls.add_method('DoStart', 
                    'void', 

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

@@ -9,6 +9,8 @@ def register_types(module):
     module.add_class('PointToPointChannel', parent=root_module['ns3::Channel'])
     ## point-to-point-net-device.h: ns3::PointToPointNetDevice [class]
     module.add_class('PointToPointNetDevice', parent=root_module['ns3::NetDevice'])
+    ## point-to-point-remote-channel.h: ns3::PointToPointRemoteChannel [class]
+    module.add_class('PointToPointRemoteChannel', parent=root_module['ns3::PointToPointChannel'])
     
     ## Register a nested module for the namespace Config
     
@@ -94,6 +96,7 @@ def register_methods(root_module):
     register_Ns3PppHeader_methods(root_module, root_module['ns3::PppHeader'])
     register_Ns3PointToPointChannel_methods(root_module, root_module['ns3::PointToPointChannel'])
     register_Ns3PointToPointNetDevice_methods(root_module, root_module['ns3::PointToPointNetDevice'])
+    register_Ns3PointToPointRemoteChannel_methods(root_module, root_module['ns3::PointToPointRemoteChannel'])
     return
 
 def register_Ns3PppHeader_methods(root_module, cls):
@@ -173,7 +176,28 @@ def register_Ns3PointToPointChannel_methods(root_module, cls):
     ## point-to-point-channel.h: bool ns3::PointToPointChannel::TransmitStart(ns3::Ptr<ns3::Packet> p, ns3::Ptr<ns3::PointToPointNetDevice> src, ns3::Time txTime) [member function]
     cls.add_method('TransmitStart', 
                    'bool', 
-                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ptr< ns3::PointToPointNetDevice >', 'src'), param('ns3::Time', 'txTime')])
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ptr< ns3::PointToPointNetDevice >', 'src'), param('ns3::Time', 'txTime')], 
+                   is_virtual=True)
+    ## point-to-point-channel.h: ns3::Time ns3::PointToPointChannel::GetDelay() const [member function]
+    cls.add_method('GetDelay', 
+                   'ns3::Time', 
+                   [], 
+                   is_const=True, visibility='protected')
+    ## point-to-point-channel.h: ns3::Ptr<ns3::PointToPointNetDevice> ns3::PointToPointChannel::GetDestination(uint32_t i) const [member function]
+    cls.add_method('GetDestination', 
+                   'ns3::Ptr< ns3::PointToPointNetDevice >', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True, visibility='protected')
+    ## point-to-point-channel.h: ns3::Ptr<ns3::PointToPointNetDevice> ns3::PointToPointChannel::GetSource(uint32_t i) const [member function]
+    cls.add_method('GetSource', 
+                   'ns3::Ptr< ns3::PointToPointNetDevice >', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True, visibility='protected')
+    ## point-to-point-channel.h: bool ns3::PointToPointChannel::IsInitialized() const [member function]
+    cls.add_method('IsInitialized', 
+                   'bool', 
+                   [], 
+                   is_const=True, visibility='protected')
     return
 
 def register_Ns3PointToPointNetDevice_methods(root_module, cls):
@@ -205,11 +229,6 @@ def register_Ns3PointToPointNetDevice_methods(root_module, cls):
                    'ns3::Ptr< ns3::Channel >', 
                    [], 
                    is_const=True, is_virtual=True)
-    ## point-to-point-net-device.h: uint16_t ns3::PointToPointNetDevice::GetFrameSize() const [member function]
-    cls.add_method('GetFrameSize', 
-                   'uint16_t', 
-                   [], 
-                   is_const=True)
     ## point-to-point-net-device.h: uint32_t ns3::PointToPointNetDevice::GetIfIndex() const [member function]
     cls.add_method('GetIfIndex', 
                    'uint32_t', 
@@ -235,6 +254,11 @@ def register_Ns3PointToPointNetDevice_methods(root_module, cls):
                    'ns3::Ptr< ns3::Node >', 
                    [], 
                    is_const=True, is_virtual=True)
+    ## point-to-point-net-device.h: ns3::Ptr<ns3::Queue> ns3::PointToPointNetDevice::GetQueue() const [member function]
+    cls.add_method('GetQueue', 
+                   'ns3::Ptr< ns3::Queue >', 
+                   [], 
+                   is_const=True)
     ## point-to-point-net-device.h: static ns3::TypeId ns3::PointToPointNetDevice::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -293,10 +317,6 @@ def register_Ns3PointToPointNetDevice_methods(root_module, cls):
     cls.add_method('SetDataRate', 
                    'void', 
                    [param('ns3::DataRate', 'bps')])
-    ## point-to-point-net-device.h: void ns3::PointToPointNetDevice::SetFrameSize(uint16_t frameSize) [member function]
-    cls.add_method('SetFrameSize', 
-                   'void', 
-                   [param('uint16_t', 'frameSize')])
     ## point-to-point-net-device.h: void ns3::PointToPointNetDevice::SetIfIndex(uint32_t const index) [member function]
     cls.add_method('SetIfIndex', 
                    'void', 
@@ -346,6 +366,23 @@ def register_Ns3PointToPointNetDevice_methods(root_module, cls):
                    visibility='private', is_virtual=True)
     return
 
+def register_Ns3PointToPointRemoteChannel_methods(root_module, cls):
+    ## point-to-point-remote-channel.h: ns3::PointToPointRemoteChannel::PointToPointRemoteChannel(ns3::PointToPointRemoteChannel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::PointToPointRemoteChannel const &', 'arg0')])
+    ## point-to-point-remote-channel.h: ns3::PointToPointRemoteChannel::PointToPointRemoteChannel() [constructor]
+    cls.add_constructor([])
+    ## point-to-point-remote-channel.h: static ns3::TypeId ns3::PointToPointRemoteChannel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## point-to-point-remote-channel.h: bool ns3::PointToPointRemoteChannel::TransmitStart(ns3::Ptr<ns3::Packet> p, ns3::Ptr<ns3::PointToPointNetDevice> src, ns3::Time txTime) [member function]
+    cls.add_method('TransmitStart', 
+                   'bool', 
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ptr< ns3::PointToPointNetDevice >', 'src'), param('ns3::Time', 'txTime')], 
+                   is_virtual=True)
+    return
+
 def register_functions(root_module):
     module = root_module
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)

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

@@ -317,6 +317,11 @@ def register_Ns3Simulator_methods(root_module, cls):
                    'ns3::Time', 
                    [], 
                    is_static=True)
+    ## simulator.h: static uint32_t ns3::Simulator::GetSystemId() [member function]
+    cls.add_method('GetSystemId', 
+                   'uint32_t', 
+                   [], 
+                   is_static=True)
     ## simulator.h: static bool ns3::Simulator::IsExpired(ns3::EventId const & id) [member function]
     cls.add_method('IsExpired', 
                    'bool', 
@@ -331,7 +336,7 @@ def register_Ns3Simulator_methods(root_module, cls):
     cls.add_method('Next', 
                    'ns3::Time', 
                    [], 
-                   is_static=True)
+                   is_static=True, deprecated=True)
     ## simulator.h: static ns3::Time ns3::Simulator::Now() [member function]
     cls.add_method('Now', 
                    'ns3::Time', 
@@ -346,7 +351,7 @@ def register_Ns3Simulator_methods(root_module, cls):
     cls.add_method('RunOneEvent', 
                    'void', 
                    [], 
-                   is_static=True)
+                   is_static=True, deprecated=True)
     ## simulator.h: static void ns3::Simulator::SetImplementation(ns3::Ptr<ns3::SimulatorImpl> impl) [member function]
     cls.add_method('SetImplementation', 
                    'void', 
@@ -795,6 +800,11 @@ def register_Ns3SimulatorImpl_methods(root_module, cls):
                    'ns3::Time', 
                    [], 
                    is_pure_virtual=True, is_const=True, is_virtual=True)
+    ## simulator-impl.h: uint32_t ns3::SimulatorImpl::GetSystemId() const [member function]
+    cls.add_method('GetSystemId', 
+                   'uint32_t', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     ## simulator-impl.h: bool ns3::SimulatorImpl::IsExpired(ns3::EventId const & ev) const [member function]
     cls.add_method('IsExpired', 
                    'bool', 
@@ -1129,6 +1139,11 @@ def register_Ns3DefaultSimulatorImpl_methods(root_module, cls):
                    'ns3::Time', 
                    [], 
                    is_const=True, is_virtual=True)
+    ## default-simulator-impl.h: uint32_t ns3::DefaultSimulatorImpl::GetSystemId() const [member function]
+    cls.add_method('GetSystemId', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## default-simulator-impl.h: static ns3::TypeId ns3::DefaultSimulatorImpl::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1423,6 +1438,11 @@ def register_Ns3RealtimeSimulatorImpl_methods(root_module, cls):
                    'ns3::RealtimeSimulatorImpl::SynchronizationMode', 
                    [], 
                    is_const=True)
+    ## realtime-simulator-impl.h: uint32_t ns3::RealtimeSimulatorImpl::GetSystemId() const [member function]
+    cls.add_method('GetSystemId', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## realtime-simulator-impl.h: static ns3::TypeId ns3::RealtimeSimulatorImpl::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 

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

@@ -13,8 +13,12 @@ def register_types(module):
     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'], root_module['ns3::StatisticalSummary']])
     ## 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]
@@ -116,7 +120,9 @@ def register_methods(root_module):
     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 >'])
@@ -364,6 +370,67 @@ 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: long int ns3::MinMaxAvgTotalCalculator<unsigned int>::getCount() const [member function]
+    cls.add_method('getCount', 
+                   'long int', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## basic-data-calculators.h: double ns3::MinMaxAvgTotalCalculator<unsigned int>::getMax() const [member function]
+    cls.add_method('getMax', 
+                   'double', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## basic-data-calculators.h: double ns3::MinMaxAvgTotalCalculator<unsigned int>::getMean() const [member function]
+    cls.add_method('getMean', 
+                   'double', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## basic-data-calculators.h: double ns3::MinMaxAvgTotalCalculator<unsigned int>::getMin() const [member function]
+    cls.add_method('getMin', 
+                   'double', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## basic-data-calculators.h: double ns3::MinMaxAvgTotalCalculator<unsigned int>::getSqrSum() const [member function]
+    cls.add_method('getSqrSum', 
+                   'double', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## basic-data-calculators.h: double ns3::MinMaxAvgTotalCalculator<unsigned int>::getStddev() const [member function]
+    cls.add_method('getStddev', 
+                   'double', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## basic-data-calculators.h: double ns3::MinMaxAvgTotalCalculator<unsigned int>::getSum() const [member function]
+    cls.add_method('getSum', 
+                   'double', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## basic-data-calculators.h: double ns3::MinMaxAvgTotalCalculator<unsigned int>::getVariance() const [member function]
+    cls.add_method('getVariance', 
+                   'double', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## 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')])
@@ -381,6 +448,26 @@ 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')])

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

@@ -0,0 +1,262 @@
+from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandlers
+
+def register_types(module):
+    root_module = module.get_root()
+    
+    ## topology-reader.h: ns3::TopologyReader [class]
+    module.add_class('TopologyReader', parent=root_module['ns3::Object'])
+    ## topology-reader.h: ns3::TopologyReader::Link [class]
+    module.add_class('Link', outer_class=root_module['ns3::TopologyReader'])
+    ## inet-topology-reader.h: ns3::InetTopologyReader [class]
+    module.add_class('InetTopologyReader', parent=root_module['ns3::TopologyReader'])
+    ## orbis-topology-reader.h: ns3::OrbisTopologyReader [class]
+    module.add_class('OrbisTopologyReader', parent=root_module['ns3::TopologyReader'])
+    
+    ## 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_Ns3TopologyReader_methods(root_module, root_module['ns3::TopologyReader'])
+    register_Ns3TopologyReaderLink_methods(root_module, root_module['ns3::TopologyReader::Link'])
+    register_Ns3InetTopologyReader_methods(root_module, root_module['ns3::InetTopologyReader'])
+    register_Ns3OrbisTopologyReader_methods(root_module, root_module['ns3::OrbisTopologyReader'])
+    return
+
+def register_Ns3TopologyReader_methods(root_module, cls):
+    ## topology-reader.h: ns3::TopologyReader::TopologyReader() [constructor]
+    cls.add_constructor([])
+    ## topology-reader.h: void ns3::TopologyReader::AddLink(ns3::TopologyReader::Link link) [member function]
+    cls.add_method('AddLink', 
+                   'void', 
+                   [param('ns3::TopologyReader::Link', 'link')])
+    ## topology-reader.h: std::string ns3::TopologyReader::GetFileName() const [member function]
+    cls.add_method('GetFileName', 
+                   'std::string', 
+                   [], 
+                   is_const=True)
+    ## topology-reader.h: static ns3::TypeId ns3::TopologyReader::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## topology-reader.h: std::_List_const_iterator<ns3::TopologyReader::Link> ns3::TopologyReader::LinksBegin() const [member function]
+    cls.add_method('LinksBegin', 
+                   'std::_List_const_iterator< ns3::TopologyReader::Link >', 
+                   [], 
+                   is_const=True)
+    ## topology-reader.h: bool ns3::TopologyReader::LinksEmpty() const [member function]
+    cls.add_method('LinksEmpty', 
+                   'bool', 
+                   [], 
+                   is_const=True)
+    ## topology-reader.h: std::_List_const_iterator<ns3::TopologyReader::Link> ns3::TopologyReader::LinksEnd() const [member function]
+    cls.add_method('LinksEnd', 
+                   'std::_List_const_iterator< ns3::TopologyReader::Link >', 
+                   [], 
+                   is_const=True)
+    ## topology-reader.h: int ns3::TopologyReader::LinksSize() const [member function]
+    cls.add_method('LinksSize', 
+                   'int', 
+                   [], 
+                   is_const=True)
+    ## topology-reader.h: ns3::NodeContainer ns3::TopologyReader::Read() [member function]
+    cls.add_method('Read', 
+                   'ns3::NodeContainer', 
+                   [], 
+                   is_pure_virtual=True, is_virtual=True)
+    ## topology-reader.h: void ns3::TopologyReader::SetFileName(std::string const fileName) [member function]
+    cls.add_method('SetFileName', 
+                   'void', 
+                   [param('std::string const', 'fileName')])
+    return
+
+def register_Ns3TopologyReaderLink_methods(root_module, cls):
+    ## topology-reader.h: ns3::TopologyReader::Link::Link(ns3::TopologyReader::Link const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::TopologyReader::Link const &', 'arg0')])
+    ## topology-reader.h: ns3::TopologyReader::Link::Link(ns3::Ptr<ns3::Node> fromPtr, std::string fromName, ns3::Ptr<ns3::Node> toPtr, std::string toName) [constructor]
+    cls.add_constructor([param('ns3::Ptr< ns3::Node >', 'fromPtr'), param('std::string', 'fromName'), param('ns3::Ptr< ns3::Node >', 'toPtr'), param('std::string', 'toName')])
+    ## topology-reader.h: std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > ns3::TopologyReader::Link::AttributesBegin() [member function]
+    cls.add_method('AttributesBegin', 
+                   'std::_Rb_tree_const_iterator< std::pair< std::basic_string< char, std::char_traits< char >, std::allocator< char > > const, std::basic_string< char, std::char_traits< char >, std::allocator< char > > > >', 
+                   [])
+    ## topology-reader.h: std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > ns3::TopologyReader::Link::AttributesEnd() [member function]
+    cls.add_method('AttributesEnd', 
+                   'std::_Rb_tree_const_iterator< std::pair< std::basic_string< char, std::char_traits< char >, std::allocator< char > > const, std::basic_string< char, std::char_traits< char >, std::allocator< char > > > >', 
+                   [])
+    ## topology-reader.h: std::string ns3::TopologyReader::Link::GetAttribute(std::string name) [member function]
+    cls.add_method('GetAttribute', 
+                   'std::string', 
+                   [param('std::string', 'name')])
+    ## topology-reader.h: bool ns3::TopologyReader::Link::GetAttributeFailSafe(std::string name, std::string & value) [member function]
+    cls.add_method('GetAttributeFailSafe', 
+                   'bool', 
+                   [param('std::string', 'name'), param('std::string &', 'value')])
+    ## topology-reader.h: ns3::Ptr<ns3::Node> ns3::TopologyReader::Link::GetFromNode() const [member function]
+    cls.add_method('GetFromNode', 
+                   'ns3::Ptr< ns3::Node >', 
+                   [], 
+                   is_const=True)
+    ## topology-reader.h: std::string ns3::TopologyReader::Link::GetFromNodeName() const [member function]
+    cls.add_method('GetFromNodeName', 
+                   'std::string', 
+                   [], 
+                   is_const=True)
+    ## topology-reader.h: ns3::Ptr<ns3::Node> ns3::TopologyReader::Link::GetToNode() const [member function]
+    cls.add_method('GetToNode', 
+                   'ns3::Ptr< ns3::Node >', 
+                   [], 
+                   is_const=True)
+    ## topology-reader.h: std::string ns3::TopologyReader::Link::GetToNodeName() const [member function]
+    cls.add_method('GetToNodeName', 
+                   'std::string', 
+                   [], 
+                   is_const=True)
+    ## topology-reader.h: void ns3::TopologyReader::Link::SetAttribute(std::string name, std::string & value) [member function]
+    cls.add_method('SetAttribute', 
+                   'void', 
+                   [param('std::string', 'name'), param('std::string &', 'value')])
+    return
+
+def register_Ns3InetTopologyReader_methods(root_module, cls):
+    ## inet-topology-reader.h: static ns3::TypeId ns3::InetTopologyReader::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## inet-topology-reader.h: ns3::InetTopologyReader::InetTopologyReader() [constructor]
+    cls.add_constructor([])
+    ## inet-topology-reader.h: ns3::NodeContainer ns3::InetTopologyReader::Read() [member function]
+    cls.add_method('Read', 
+                   'ns3::NodeContainer', 
+                   [], 
+                   is_virtual=True)
+    return
+
+def register_Ns3OrbisTopologyReader_methods(root_module, cls):
+    ## orbis-topology-reader.h: static ns3::TypeId ns3::OrbisTopologyReader::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## orbis-topology-reader.h: ns3::OrbisTopologyReader::OrbisTopologyReader() [constructor]
+    cls.add_constructor([])
+    ## orbis-topology-reader.h: ns3::NodeContainer ns3::OrbisTopologyReader::Read() [member function]
+    cls.add_method('Read', 
+                   'ns3::NodeContainer', 
+                   [], 
+                   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/ns3modulegen_generated.py

@@ -17,6 +17,7 @@ import ns3_module_simulator
 import ns3_module_test
 import ns3_module_common
 import ns3_module_mobility
+import ns3_module_mpi
 import ns3_module_contrib
 import ns3_module_node
 import ns3_module_bridge
@@ -31,9 +32,11 @@ import ns3_module_point_to_point
 import ns3_module_static_routing
 import ns3_module_stats
 import ns3_module_tap_bridge
+import ns3_module_topology_read
 import ns3_module_v4ping
 import ns3_module_virtual_net_device
 import ns3_module_wifi
+import ns3_module_wimax
 import ns3_module_aodv
 import ns3_module_flow_monitor
 import ns3_module_nix_vector_routing
@@ -109,6 +112,17 @@ def register_types(module):
         ns3_module_mobility__local.register_types(module)
     
     root_module.end_section('ns3_module_mobility')
+    root_module.begin_section('ns3_module_mpi')
+    ns3_module_mpi.register_types(module)
+    
+    try:
+        import ns3_module_mpi__local
+    except ImportError:
+        pass
+    else:
+        ns3_module_mpi__local.register_types(module)
+    
+    root_module.end_section('ns3_module_mpi')
     root_module.begin_section('ns3_module_contrib')
     ns3_module_contrib.register_types(module)
     
@@ -263,6 +277,17 @@ def register_types(module):
         ns3_module_tap_bridge__local.register_types(module)
     
     root_module.end_section('ns3_module_tap_bridge')
+    root_module.begin_section('ns3_module_topology_read')
+    ns3_module_topology_read.register_types(module)
+    
+    try:
+        import ns3_module_topology_read__local
+    except ImportError:
+        pass
+    else:
+        ns3_module_topology_read__local.register_types(module)
+    
+    root_module.end_section('ns3_module_topology_read')
     root_module.begin_section('ns3_module_v4ping')
     ns3_module_v4ping.register_types(module)
     
@@ -296,6 +321,17 @@ def register_types(module):
         ns3_module_wifi__local.register_types(module)
     
     root_module.end_section('ns3_module_wifi')
+    root_module.begin_section('ns3_module_wimax')
+    ns3_module_wimax.register_types(module)
+    
+    try:
+        import ns3_module_wimax__local
+    except ImportError:
+        pass
+    else:
+        ns3_module_wimax__local.register_types(module)
+    
+    root_module.end_section('ns3_module_wimax')
     root_module.begin_section('ns3_module_aodv')
     ns3_module_aodv.register_types(module)
     
@@ -430,6 +466,11 @@ def register_types(module):
     root_module.end_section('ns3_module_flame')
     module.add_container('std::vector< unsigned int >', 'unsigned int', container_type='vector')
     module.add_container('std::vector< bool >', 'bool', container_type='vector')
+    module.add_container('std::vector< ns3::ServiceFlow * >', 'ns3::ServiceFlow *', container_type='vector')
+    module.add_container('ns3::bvec', 'bool', container_type='vector')
+    module.add_container('std::vector< ns3::SSRecord * >', 'ns3::SSRecord *', container_type='vector')
+    module.add_container('std::map< std::string, std::string >', ('std::string', 'std::string'), container_type='map')
+    module.add_container('std::list< std::pair< ns3::OfdmDlMapIe *, ns3::Ptr< ns3::PacketBurst > > >', 'std::pair< ns3::OfdmDlMapIe *, ns3::Ptr< ns3::PacketBurst > >', container_type='list')
     module.add_container('std::vector< unsigned long >', 'long unsigned int', container_type='vector')
     module.add_container('std::list< unsigned int >', 'unsigned int', container_type='list')
     module.add_container('std::list< std::pair< ns3::Ptr< ns3::Packet >, ns3::AmsduSubframeHeader > >', 'std::pair< ns3::Ptr< ns3::Packet >, ns3::AmsduSubframeHeader >', container_type='list')
@@ -515,6 +556,7 @@ def register_types_ns3_internal(module):
 def register_types_ns3_olsr(module):
     root_module = module.get_root()
     
+    module.add_container('std::set< unsigned int >', 'unsigned int', container_type='set')
 
 def register_methods(root_module):
     root_module.begin_section('ns3_module_core')
@@ -572,6 +614,17 @@ def register_methods(root_module):
         ns3_module_mobility__local.register_methods(root_module)
     
     root_module.end_section('ns3_module_mobility')
+    root_module.begin_section('ns3_module_mpi')
+    ns3_module_mpi.register_methods(root_module)
+    
+    try:
+        import ns3_module_mpi__local
+    except ImportError:
+        pass
+    else:
+        ns3_module_mpi__local.register_methods(root_module)
+    
+    root_module.end_section('ns3_module_mpi')
     root_module.begin_section('ns3_module_contrib')
     ns3_module_contrib.register_methods(root_module)
     
@@ -726,6 +779,17 @@ def register_methods(root_module):
         ns3_module_tap_bridge__local.register_methods(root_module)
     
     root_module.end_section('ns3_module_tap_bridge')
+    root_module.begin_section('ns3_module_topology_read')
+    ns3_module_topology_read.register_methods(root_module)
+    
+    try:
+        import ns3_module_topology_read__local
+    except ImportError:
+        pass
+    else:
+        ns3_module_topology_read__local.register_methods(root_module)
+    
+    root_module.end_section('ns3_module_topology_read')
     root_module.begin_section('ns3_module_v4ping')
     ns3_module_v4ping.register_methods(root_module)
     
@@ -759,6 +823,17 @@ def register_methods(root_module):
         ns3_module_wifi__local.register_methods(root_module)
     
     root_module.end_section('ns3_module_wifi')
+    root_module.begin_section('ns3_module_wimax')
+    ns3_module_wimax.register_methods(root_module)
+    
+    try:
+        import ns3_module_wimax__local
+    except ImportError:
+        pass
+    else:
+        ns3_module_wimax__local.register_methods(root_module)
+    
+    root_module.end_section('ns3_module_wimax')
     root_module.begin_section('ns3_module_aodv')
     ns3_module_aodv.register_methods(root_module)
     
@@ -950,6 +1025,17 @@ def register_functions(root_module):
         ns3_module_mobility__local.register_functions(root_module)
     
     root_module.end_section('ns3_module_mobility')
+    root_module.begin_section('ns3_module_mpi')
+    ns3_module_mpi.register_functions(root_module)
+    
+    try:
+        import ns3_module_mpi__local
+    except ImportError:
+        pass
+    else:
+        ns3_module_mpi__local.register_functions(root_module)
+    
+    root_module.end_section('ns3_module_mpi')
     root_module.begin_section('ns3_module_contrib')
     ns3_module_contrib.register_functions(root_module)
     
@@ -1104,6 +1190,17 @@ def register_functions(root_module):
         ns3_module_tap_bridge__local.register_functions(root_module)
     
     root_module.end_section('ns3_module_tap_bridge')
+    root_module.begin_section('ns3_module_topology_read')
+    ns3_module_topology_read.register_functions(root_module)
+    
+    try:
+        import ns3_module_topology_read__local
+    except ImportError:
+        pass
+    else:
+        ns3_module_topology_read__local.register_functions(root_module)
+    
+    root_module.end_section('ns3_module_topology_read')
     root_module.begin_section('ns3_module_v4ping')
     ns3_module_v4ping.register_functions(root_module)
     
@@ -1137,6 +1234,17 @@ def register_functions(root_module):
         ns3_module_wifi__local.register_functions(root_module)
     
     root_module.end_section('ns3_module_wifi')
+    root_module.begin_section('ns3_module_wimax')
+    ns3_module_wimax.register_functions(root_module)
+    
+    try:
+        import ns3_module_wimax__local
+    except ImportError:
+        pass
+    else:
+        ns3_module_wimax__local.register_functions(root_module)
+    
+    root_module.end_section('ns3_module_wimax')
     root_module.begin_section('ns3_module_aodv')
     ns3_module_aodv.register_functions(root_module)
     

bindings/python/ns3modulegen.py

@@ -12,7 +12,9 @@ sys.path.insert(0, sys.argv[2])
 
 from pybindgen import FileCodeSink, write_preamble
 from pybindgen.module import MultiSectionFactory
+
 import pybindgen.settings
+pybindgen.settings.deprecated_virtuals = False
 
 from ns3modulegen_generated import module_init, register_types, register_methods, register_functions
 import ns3modulegen_core_customizations
@@ -54,7 +56,7 @@ class MyMultiSectionFactory(MultiSectionFactory):
         self.main_file_name = main_file_name
         self.main_sink = FileCodeSink(open(main_file_name, "wt"))
         self.header_name = "ns3module.h"
-        header_file_name = os.path.join(os.path.dirname(self.main_file_name), self.header_name)
+        header_file_name = os.path.join(os.path.dirname(self.main_file_name), 'pch', self.header_name)
         self.header_sink = FileCodeSink(open(header_file_name, "wt"))
         self.section_sinks = {'__main__': self.main_sink}
 

bindings/python/ns3modulegen_core_customizations.py

@@ -24,7 +24,7 @@ class SmartPointerTransformation(typehandlers.TypeTransformation):
     """
     def __init__(self):
         super(SmartPointerTransformation, self).__init__()
-        self.rx = re.compile(r'(ns3::|::ns3::|)Ptr<([^>]+)>')
+        self.rx = re.compile(r'(ns3::|::ns3::|)Ptr<([^>]+)>\s*$')
 
     def _get_untransformed_type_traits(self, name):
         m = self.rx.match(name)
@@ -350,180 +350,21 @@ static ns3::TypeId GetTypeId (void)
             "NS_OBJECT_ENSURE_REGISTERED (%s);" % helper_class.name)
     Object.add_helper_class_hook(helper_class_hook)
 
-    ## Replace all class constructors with a generic constructor based on CreateObjectWithAttributes<T> (AttributeList)
-    module.header.writeln('''
-namespace ns3 {
+    def ns3_object_instance_creation_function(cpp_class, code_block, lvalue,
+                                              parameters, construct_type_name):
+        assert lvalue
+        assert not lvalue.startswith('None')
+        if cpp_class.cannot_be_constructed:
+            raise CodeGenerationError("%s cannot be constructed (%s)"
+                                      % cpp_class.full_name)
+        if cpp_class.incomplete_type:
+            raise CodeGenerationError("%s cannot be constructed (incomplete type)"
+                                      % cpp_class.full_name)
+        code_block.write_code("%s = new %s(%s);" % (lvalue, construct_type_name, parameters))
+        code_block.write_code("%s->Ref ();" % (lvalue))
+        code_block.write_code("ns3::CompleteConstruct(%s);" % (lvalue, ))
 
-void PythonCompleteConstruct (Ptr<Object> object, TypeId typeId, const AttributeList &attributes);
-
-template <typename T>
-Ptr<T> CreateObjectPython (PyObject *pyobj, const AttributeList &attributes)
-{
-  Ptr<T> p = Ptr<T> (new T (), false);
-  p->set_pyobj (pyobj);
-  PythonCompleteConstruct (p, T::GetTypeId (), attributes);
-  return p;  
-}
-
-} // namespace ns3
-
-''')
-    
-    for cls in module.classes:
-        if not cls.is_subclass(Object):
-            continue
-        cls.constructors = [] # clear the list of constructors
-
-        ## add our own custom constructor, if possible
-        try:
-            construct_name = cls.get_construct_name()
-        except CodeGenerationError:
-            construct_name = None
-
-        if construct_name and not cls.helper_class:
-            construct_code = '''
-    ns3::Ptr< %(CONSTRUCT_NAME)s > obj = ns3::CreateObjectWithAttributes< %(CONSTRUCT_NAME)s > (attrList);
-    obj->Ref ();
-    self->obj = ns3::PeekPointer (obj);
-''' % dict (CONSTRUCT_NAME=construct_name)
-
-        elif not construct_name and not cls.helper_class:
-            continue
-
-        elif not construct_name and cls.helper_class:
-            construct_code = '''
-    if (self->ob_type != &%(PYTYPESTRUCT)s)
-    {
-        ns3::Ptr< %(HELPER_CLASS_NAME)s > obj = ns3::CreateObjectPython< %(HELPER_CLASS_NAME)s > ((PyObject *)self, attrList);
-        obj->Ref ();
-        self->obj = ns3::PeekPointer (obj);
-    } else {
-        PyErr_SetString(PyExc_TypeError, "Class cannot be constructed (unless subclassed)");
-        {
-            PyObject *exc_type, *traceback;
-            PyErr_Fetch(&exc_type, return_exception, &traceback);
-            Py_XDECREF(exc_type);
-            Py_XDECREF(traceback);
-        }
-        return -1;
-    }
-''' % dict (CONSTRUCT_NAME=construct_name, HELPER_CLASS_NAME=cls.helper_class.name,
-            PYTYPESTRUCT=cls.pytypestruct)
-
-        elif construct_name and cls.helper_class:
-            construct_code = '''
-    if (self->ob_type != &%(PYTYPESTRUCT)s)
-    {
-        ns3::Ptr< %(HELPER_CLASS_NAME)s > obj = ns3::CreateObjectPython< %(HELPER_CLASS_NAME)s > ((PyObject *)self, attrList);
-        obj->Ref ();
-        self->obj = ns3::PeekPointer (obj);
-    } else {
-        ns3::Ptr< %(CONSTRUCT_NAME)s > obj = ns3::CreateObjectWithAttributes< %(CONSTRUCT_NAME)s > (attrList);
-        obj->Ref ();
-        self->obj = ns3::PeekPointer (obj);
-    }
-''' % dict (CONSTRUCT_NAME=construct_name, HELPER_CLASS_NAME=cls.helper_class.name,
-            PYTYPESTRUCT=cls.pytypestruct)
-        else:
-            raise AssertionError
-
-        wrapper_name = "_wrap_create_object_%s" % (cls.mangled_full_name,) 
-        constructor = '''
-static int %(WRAPPER_NAME)s (%(PYSTRUCT)s *self, PyObject *args, PyObject *kwargs, PyObject **return_exception)
-{
-    if (PyTuple_Size(args)) {
-        PyErr_SetString(PyExc_TypeError, "positional arguments not supported "
-                        "for ns3.Object constructors, only keyword arguments"
-                        " should be used (AttributeName=Value)");
-        {
-            PyObject *exc_type, *traceback;
-            PyErr_Fetch(&exc_type, return_exception, &traceback);
-            Py_XDECREF(exc_type);
-            Py_XDECREF(traceback);
-        }
-        return -1;
-    }
-    ns3::AttributeList attrList;
-    if (kwargs && KwargsToAttributeList(kwargs, %(CLASS_NAME)s::GetTypeId(), attrList)) {
-        {
-            PyObject *exc_type, *traceback;
-            PyErr_Fetch(&exc_type, return_exception, &traceback);
-            Py_XDECREF(exc_type);
-            Py_XDECREF(traceback);
-        }
-        return -1;
-    }
-    %(CONSTRUCT_CODE)s
-    PyNs3ObjectBase_wrapper_registry[(void *) self->obj] = (PyObject *) self;
-    return 0;
-}
-''' % dict(WRAPPER_NAME=wrapper_name, PYSTRUCT=cls.pystruct, CLASS_NAME=cls.full_name,
-           CONSTRUCT_CODE=construct_code, PURE_VIRTUALS=cls.have_pure_virtual_methods)
-        cls.add_constructor(CustomCppConstructorWrapper(wrapper_name, constructor))
-
-
-    # Generate conversion function from PyObject* to AttributeValue
-#     sink = module.body
-#     sink.writeln('''
-# Ptr<AttributeValue> AttributeValueFromPyObject (PyObject *obj)
-# {
-#     // note: needs to check for bool first, because bool is a subclass of int
-#     if (PyBool_Check(obj)) {
-#         return Create<BooleanValue>(PyObject_IsTrue(obj));
-#     } else if (PyInt_Check(obj)) {
-#         return Create<IntegerValue>(PyInt_AsLong(obj));
-#     } else if (PyLong_Check(obj)) {
-#         return Create<IntegerValue>(PyLong_AsLongLong(obj));
-#     } else if (PyFloat_Check(obj)) {
-#         return Create<DoubleValue>(PyFloat_AsDouble(obj));
-#     }
-
-# ''')
-    
-
-
-    ## ---------------------------------------------------------------------
-    ## -------------- write the KwargsToAttributeList function -------------
-    ## ---------------------------------------------------------------------
-    Attribute = module['ns3::AttributeValue']
-    module.after_forward_declarations.writeln(
-        'int KwargsToAttributeList(PyObject *kwargs, ns3::TypeId tid, ns3::AttributeList &oAttrList);')
-
-    module.body.writeln(
-'''
-int KwargsToAttributeList(PyObject *kwargs, ns3::TypeId tid, ns3::AttributeList &oAttrList)
-{
-    PyObject *key, *value;
-    Py_ssize_t pos = 0;
-
-    while (PyDict_Next(kwargs, &pos, &key, &value)) {
-        if (!PyString_Check(key)) {
-            PyErr_SetString(PyExc_TypeError, "kwargs keys must be strings");
-            return -1;
-        }
-        if (PyObject_IsInstance(value, (PyObject*) &%s)) {
-            oAttrList.SetWithTid(tid, PyString_AsString(key), *((%s *) value)->obj);''' \
-    % (Attribute.pytypestruct, Attribute.pystruct))
-
-    for conversion_source in Attribute.get_all_implicit_conversions():
-        module.body.writeln('''
-        } else if (PyObject_IsInstance(value, (PyObject*) &%s)) {
-            oAttrList.SetWithTid(tid, PyString_AsString(key), *((%s *) value)->obj);''' \
-                        % (conversion_source.pytypestruct, conversion_source.pystruct))
-
-    possible_type_names = ", ".join([cls.name for cls in [Attribute] + Attribute.get_all_implicit_conversions()])
-    module.body.writeln('''
-        } else {
-            PyErr_Format(PyExc_TypeError, \"parameter must an instance of one of the types (%s), not %%s\", value->ob_type->tp_name);
-            return -1;
-        }''' % (possible_type_names))
-
-    module.body.writeln(
-'''
-    }
-    return 0;
-}
-''')
+    Object.set_instance_creation_function(ns3_object_instance_creation_function)
 
 
 def Attribute_customizations(module):
@@ -572,6 +413,16 @@ def add_std_ofstream(module):
                               Parameter.new("::std::ofstream::openmode", 'mode', default_value="std::ios_base::out")])
     ofstream.add_method('close', None, [])
 
+    import pybindgen.typehandlers.base
+    for alias in "std::_Ios_Openmode", "std::ios::openmode":
+        pybindgen.typehandlers.base.param_type_matcher.add_type_alias(alias, "int")
+
+    for flag in 'in', 'out', 'ate', 'app', 'trunc', 'binary':
+        module.after_init.write_code('PyModule_AddIntConstant(m, (char *) "STD_IOS_%s", std::ios::%s);'
+                                     % (flag.upper(), flag))
+
+
+
 def add_ipv4_address_tp_hash(module):
     module.body.writeln('''
 long

bindings/python/ns3modulescan.py

@@ -87,6 +87,17 @@ type_annotations = {
     'extern void ns3::PythonCompleteConstruct(ns3::Ptr<ns3::Object> object, ns3::TypeId typeId, ns3::AttributeList const & attributes) [free function]': {
         'ignore': None # used transparently by, should not be wrapped
         },
+
+    'ns3::Ptr<ns3::Ipv4RoutingProtocol> ns3::Ipv4ListRouting::GetRoutingProtocol(uint32_t index, int16_t & priority) const [member function]': {
+        'params': {'priority':{'direction':'out'}}
+        },
+    'ns3::Ipv4RoutingTableEntry * ns3::GlobalRouter::GetInjectedRoute(uint32_t i) [member function]': {
+        'params': {'return': { 'caller_owns_return': 'false',}},
+        },
+    'ns3::Ipv4RoutingTableEntry * ns3::Ipv4GlobalRouting::GetRoute(uint32_t i) [member function]': {
+        'params': {'return': { 'caller_owns_return': 'false',}},
+        },
+    
     }
 
 def get_ns3_relative_path(path):
@@ -150,8 +161,8 @@ def pre_scan_hook(dummy_module_parser,
     ## classes
     if isinstance(pygccxml_definition, class_t):
         # no need for helper classes to allow subclassing in Python, I think...
-        if pygccxml_definition.name.endswith('Helper'):
-            global_annotations['allow_subclassing'] = 'false'
+        #if pygccxml_definition.name.endswith('Helper'):
+        #    global_annotations['allow_subclassing'] = 'false'
 
         if pygccxml_definition.decl_string.startswith('::ns3::SimpleRefCount<'):
             global_annotations['incref_method'] = 'Ref'

bindings/python/pch/_placeholder_

@@ -0,0 +1 @@
+placeholder

bindings/python/wscript

@@ -15,10 +15,30 @@ import Build
 import Utils
 
 ## https://launchpad.net/pybindgen/
-REQUIRED_PYBINDGEN_VERSION = (0, 12, 0, 710)
+REQUIRED_PYBINDGEN_VERSION = (0, 14, 1)
 REQUIRED_PYGCCXML_VERSION = (0, 9, 5)
 
 
+
+from TaskGen import feature, after
+import Task, ccroot
+
+@feature('pch')
+@after('apply_link')
+def process_pch(self):
+    node = self.path.find_resource(self.pch)
+    assert node
+    tsk = self.create_task('gchx')
+    tsk.set_inputs(node)
+    tsk.set_outputs(node.parent.find_or_declare(node.name + '.gch'))
+
+comp_line = '${CXX} ${CXXFLAGS} ${CPPFLAGS} ${_CXXINCFLAGS} ${_CXXDEFFLAGS} ${SRC} -o ${TGT}'
+cls = Task.simple_task_type('gchx', comp_line, before='cc cxx')
+cls.scan = ccroot.scan
+
+
+
+
 def add_to_python_path(path):
     if os.environ.get('PYTHONPATH', ''):
         os.environ['PYTHONPATH'] = path + os.pathsep + os.environ.get('PYTHONPATH')
@@ -44,9 +64,14 @@ def set_options(opt):
                    help=('Path to an existing pybindgen source tree to use.'),
                    default=None,
                    dest='with_pybindgen', type="string")
+    opt.add_option('--enable-python-pch',
+                   help=("Enable precompiled headers when compiling python bindings, to speed up compilation."),
+                   action="store_true", default=False,
+                   dest='enable_python_pch')
 
 
 def configure(conf):
+    conf.env['ENABLE_PYTHON_PCH'] = Options.options.enable_python_pch
     conf.env['ENABLE_PYTHON_BINDINGS'] = False
     if Options.options.python_disable:
         conf.report_optional_feature("python", "Python Bindings", False,
@@ -246,7 +271,7 @@ def calc_header_include(path):
 
 
 class gen_everything_h_task(Task.Task):
-    before = 'cc cxx'
+    before = 'cc cxx gchx'
     after = 'ns3header_task'
     color = 'BLUE'
 
@@ -346,7 +371,7 @@ class all_ns3_headers_taskgen(TaskGen.task_gen):
                         all_headers_inputs.append(node)
         assert all_headers_inputs
         all_headers_outputs = [self.path.find_or_declare("everything.h")]
-        task = self.create_task('gen_everything_h', self.env)
+        task = self.create_task('gen_everything_h', env=self.env)
         task.set_inputs(all_headers_inputs)
         task.set_outputs(all_headers_outputs)
 
@@ -384,7 +409,7 @@ class python_scan_task(Task.TaskBase):
     """Uses gccxml to scan the file 'everything.h' and extract API definitions.
     """
     after = 'gen_everything_h_task'
-    before = 'cc cxx'
+    before = 'cc cxx gchx'
     color = "BLUE"
     def __init__(self, curdirnode, env, bld, target, cflags):
         self.bld = bld
@@ -495,7 +520,7 @@ def build(bld):
             ]
         target = [
             'ns3module.cc',
-            'ns3module.h',
+            'pch/ns3module.h',
             ]
         if not debug:
             target.append('ns3modulegen.log')
@@ -526,15 +551,18 @@ def build(bld):
         bindgen = bld.new_task_gen('command', source=source, target=target, command=argv)
         bindgen.env['FEATURES'] = ','.join(features)
         bindgen.dep_vars = ['FEATURES']
-        bindgen.before = 'cxx'
+        bindgen.before = 'cxx gchx'
         bindgen.after = 'gen_everything_h_task'
         bindgen.name = "pybindgen-command"
-
-        pymod = bld.new_task_gen('cxx', 'shlib', 'pyext')
-        if sys.platform == 'cygwin':
-            pymod.features.append('implib') # workaround for WAF bug #472
+ 
+        features = 'cxx cshlib pyext'
+        if env['ENABLE_PYTHON_PCH']:
+            features += ' pch'
+        pymod = bld.new_task_gen(features=features)
         pymod.source = ['ns3module.cc', 'ns3module_helpers.cc']
-        pymod.includes = '.'
+        pymod.includes = '. pch'
+        if env['ENABLE_PYTHON_PCH']:
+            pymod.pch = 'pch/ns3module.h'
         for module in scanned_modules:
             pymod.source.append("ns3_module_%s.cc" % module)
         pymod.target = 'ns3/_ns3'

doc/manual/Makefile

@@ -58,6 +58,7 @@ CHAPTERS = \
 	python.texi \
 	random.texi \
 	realtime.texi \
+  distributed.texi \
 	routing.texi \
 	simple.texi \
 	sockets.texi \

doc/manual/attributes.texi

@@ -514,6 +514,24 @@ the attribute system:
 
 @subsubsection Initialization order
 
+Attributes in the system must not depend on the state of any other Attribute
+in this system.  This is because an ordering of Attribute initialization is
+not specified, nor enforced, by the system.  A specific example of this 
+can be seen in automated configuration programs such as @code{ns3::ConfigStore}.  
+Although a given model may arrange it so that Attributes are initialized in
+a particular order, another automatic configurator may decide independently 
+to change Attributes in, for example, alphabetic order.  
+
+Because of this non-specific ordering, no Attribute in the system may have
+any dependence on any other Attribute.  As a corollary, Attribute setters must
+never fail due to the state of another Attribute.  No Attribute setter may 
+change (set) any other Attribute value as a result of changing its value.
+
+This is a very strong restriction and there are cases where Attributes must
+set consistently to allow correct operation.  To this end we do allow for 
+consistency checking @emph{when the attribute is used} (cf. NS_ASSERT_MSG 
+or NS_ABORT_MSG).
+
 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

doc/manual/callbacks.texi

@@ -251,7 +251,7 @@ The caller defines a specific part of the functor that really is just there to
 implement the specific operator() method,
 
 @verbatim
-  template <typname T, typename ARG>
+  template <typename T, typename ARG>
   class SpecificFunctor : public Functor
    {
    public:
@@ -305,7 +305,7 @@ case, provides the integer argument:
   void 
   LibraryFunction (Functor functor)
   {
-    // Ececute the library function
+    // Execute the library function
     functor(1234);
   }
 @end verbatim
@@ -362,7 +362,7 @@ 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 function template @code{Callback} is esentially the
+a @code{this} pointer.  The function template @code{Callback} is essentially 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
@@ -551,7 +551,7 @@ bound arguments.  Conceptually, it extends the specific functor described above
 with one or more bound arguments
 
 @verbatim
-  template <typname T, typename ARG, typename BOUND_ARG>
+  template <typename T, typename ARG, typename BOUND_ARG>
   class SpecificFunctor : public Functor
    {
    public:
@@ -581,7 +581,7 @@ the single parameter, as in
   m_promiscSnifferTrace (m_currentPkt);
 @end verbatim
 
-the imlpementation of @code{operator()} adds the bound parameter into the actual
+the implementation of @code{operator()} adds the bound parameter into the actual
 function call:
 
 @verbatim

doc/manual/csma.texi

@@ -218,7 +218,7 @@ attempted.  The default maximum number of retries is 1000.
 @section Using the CsmaNetDevice
 
 The CSMA net devices and channels are typically created and configured using
-the associated @code{CsmaHelper} object.  The various ns3 device dhelpers 
+the associated @code{CsmaHelper} object.  The various ns3 device helpers 
 generally work in a similar way, and their use is seen in many of our example
 programs.
 

doc/manual/distributed.texi

@@ -0,0 +1,225 @@
+@node Distributed
+@chapter Distributed Simulation with MPI
+@anchor{chap:Distributed}
+
+@menu
+* Current Implementation Details::
+* Running Distributed Simulations::
+* Tracing During Distributed Simulations::
+@end menu
+
+Parallel and distributed discrete event simulation allows the execution of a 
+single simulation program on multiple processors. By splitting up the 
+simulation into logical processes, LPs, each LP can be executed by a different 
+processor. This simulation methodology enables very large-scale simulations by 
+leveraging increased processing power and memory availability. In order to 
+ensure proper execution of a distributed simulation, message passing between 
+LPs is required. To support distributed simulation in ns-3, the standard 
+Message Passing Interface (MPI) is used, along with a new distributed simulator 
+class. Currently, dividing a simulation for distributed purposes in ns-3 can 
+only occur across point-to-point links.
+
+@node Current Implementation Details
+@section Current Implementation Details
+During the course of a distributed simulation, many packets must cross 
+simulator boundaries. In other words, a packet that originated on one LP 
+is destined for a different LP, and in order to make this transition, a message 
+containing the packet contents must be sent to the remote LP.  Upon receiving 
+this message, the remote LP can rebuild the packet and proceed as normal. The 
+process of sending an receiving messages between LPs is handled easily by the 
+new MPI interface in ns-3.
+
+Along with simple message passing between LPs, a distributed simulator is used 
+on each LP to determine which events to process. It is important to process 
+events in time-stamped order to ensure proper simulation execution. If a 
+LP receives a message containing an event from the past, clearly this is an 
+issue, since this event could change other events which have already been 
+executed. To address this problem, a conservative synchronization algorithm with 
+lookahead is used in ns-3. For more information on different synchronization 
+approaches and parallel and distributed simulation in general, please refer to
+"Parallel and Distributed Simulation Systems" by Richard Fujimoto.
+
+@subsection Remote point-to-point links
+As described in the introduction, dividing a simulation for distributed purposes 
+in ns-3 currently can only occur across point-to-point links; therefore, the idea 
+of remote point-to-point links is very important for distributed simulation in ns-3.
+When a point-to-point link is installed, connecting two nodes, the point-to-point 
+helper checks the system id, or rank, of both nodes.  The rank should be assigned 
+during node creation for distributed simulation and is intended to signify on which 
+LP a node belongs.  If the two nodes are on the same rank, a regular point-to-point 
+link is created. If, however, the two nodes are on different ranks, then these nodes 
+are intended for different LPs, and a remote point-to-point link is used. If a packet 
+is to be sent across a remote point-to-point link, MPI is used to send the message to 
+the remote LP.
+
+@subsection Distributing the topology
+Currently, the full topology is created on each rank, regardless of the individual node 
+system ids.  Only the applications are specific to a rank.  For example, consider 
+node 1 on LP 1 and node 2 on LP 2, with a traffic generator on node 1. Both node 
+1 and node 2 will be created on both LP1 and LP2; however, the traffic generator 
+will only be installed on LP1.  While this is not optimal for memory efficiency, it 
+does simplify routing, since all current routing implementations in ns-3 will work 
+with distributed simulation.
+
+@node Running Distributed Simulations
+@section Running Distributed Simulations
+
+@subsection Prerequisites
+Ensure that MPI is installed, as well as mpic++. In Ubuntu repositories, 
+these are openmpi-bin, openmpi-common, openmpi-doc, libopenmpi-dev. In 
+Fedora, these are openmpi and openmpi-devel.
+
+Note: 
+There is a conflict on some Fedora systems between libotf and openmpi. A 
+possible "quick-fix" is to yum remove libotf before installing openmpi. 
+This will remove conflict, but it will also remove emacs. Alternatively, 
+these steps could be followed to resolve the conflict:
+
+@verbatim
+1) Rename the tiny otfdump which emacs says it needs:
+
+     mv /usr/bin/otfdump /usr/bin/otfdump.emacs-version
+
+2) Manually resolve openmpi dependencies:
+
+     sudo yum install libgfortran libtorque numactl
+
+3) Download rpm packages: 
+
+     openmpi-1.3.1-1.fc11.i586.rpm
+     openmpi-devel-1.3.1-1.fc11.i586.rpm
+     openmpi-libs-1.3.1-1.fc11.i586.rpm
+     openmpi-vt-1.3.1-1.fc11.i586.rpm
+
+     from
+
+     http://mirrors.kernel.org/fedora/releases/11/Everything/i386/os/Packages/
+
+4) Force the packages in:
+
+     sudo rpm -ivh --force openmpi-1.3.1-1.fc11.i586.rpm
+     openmpi-libs-1.3.1-1.fc11.i586.rpm openmpi-devel-1.3.1-1.fc11.i586.rpm
+     openmpi-vt-1.3.1-1.fc11.i586.rpm
+
+@end verbatim
+
+Also, it may be necessary to add the openmpi bin directory to PATH in order to 
+execute mpic++ and mpirun from the command line.  Alternatively, the full path 
+to these executables can be used.  Finally, if openmpi complains about the 
+inability to open shared libraries, such as libmpi_cxx.so.0, it may be 
+necessary to add the openmpi lib directory to LD_LIBRARY_PATH.
+
+@subsection Building and Running Examples
+If you already built ns-3 without MPI enabled, you must re-build:
+@verbatim
+./waf distclean
+@end verbatim
+
+Configure ns-3 with the --enable-mpi option:
+@verbatim
+./waf -d debug configure --enable-mpi
+@end verbatim
+
+Ensure that MPI is enabled by checking the optional features shown from the 
+output of configure.
+
+Next, build ns-3:
+@verbatim
+./waf
+@end verbatim
+
+After building ns-3 with mpi enabled, the example programs are now ready to 
+run with mpirun.  Here are a few examples (from the root ns-3 directory):
+
+@verbatim
+mpirun -np 2 ./waf --run simple-distributed
+mpirun -np 4 -machinefile mpihosts ./waf --run 'nms-udp-nix --LAN=2 --CN=4 --nix=1 --tracing=0'
+@end verbatim
+            
+The np switch is the number of logical processors to use. The 
+machinefile switch is which machines to use.  In order to use machinefile, 
+the target file must exist (in this case mpihosts). This can simply contain 
+something like:
+
+@verbatim
+localhost
+localhost
+localhost
+...
+@end verbatim
+
+Or if you have a cluster of machines, you can name them.
+
+** NOTE: Some users have experienced issues using mpirun and waf together. 
+An alternative way to run distributed examples is shown below:
+
+@verbatim
+./waf shell
+cd build/debug
+mpirun -np 2 examples/mpi/simple-distributed
+@end verbatim
+
+@subsection Creating custom topologies
+The example programs in examples/mpi give a good idea of how to create 
+different topologies for distributed simulation. The main points are 
+assigning system ids to individual nodes, creating point-to-point 
+links where the simulation should be divided, and installing
+applications only on the LP associated with the target node.
+
+Assigning system ids to nodes is simple and can be handled two different 
+ways. First, a NodeContainer can be used to create the nodes and assign 
+system ids:
+
+@verbatim 
+NodeContainer nodes;
+nodes.Create (5, 1); // Creates 5 nodes with system id 1.
+@end verbatim
+
+Alternatively, nodes can be created individually, assigned system ids, and 
+added to a NodeContainer. This is useful if a NodeContainer holds nodes with 
+different system ids:
+
+@verbatim
+NodeContainer nodes;
+Ptr<Node> node1 = CreateObject<Node> (0); // Create node1 with system id 0
+Ptr<Node> node2 = CreateObject<Node> (1); // Create node2 with system id 1
+nodes.Add (node1);
+nodes.Add (node2);
+@end verbatim
+
+Next, where the simulation is divided is determined by the placement of 
+point-to-point links.  If a point-to-point link is created between two 
+nodes with different system ids, a remote point-to-point link is created, 
+as described in @ref{Current Implementation Details}.
+
+Finally, installing applications only on the LP associated with the target 
+node is very important. For example, if a traffic generator is to be placed 
+on node 0, which is on LP0, only LP0 should install this application. 
+This is easily accomplished by first checking the simulator system id, and 
+ensuring that it matches the system id of the target node before installing 
+the application.
+
+@node Tracing During Distributed Simulations
+@section Tracing During Distributed Simulations
+Depending on the system id (rank) of the simulator, the information traced 
+will be different, since traffic originating on one simulator is not seen 
+by another simulator until it reaches nodes specific to that simulator.  The 
+easiest way to keep track of different traces is to just name the trace files 
+or pcaps differently, based on the system id of the simulator.  For example, 
+something like this should work well, assuming all of these local variables 
+were previously defined:
+
+@verbatim
+if (MpiInterface::GetSystemId () == 0)
+  {
+    pointToPoint.EnablePcapAll ("distributed-rank0");
+    phy.EnablePcap ("distributed-rank0", apDevices.Get (0));
+    csma.EnablePcap ("distributed-rank0", csmaDevices.Get (0), true);
+  }
+else if (MpiInterface::GetSystemId () == 1)
+  {
+    pointToPoint.EnablePcapAll ("distributed-rank1");
+    phy.EnablePcap ("distributed-rank1", apDevices.Get (0));
+    csma.EnablePcap ("distributed-rank1", csmaDevices.Get (0), true);
+  }
+@end verbatim

doc/manual/emulation.texi

@@ -39,7 +39,7 @@ the ns-3 tracing, logging, visualization and statistics gathering tools.
 In what can be viewed as essentially an inverse configuration, we allow ``real'' 
 machines running native applications and protocol stacks to integrate with
 an ns-3 simulation.  This allows for the simulation of large networks connected
-to a real mahince, and also enables virtualization.  A simulation of this kind
+to a real machine, and also enables virtualization.  A simulation of this kind
 is shown in the following figure:
 
 @float Figure,fig:emulated-channel

doc/manual/manual.texi

@@ -96,6 +96,7 @@ Simulator version:
 * Logging::
 * Tracing::
 * RealTime::
+* Distributed::
 * Packets::
 * Helpers::
 * Python::
@@ -140,6 +141,7 @@ Simulator version:
 @include log.texi
 @include tracing.texi
 @include realtime.texi
+@include distributed.texi
 @include packets.texi
 @include helpers.texi
 @include python.texi

doc/manual/objects.texi

@@ -10,6 +10,7 @@
 * Object-oriented behavior::
 * Object base classes::
 * Memory management and class Ptr::
+* Object factories::
 * Downcasting::
 @end menu
 
@@ -62,7 +63,7 @@ These base classes are:
 @itemize @bullet
 @item @code{class Object}
 @item @code{class ObjectBase}
-@item @code{class RefCountBase}
+@item @code{class SimpleRefCount}
 @end itemize
 It is not required that ns-3 objects inherit from these class, but 
 those that do get special properties.  Classes deriving from 
@@ -75,7 +76,7 @@ those that do get special properties.  Classes deriving from
 
 Classes that derive from @code{class ObjectBase} get the first two
 properties above, but do not get smart pointers.  Classes that
-derive from @code{class RefCountBase} get only the smart-pointer
+derive from @code{class SimpleRefCount} get only the smart-pointer
 reference counting system.
 
 In practice, @code{class Object} is the variant of the three above that
@@ -134,7 +135,7 @@ If you want to store a newed object into a smart pointer,
 we recommend you to use the CreateObject template functions
 to create the object and store it in a smart pointer to avoid
 memory leaks. These functions are really small convenience
-functions and their goal is just is save you a small
+functions and their goal is just to save you a small
 bit of typing.
 
 @subsection CreateObject and Create
@@ -152,11 +153,8 @@ For objects deriving from @code{class Object}:
 Please do not create such objects using @code{operator new}; create them
 using @code{CreateObject()} instead.
 
-For objects deriving from @code{class RefCountBase}, or other
-objects that support usage of the smart pointer class
-(in particular, the ns-3 Packet class does not derive from RefCountBase
-in order to avoid a vtable, but separately implements @code{Ref ()} and 
-@code{Unref ()}),
+For objects deriving from @code{class SimpleRefCount}, or other
+objects that support usage of the smart pointer class,
 a templated helper function is available and recommended to be used:
 @verbatim
   Ptr<B> b = Create<B> ();
@@ -164,6 +162,10 @@ a templated helper function is available and recommended to be used:
 This is simply a wrapper around operator new that correctly handles
 the reference counting system.
 
+In summary, use @code{Create<B>} if B is not an object but just uses
+reference counting (e.g. @code{class Packet}), and use @code{CreateObject<B>}
+if B derives from @code{ns3::Object}.
+
 @subsection Aggregation
 
 The ns-3 object aggregation system is motivated in strong part by 
@@ -255,6 +257,43 @@ not know anything about energy models.
 We hope that this mode of programming will require much less 
 need for developers to modify the base classes.
 
+@node Object factories
+@section Object factories
+
+A common use case is to create lots of similarly configured objects.
+One can repeatedly call @code{CreateObject} but there is also a 
+factory design pattern in use in the ns-3 system.  It is heavily
+used in the "helper" API. 
+
+Class @code{ObjectFactory} can be used to instantiate objects and
+to configure the attributes on those objects 
+
+@verbatim
+  void SetTypeId (TypeId tid);
+  void Set (std::string name, const AttributeValue &value);
+  Ptr<T> Create (void) const;
+@end verbatim
+
+The first method allows one to use the ns-3 TypeId system to specify
+the type of objects created.  The second allows one to set 
+attributes on the objects to be created, and the third allows one
+to create the objects themselves. 
+
+For example:
+@verbatim
+  ObjectFactory factory;
+  // Make this factory create objects of type FriisPropagationLossModel
+  factory.SetTypeId ("ns3::FriisPropagationLossModel")
+  // Make this factory object change a default value of an attribute, for
+  // subsequently created objects
+  factory.Set ("SystemLoss", DoubleValue (2.0));
+  // Create one such object
+  Ptr<Object> object = m_factory.Create (); 
+  factory.Set ("SystemLoss", DoubleValue (3.0));
+  // Create another object
+  Ptr<Object> object = m_factory.Create (); 
+@end verbatim
+
 @node Downcasting
 @section Downcasting
 

doc/manual/other.texi

@@ -901,7 +901,7 @@ after this initialization.  They are:
     Ipv4AddressGenerator::SeedAddress (mask, baseAddress);
 @end verbatim
 
-We provide an IP address generator class to allow us to programatically 
+We provide an IP address generator class to allow us to programmatically
 allocate IP addresses.  The first call to @code{SeedNetwork} gives the
 address generator a starting network number to use when generating addresses.
 The second call to @code{SeedAddress} gives the address generator a starting
@@ -1011,7 +1011,7 @@ relatively abstract bus class, we can create bus networks with 4, 40 or 4000
 nodes with no additional effort.
 
 A use of the bus network class is shown in the file 
-@code{bus-netowrk.cc} located in the @code{tutorial} directory.  The
+@code{bus-network.cc} located in the @code{tutorial} directory.  The
 interesting code is,
 
 @verbatim

doc/manual/tracing.texi

@@ -16,6 +16,7 @@ this is the tracing subsystem.
 * Tracing Motivation::
 * Overview::
 * Using the Tracing API::
+* Using Trace Helpers::
 * Tracing implementation details::
 @end menu
 
@@ -339,5 +340,855 @@ core of the simulator;
 sinks. 
 @end itemize
 
+@node Using Trace Helpers
+@section Using Trace Helpers
+
+The @code{ns-3} trace helpers provide a rich environment for configuring and
+selecting different trace events and writing them to files.  In previous
+sections, primarily ``Building Topologies,'' we have seen several varieties
+of the trace helper methods designed for use inside other (device) helpers.
+
+Perhaps you will recall seeing some of these variations: 
+
+@verbatim
+  pointToPoint.EnablePcapAll ("second");
+  pointToPoint.EnablePcap ("second", p2pNodes.Get (0)->GetId (), 0);
+  csma.EnablePcap ("third", csmaDevices.Get (0), true);
+  pointToPoint.EnableAsciiAll (ascii.CreateFileStream ("myfirst.tr"));
+@end verbatim
+
+What may not be obvious, though, is that there is a consistent model for all of 
+the trace-related methods found in the system.  We will now take a little time
+and take a look at the ``big picture''.
+
+There are currently two primary use cases of the tracing helpers in @code{ns-3}:
+Device helpers and protocol helpers.  Device helpers look at the problem
+of specifying which traces should be enabled through a node, device pair.  For 
+example, you may want to specify that pcap tracing should be enabled on a 
+particular device on a specific node.  This follows from the @code{ns-3} device
+conceptual model, and also the conceptual models of the various device helpers.
+Following naturally from this, the files created follow a 
+<prefix>-<node>-<device> naming convention.  
+
+Protocol helpers look at the problem of specifying which traces should be
+enabled through a protocol and interface pair.  This follows from the @code{ns-3}
+protocol stack conceptual model, and also the conceptual models of internet
+stack helpers.  Naturally, the trace files should follow a 
+<prefix>-<protocol>-<interface> naming convention.
+
+The trace helpers therefore fall naturally into a two-dimensional taxonomy.
+There are subtleties that prevent all four classes from behaving identically,
+but we do strive to make them all work as similarly as possible; and whenever
+possible there are analogs for all methods in all classes.
+
+@verbatim
+                   | pcap | ascii |
+  -----------------+------+-------|
+  Device Helper    |      |       |
+  -----------------+------+-------|
+  Protocol Helper  |      |       |
+  -----------------+------+-------|
+@end verbatim
+
+We use an approach called a @code{mixin} to add tracing functionality to our 
+helper classes.  A @code{mixin} is a class that provides functionality to that
+is inherited by a subclass.  Inheriting from a mixin is not considered a form 
+of specialization but is really a way to collect functionality. 
+
+Let's take a quick look at all four of these cases and their respective 
+@code{mixins}.
+
+@subsection Pcap Tracing Device Helpers
+
+The goal of these helpers is to make it easy to add a consistent pcap trace
+facility to an @code{ns-3} device.  We want all of the various flavors of
+pcap tracing to work the same across all devices, so the methods of these 
+helpers are inherited by device helpers.  Take a look at 
+@code{src/helper/trace-helper.h} if you want to follow the discussion while 
+looking at real code.
+
+The class @code{PcapHelperForDevice} is a @code{mixin} provides the high level 
+functionality for using pcap tracing in an @code{ns-3} device.  Every device 
+must implement a single virtual method inherited from this class.
+
+@verbatim
+  virtual void EnablePcapInternal (std::string prefix, Ptr<NetDevice> nd, bool promiscuous) = 0;
+@end verbatim
+
+The signature of this method reflects the device-centric view of the situation
+at this level.  All of the public methods inherited from class 
+2@code{PcapUserHelperForDevice} reduce to calling this single device-dependent
+implementation method.  For example, the lowest level pcap method,
+
+@verbatim
+  void EnablePcap (std::string prefix, Ptr<NetDevice> nd, bool promiscuous = false, bool explicitFilename = false);
+@end verbatim
+
+will call the device implementation of @code{EnablePcapInternal} directly.  All
+other public pcap tracing methods build on this implementation to provide 
+additional user-level functionality.  What this means to the user is that all 
+device helpers in the system will have all of the pcap trace methods available;
+and these methods will all work in the same way across devices if the device 
+implements @code{EnablePcapInternal} correctly.
+
+@subsubsection Pcap Tracing Device Helper Methods
+
+@verbatim
+  void EnablePcap (std::string prefix, Ptr<NetDevice> nd, bool promiscuous = false, bool explicitFilename = false);
+  void EnablePcap (std::string prefix, std::string ndName, bool promiscuous = false, bool explicitFilename = false);
+  void EnablePcap (std::string prefix, NetDeviceContainer d, bool promiscuous = false);
+  void EnablePcap (std::string prefix, NodeContainer n, bool promiscuous = false);
+  void EnablePcap (std::string prefix, uint32_t nodeid, uint32_t deviceid, bool promiscuous = false);
+  void EnablePcapAll (std::string prefix, bool promiscuous = false);
+@end verbatim
+
+In each of the methods shown above, there is a default parameter called 
+@code{promiscuous} that defaults to false.  This parameter indicates that the
+trace should not be gathered in promiscuous mode.  If you do want your traces
+to include all traffic seen by the device (and if the device supports a 
+promiscuous mode) simply add a true parameter to any of the calls above.  For example,
+
+@verbatim
+  Ptr<NetDevice> nd;
+  ...
+  helper.EnablePcap ("prefix", nd, true);
+@end verbatim
+
+will enable promiscuous mode captures on the @code{NetDevice} specified by @code{nd}.
+
+The first two methods also include a default parameter called @code{explicitFilename}
+that will be discussed below.
+
+You are encouraged to peruse the Doxygen for class @code{PcapHelperForDevice}
+to find the details of these methods; but to summarize ...
+
+You can enable pcap tracing on a particular node/net-device pair by providing a
+@code{Ptr<NetDevice>} to an @code{EnablePcap} method.  The @code{Ptr<Node>} is 
+implicit since the net device must belong to exactly one @code{Node}.
+For example, 
+
+@verbatim
+  Ptr<NetDevice> nd;
+  ...
+  helper.EnablePcap ("prefix", nd);
+@end verbatim
+
+You can enable pcap tracing on a particular node/net-device pair by providing a
+@code{std::string} representing an object name service string to an 
+@code{EnablePcap} method.  The @code{Ptr<NetDevice>} is looked up from the name
+string.  Again, the @code<Node> is implicit since the named net device must 
+belong to exactly one @code{Node}.  For example, 
+
+@verbatim
+  Names::Add ("server" ...);
+  Names::Add ("server/eth0" ...);
+  ...
+  helper.EnablePcap ("prefix", "server/ath0");
+@end verbatim
+
+You can enable pcap tracing on a collection of node/net-device pairs by 
+providing a @code{NetDeviceContainer}.  For each @code{NetDevice} in the container
+the type is checked.  For each device of the proper type (the same type as is 
+managed by the device helper), tracing is enabled.    Again, the @code<Node> is 
+implicit since the found net device must belong to exactly one @code{Node}.
+For example, 
+
+@verbatim
+  NetDeviceContainer d = ...;
+  ...
+  helper.EnablePcap ("prefix", d);
+@end verbatim
+
+You can enable pcap tracing on a collection of node/net-device pairs by 
+providing a @code{NodeContainer}.  For each @code{Node} in the @code{NodeContainer}
+its attached @code{NetDevices} are iterated.  For each @code{NetDevice} attached
+to each node in the container, the type of that device is checked.  For each 
+device of the proper type (the same type as is managed by the device helper), 
+tracing is enabled.
+
+@verbatim
+  NodeContainer n;
+  ...
+  helper.EnablePcap ("prefix", n);
+@end verbatim
+
+You can enable pcap tracing on the basis of node ID and device ID as well as
+with explicit @code{Ptr}.  Each @code{Node} in the system has an integer node ID
+and each device connected to a node has an integer device ID.
+
+@verbatim
+  helper.EnablePcap ("prefix", 21, 1);
+@end verbatim
+
+Finally, you can enable pcap tracing for all devices in the system, with the
+same type as that managed by the device helper.
+
+@verbatim
+  helper.EnablePcapAll ("prefix");
+@end verbatim
+
+@subsubsection Pcap Tracing Device Helper Filename Selection
+
+Implicit in the method descriptions above is the construction of a complete 
+filename by the implementation method.  By convention, pcap traces in the 
+@code{ns-3} system are of the form ``<prefix>-<node id>-<device id>.pcap''
+
+As previously mentioned, every node in the system will have a system-assigned
+node id; and every device will have an interface index (also called a device id)
+relative to its node.  By default, then, a pcap trace file created as a result
+of enabling tracing on the first device of node 21 using the prefix ``prefix''
+would be ``prefix-21-1.pcap''.
+
+You can always use the @code{ns-3} object name service to make this more clear.
+For example, if you use the object name service to assign the name ``server''
+to node 21, the resulting pcap trace file name will automatically become,
+``prefix-server-1.pcap'' and if you also assign the name ``eth0'' to the 
+device, your pcap file name will automatically pick this up and be called
+``prefix-server-eth0.pcap''.
+
+Finally, two of the methods shown above,
+
+@verbatim
+  void EnablePcap (std::string prefix, Ptr<NetDevice> nd, bool promiscuous = false, bool explicitFilename = false);
+  void EnablePcap (std::string prefix, std::string ndName, bool promiscuous = false, bool explicitFilename = false);
+@end verbatim
+
+have a default parameter called @code{explicitFilename}.  When set to true,
+this parameter disables the automatic filename completion mechanism and allows
+you to create an explicit filename.  This option is only available in the 
+methods which enable pcap tracing on a single device.  
+
+For example, in order to arrange for a device helper to create a single 
+promiscuous pcap capture file of a specific name (``my-pcap-file.pcap'') on a
+given device, one could:
+
+@verbatim
+  Ptr<NetDevice> nd;
+  ...
+  helper.EnablePcap ("my-pcap-file.pcap", nd, true, true);
+@end verbatim
+
+The first @code{true} parameter enables promiscuous mode traces and the second
+tells the helper to interpret the @code{prefix} parameter as a complete filename.
+
+@subsection Ascii Tracing Device Helpers
+
+The behavior of the ascii trace helper @code{mixin} is substantially similar to 
+the pcap version.  Take a look at @code{src/helper/trace-helper.h} if you want to 
+follow the discussion while looking at real code.
+
+The class @code{AsciiTraceHelperForDevice} adds the high level functionality for 
+using ascii tracing to a device helper class.  As in the pcap case, every device
+must implement a single virtual method inherited from the ascii trace @code{mixin}.
+
+@verbatim
+  virtual void EnableAsciiInternal (Ptr<OutputStreamWrapper> stream, std::string prefix, Ptr<NetDevice> nd) = 0;
+@end verbatim
+
+The signature of this method reflects the device-centric view of the situation
+at this level; and also the fact that the helper may be writing to a shared
+output stream.  All of the public ascii-trace-related methods inherited from 
+class @code{AsciiTraceHelperForDevice} reduce to calling this single device-
+dependent implementation method.  For example, the lowest level ascii trace
+methods,
+
+@verbatim
+  void EnableAscii (std::string prefix, Ptr<NetDevice> nd);
+  void EnableAscii (Ptr<OutputStreamWrapper> stream, Ptr<NetDevice> nd);
+@verbatim
+
+will call the device implementation of @code{EnableAsciiInternal} directly,
+providing either a valid prefix or stream.  All other public ascii tracing 
+methods will build on these low-level functions to provide additional user-level
+functionality.  What this means to the user is that all device helpers in the 
+system will have all of the ascii trace methods available; and these methods
+will all work in the same way across devices if the devices implement 
+@code{EnablAsciiInternal} correctly.
+
+@subsubsection Ascii Tracing Device Helper Methods
+
+@verbatim
+  void EnableAscii (std::string prefix, Ptr<NetDevice> nd);
+  void EnableAscii (Ptr<OutputStreamWrapper> stream, Ptr<NetDevice> nd);
+
+  void EnableAscii (std::string prefix, std::string ndName);
+  void EnableAscii (Ptr<OutputStreamWrapper> stream, std::string ndName);
+
+  void EnableAscii (std::string prefix, NetDeviceContainer d);
+  void EnableAscii (Ptr<OutputStreamWrapper> stream, NetDeviceContainer d);
+
+  void EnableAscii (std::string prefix, NodeContainer n);
+  void EnableAscii (Ptr<OutputStreamWrapper> stream, NodeContainer n);
+
+  void EnableAscii (std::string prefix, uint32_t nodeid, uint32_t deviceid);
+  void EnableAscii (Ptr<OutputStreamWrapper> stream, uint32_t nodeid, uint32_t deviceid);
+
+  void EnableAsciiAll (std::string prefix);
+  void EnableAsciiAll (Ptr<OutputStreamWrapper> stream);
+@end verbatim
+
+You are encouraged to peruse the Doxygen for class @code{TraceHelperForDevice}
+to find the details of these methods; but to summarize ...
+
+There are twice as many methods available for ascii tracing as there were for
+pcap tracing.  This is because, in addition to the pcap-style model where traces
+from each unique node/device pair are written to a unique file, we support a model
+in which trace information for many node/device pairs is written to a common file.
+This means that the <prefix>-<node>-<device> file name generation mechanism is 
+replaced by a mechanism to refer to a common file; and the number of API methods
+is doubled to allow all combinations.
+
+Just as in pcap tracing, you can enable ascii tracing on a particular 
+node/net-device pair by providing a @code{Ptr<NetDevice>} to an @code{EnableAscii}
+method.  The @code{Ptr<Node>} is implicit since the net device must belong to 
+exactly one @code{Node}.  For example, 
+
+@verbatim
+  Ptr<NetDevice> nd;
+  ...
+  helper.EnableAscii ("prefix", nd);
+@end verbatim
+
+In this case, no trace contexts are written to the ascii trace file since they
+would be redundant.  The system will pick the file name to be created using
+the same rules as described in the pcap section, except that the file will
+have the suffix ``.tr'' instead of ``.pcap''.
+
+If you want to enable ascii tracing on more than one net device and have all 
+traces sent to a single file, you can do that as well by using an object to
+refer to a single file:
+
+@verbatim
+  Ptr<NetDevice> nd1;
+  Ptr<NetDevice> nd2;
+  ...
+  Ptr<OutputStreamWrapper> stream = asciiTraceHelper.CreateFileStream ("trace-file-name.tr");
+  ...
+  helper.EnableAscii (stream, nd1);
+  helper.EnableAscii (stream, nd2);
+@verbatim
+
+In this case, trace contexts are written to the ascii trace file since they
+are required to disambiguate traces from the two devices.  Note that since the
+user is completely specifying the file name, the string should include the ``,tr''
+for consistency.
+
+You can enable ascii tracing on a particular node/net-device pair by providing a
+@code{std::string} representing an object name service string to an 
+@code{EnablePcap} method.  The @code{Ptr<NetDevice>} is looked up from the name
+string.  Again, the @code<Node> is implicit since the named net device must 
+belong to exactly one @code{Node}.  For example, 
+
+@verbatim
+  Names::Add ("client" ...);
+  Names::Add ("client/eth0" ...);
+  Names::Add ("server" ...);
+  Names::Add ("server/eth0" ...);
+  ...
+  helper.EnableAscii ("prefix", "client/eth0");
+  helper.EnableAscii ("prefix", "server/eth0");
+@end verbatim
+
+This would result in two files named ``prefix-client-eth0.tr'' and 
+``prefix-server-eth0.tr'' with traces for each device in the respective trace
+file.  Since all of the EnableAscii functions are overloaded to take a stream wrapper,
+you can use that form as well:
+
+@verbatim
+  Names::Add ("client" ...);
+  Names::Add ("client/eth0" ...);
+  Names::Add ("server" ...);
+  Names::Add ("server/eth0" ...);
+  ...
+  Ptr<OutputStreamWrapper> stream = asciiTraceHelper.CreateFileStream ("trace-file-name.tr");
+  ...
+  helper.EnableAscii (stream, "client/eth0");
+  helper.EnableAscii (stream, "server/eth0");
+@end verbatim
+
+This would result in a single trace file called ``trace-file-name.tr'' that 
+contains all of the trace events for both devices.  The events would be 
+disambiguated by trace context strings.
+
+You can enable ascii tracing on a collection of node/net-device pairs by 
+providing a @code{NetDeviceContainer}.  For each @code{NetDevice} in the container
+the type is checked.  For each device of the proper type (the same type as is 
+managed by the device helper), tracing is enabled.    Again, the @code<Node> is 
+implicit since the found net device must belong to exactly one @code{Node}.
+For example, 
+
+@verbatim
+  NetDeviceContainer d = ...;
+  ...
+  helper.EnableAscii ("prefix", d);
+@end verbatim
+
+This would result in a number of ascii trace files being created, each of which
+follows the <prefix>-<node id>-<device id>.tr convention.  Combining all of the
+traces into a single file is accomplished similarly to the examples above:
+
+@verbatim
+  NetDeviceContainer d = ...;
+  ...
+  Ptr<OutputStreamWrapper> stream = asciiTraceHelper.CreateFileStream ("trace-file-name.tr");
+  ...
+  helper.EnableAscii (stream, d);
+@end verbatim
+
+You can enable ascii tracing on a collection of node/net-device pairs by 
+providing a @code{NodeContainer}.  For each @code{Node} in the @code{NodeContainer}
+its attached @code{NetDevices} are iterated.  For each @code{NetDevice} attached
+to each node in the container, the type of that device is checked.  For each 
+device of the proper type (the same type as is managed by the device helper), 
+tracing is enabled.
+
+@verbatim
+  NodeContainer n;
+  ...
+  helper.EnableAscii ("prefix", n);
+@end verbatim
+
+This would result in a number of ascii trace files being created, each of which
+follows the <prefix>-<node id>-<device id>.tr convention.  Combining all of the
+traces into a single file is accomplished similarly to the examples above:
+
+You can enable pcap tracing on the basis of node ID and device ID as well as
+with explicit @code{Ptr}.  Each @code{Node} in the system has an integer node ID
+and each device connected to a node has an integer device ID.
+
+@verbatim
+  helper.EnableAscii ("prefix", 21, 1);
+@end verbatim
+
+Of course, the traces can be combined into a single file as shown above.
+
+Finally, you can enable pcap tracing for all devices in the system, with the
+same type as that managed by the device helper.
+
+@verbatim
+  helper.EnableAsciiAll ("prefix");
+@end verbatim
+
+This would result in a number of ascii trace files being created, one for
+every device in the system of the type managed by the helper.  All of these
+files will follow the <prefix>-<node id>-<device id>.tr convention.  Combining
+all of the traces into a single file is accomplished similarly to the examples
+above.
+
+@subsubsection Ascii Tracing Device Helper Filename Selection
+
+Implicit in the prefix-style method descriptions above is the construction of the
+complete filenames by the implementation method.  By convention, ascii traces
+in the @code{ns-3} system are of the form ``<prefix>-<node id>-<device id>.tr''
+
+As previously mentioned, every node in the system will have a system-assigned
+node id; and every device will have an interface index (also called a device id)
+relative to its node.  By default, then, an ascii trace file created as a result
+of enabling tracing on the first device of node 21, using the prefix ``prefix'',
+would be ``prefix-21-1.tr''.
+
+You can always use the @code{ns-3} object name service to make this more clear.
+For example, if you use the object name service to assign the name ``server''
+to node 21, the resulting ascii trace file name will automatically become,
+``prefix-server-1.tr'' and if you also assign the name ``eth0'' to the 
+device, your ascii trace file name will automatically pick this up and be called
+``prefix-server-eth0.tr''.
+
+@subsection Pcap Tracing Protocol Helpers
+
+The goal of these @code{mixins} is to make it easy to add a consistent pcap trace
+facility to protocols.  We want all of the various flavors of pcap tracing to 
+work the same across all protocols, so the methods of these helpers are 
+inherited by stack helpers.  Take a look at @code{src/helper/trace-helper.h} 
+if you want to follow the discussion while looking at real code.
+
+In this section we will be illustrating the methods as applied to the protocol
+@code{Ipv4}.  To specify traces in similar protocols, just substitute the
+appropriate type.  For example, use a @code{Ptr<Ipv6>} instead of a
+@code{Ptr<Ipv4>} and call @code{EnablePcapIpv6} instead of @code{EnablePcapIpv4}.
+
+The class @code{PcapHelperForIpv4} provides the high level functionality for
+using pcap tracing in the @code{Ipv4} protocol.  Each protocol helper enabling these
+methods must implement a single virtual method inherited from this class.  There
+will be a separate implementation for @code{Ipv6}, for example, but the only
+difference will be in the method names and signatures.  Different method names
+are required to disambiguate class @code{Ipv4} from @code{Ipv6} which are both 
+derived from class @code{Object}, and methods that share the same signature.
+
+@verbatim
+  virtual void EnablePcapIpv4Internal (std::string prefix, Ptr<Ipv4> ipv4, uint32_t interface) = 0;
+@end verbatim
+
+The signature of this method reflects the protocol and interface-centric view 
+of the situation at this level.  All of the public methods inherited from class 
+@code{PcapHelperForIpv4} reduce to calling this single device-dependent
+implementation method.  For example, the lowest level pcap method,
+
+@verbatim
+  void EnablePcapIpv4 (std::string prefix, Ptr<Ipv4> ipv4, uint32_t interface);
+@verbatim
+
+will call the device implementation of @code{EnablePcapIpv4Internal} directly.
+All other public pcap tracing methods build on this implementation to provide 
+additional user-level functionality.  What this means to the user is that all 
+protocol helpers in the system will have all of the pcap trace methods 
+available; and these methods will all work in the same way across 
+protocols if the helper implements @code{EnablePcapIpv4Internal} correctly.
+
+@subsubsection Pcap Tracing Protocol Helper Methods
+
+These methods are designed to be in one-to-one correspondence with the @code{Node}-
+and @code{NetDevice}- centric versions of the device versions.  Instead of
+@code{Node} and @code{NetDevice} pair constraints, we use protocol and interface
+constraints.
+
+Note that just like in the device version, there are six methods:
+
+@verbatim
+  void EnablePcapIpv4 (std::string prefix, Ptr<Ipv4> ipv4, uint32_t interface);
+  void EnablePcapIpv4 (std::string prefix, std::string ipv4Name, uint32_t interface);
+  void EnablePcapIpv4 (std::string prefix, Ipv4InterfaceContainer c);
+  void EnablePcapIpv4 (std::string prefix, NodeContainer n);
+  void EnablePcapIpv4 (std::string prefix, uint32_t nodeid, uint32_t interface);
+  void EnablePcapIpv4All (std::string prefix);
+@end verbatim
+
+You are encouraged to peruse the Doxygen for class @code{PcapHelperForIpv4}
+to find the details of these methods; but to summarize ...
+
+You can enable pcap tracing on a particular protocol/interface pair by providing a
+@code{Ptr<Ipv4>} and @code{interface} to an @code{EnablePcap} method.  For example, 
+
+@verbatim
+  Ptr<Ipv4> ipv4 = node->GetObject<Ipv4> ();
+  ...
+  helper.EnablePcapIpv4 ("prefix", ipv4, 0);
+@end verbatim
+
+You can enable pcap tracing on a particular node/net-device pair by providing a
+@code{std::string} representing an object name service string to an 
+@code{EnablePcap} method.  The @code{Ptr<Ipv4>} is looked up from the name
+string.  For example, 
+
+@verbatim
+  Names::Add ("serverIPv4" ...);
+  ...
+  helper.EnablePcapIpv4 ("prefix", "serverIpv4", 1);
+@end verbatim
+
+You can enable pcap tracing on a collection of protocol/interface pairs by 
+providing an @code{Ipv4InterfaceContainer}.  For each @code{Ipv4} / interface
+pair in the container the protocol type is checked.  For each protocol of the 
+proper type (the same type as is managed by the device helper), tracing is 
+enabled for the corresponding interface.  For example, 
+
+@verbatim
+  NodeContainer nodes;
+  ...
+  NetDeviceContainer devices = deviceHelper.Install (nodes);
+  ... 
+  Ipv4AddressHelper ipv4;
+  ipv4.SetBase ("10.1.1.0", "255.255.255.0");
+  Ipv4InterfaceContainer interfaces = ipv4.Assign (devices);
+  ...
+  helper.EnablePcapIpv4 ("prefix", interfaces);
+@end verbatim
+
+You can enable pcap tracing on a collection of protocol/interface pairs by 
+providing a @code{NodeContainer}.  For each @code{Node} in the @code{NodeContainer}
+the appropriate protocol is found.  For each protocol, its interfaces are 
+enumerated and tracing is enabled on the resulting pairs.  For example,
+
+@verbatim
+  NodeContainer n;
+  ...
+  helper.EnablePcapIpv4 ("prefix", n);
+@end verbatim
+
+You can enable pcap tracing on the basis of node ID and interface as well.  In
+this case, the node-id is translated to a @code{Ptr<Node>} and the appropriate
+protocol is looked up in the node.  The resulting protocol and interface are
+used to specify the resulting trace source.
+
+@verbatim
+  helper.EnablePcapIpv4 ("prefix", 21, 1);
+@end verbatim
+
+Finally, you can enable pcap tracing for all interfaces in the system, with
+associated protocol being the same type as that managed by the device helper.
+
+@verbatim
+  helper.EnablePcapIpv4All ("prefix");
+@end verbatim
+
+@subsubsection Pcap Tracing Protocol Helper Filename Selection
+
+Implicit in all of the method descriptions above is the construction of the
+complete filenames by the implementation method.  By convention, pcap traces
+taken for devices in the @code{ns-3} system are of the form 
+``<prefix>-<node id>-<device id>.pcap''.  In the case of protocol traces,
+there is a one-to-one correspondence between protocols and @code{Nodes}.
+This is because protocol @code{Objects} are aggregated to @code{Node Objects}.
+Since there is no global protocol id in the system, we use the corresponding
+node id in file naming.  Therefore there is a possibility for file name 
+collisions in automatically chosen trace file names.  For this reason, the
+file name convention is changed for protocol traces.
+
+As previously mentioned, every node in the system will have a system-assigned
+node id.  Since there is a one-to-one correspondence between protocol instances
+and node instances we use the node id.  Each interface has an interface id 
+relative to its protocol.  We use the convention 
+"<prefix>-n<node id>-i<interface id>.pcap" for trace file naming in protocol
+helpers.
+
+Therefore, by default, a pcap trace file created as a result of enabling tracing
+on interface 1 of the Ipv4 protocol of node 21 using the prefix ``prefix''
+would be ``prefix-n21-i1.pcap''.
+
+You can always use the @code{ns-3} object name service to make this more clear.
+For example, if you use the object name service to assign the name ``serverIpv4''
+to the Ptr<Ipv4> on node 21, the resulting pcap trace file name will 
+automatically become, ``prefix-nserverIpv4-i1.pcap''.
+
+@subsection Ascii Tracing Protocol Helpers
+
+The behavior of the ascii trace helpers is substantially similar to the pcap
+case.  Take a look at @code{src/helper/trace-helper.h} if you want to 
+follow the discussion while looking at real code.
+
+In this section we will be illustrating the methods as applied to the protocol
+@code{Ipv4}.  To specify traces in similar protocols, just substitute the
+appropriate type.  For example, use a @code{Ptr<Ipv6>} instead of a
+@code{Ptr<Ipv4>} and call @code{EnableAsciiIpv6} instead of @code{EnableAsciiIpv4}.
+
+The class @code{AsciiTraceHelperForIpv4} adds the high level functionality
+for using ascii tracing to a protocol helper.  Each protocol that enables these
+methods must implement a single virtual method inherited from this class.
+
+@verbatim
+  virtual void EnableAsciiIpv4Internal (Ptr<OutputStreamWrapper> stream, std::string prefix, 
+                                        Ptr<Ipv4> ipv4, uint32_t interface) = 0;
+@end verbatim
+
+The signature of this method reflects the protocol- and interface-centric view 
+of the situation at this level; and also the fact that the helper may be writing
+to a shared output stream.  All of the public methods inherited from class 
+@code{PcapAndAsciiTraceHelperForIpv4} reduce to calling this single device-
+dependent implementation method.  For example, the lowest level ascii trace
+methods,
+
+@verbatim
+  void EnableAsciiIpv4 (std::string prefix, Ptr<Ipv4> ipv4, uint32_t interface);
+  void EnableAsciiIpv4 (Ptr<OutputStreamWrapper> stream, Ptr<Ipv4> ipv4, uint32_t interface);
+@verbatim
+
+will call the device implementation of @code{EnableAsciiIpv4Internal} directly,
+providing either the prefix or the stream.  All other public ascii tracing 
+methods will build on these low-level functions to provide additional user-level
+functionality.  What this means to the user is that all device helpers in the 
+system will have all of the ascii trace methods available; and these methods
+will all work in the same way across protocols if the protocols implement 
+@code{EnablAsciiIpv4Internal} correctly.
+
+@subsubsection Ascii Tracing Device Helper Methods
+
+@verbatim
+  void EnableAsciiIpv4 (std::string prefix, Ptr<Ipv4> ipv4, uint32_t interface);
+  void EnableAsciiIpv4 (Ptr<OutputStreamWrapper> stream, Ptr<Ipv4> ipv4, uint32_t interface);
+
+  void EnableAsciiIpv4 (std::string prefix, std::string ipv4Name, uint32_t interface);
+  void EnableAsciiIpv4 (Ptr<OutputStreamWrapper> stream, std::string ipv4Name, uint32_t interface);
+
+  void EnableAsciiIpv4 (std::string prefix, Ipv4InterfaceContainer c);
+  void EnableAsciiIpv4 (Ptr<OutputStreamWrapper> stream, Ipv4InterfaceContainer c);
+
+  void EnableAsciiIpv4 (std::string prefix, NodeContainer n);
+  void EnableAsciiIpv4 (Ptr<OutputStreamWrapper> stream, NodeContainer n);
+
+  void EnableAsciiIpv4 (std::string prefix, uint32_t nodeid, uint32_t deviceid);
+  void EnableAsciiIpv4 (Ptr<OutputStreamWrapper> stream, uint32_t nodeid, uint32_t interface);
+
+  void EnableAsciiIpv4All (std::string prefix);
+  void EnableAsciiIpv4All (Ptr<OutputStreamWrapper> stream);
+@end verbatim
+
+You are encouraged to peruse the Doxygen for class @code{PcapAndAsciiHelperForIpv4}
+to find the details of these methods; but to summarize ...
+
+There are twice as many methods available for ascii tracing as there were for
+pcap tracing.  This is because, in addition to the pcap-style model where traces
+from each unique protocol/interface pair are written to a unique file, we 
+support a model in which trace information for many protocol/interface pairs is 
+written to a common file.  This means that the <prefix>-n<node id>-<interface>
+file name generation mechanism is replaced by a mechanism to refer to a common 
+file; and the number of API methods is doubled to allow all combinations.
+
+Just as in pcap tracing, you can enable ascii tracing on a particular 
+protocol/interface pair by providing a @code{Ptr<Ipv4>} and an @code{interface}
+to an @code{EnableAscii} method.
+For example, 
+
+@verbatim
+  Ptr<Ipv4> ipv4;
+  ...
+  helper.EnableAsciiIpv4 ("prefix", ipv4, 1);
+@end verbatim
+
+In this case, no trace contexts are written to the ascii trace file since they
+would be redundant.  The system will pick the file name to be created using
+the same rules as described in the pcap section, except that the file will
+have the suffix ``.tr'' instead of ``.pcap''.
+
+If you want to enable ascii tracing on more than one interface and have all 
+traces sent to a single file, you can do that as well by using an object to
+refer to a single file.  We have already something similar to this in the
+``cwnd'' example above:
+
+@verbatim
+  Ptr<Ipv4> protocol1 = node1->GetObject<Ipv4> ();
+  Ptr<Ipv4> protocol2 = node2->GetObject<Ipv4> ();
+  ...
+  Ptr<OutputStreamWrapper> stream = asciiTraceHelper.CreateFileStream ("trace-file-name.tr");
+  ...
+  helper.EnableAsciiIpv4 (stream, protocol1, 1);
+  helper.EnableAsciiIpv4 (stream, protocol2, 1);
+@verbatim
+
+In this case, trace contexts are written to the ascii trace file since they
+are required to disambiguate traces from the two interfaces.  Note that since 
+the user is completely specifying the file name, the string should include the
+``,tr'' for consistency.
+
+You can enable ascii tracing on a particular protocol by providing a 
+@code{std::string} representing an object name service string to an 
+@code{EnablePcap} method.  The @code{Ptr<Ipv4>} is looked up from the name
+string.  The @code<Node> in the resulting filenames is implicit since there
+is a one-to-one correspondence between protocol instances and nodes,
+For example, 
+
+@verbatim
+  Names::Add ("node1Ipv4" ...);
+  Names::Add ("node2Ipv4" ...);
+  ...
+  helper.EnableAsciiIpv4 ("prefix", "node1Ipv4", 1);
+  helper.EnableAsciiIpv4 ("prefix", "node2Ipv4", 1);
+@end verbatim
+
+This would result in two files named ``prefix-nnode1Ipv4-i1.tr'' and 
+``prefix-nnode2Ipv4-i1.tr'' with traces for each interface in the respective 
+trace file.  Since all of the EnableAscii functions are overloaded to take a 
+stream wrapper, you can use that form as well:
+
+@verbatim
+  Names::Add ("node1Ipv4" ...);
+  Names::Add ("node2Ipv4" ...);
+  ...
+  Ptr<OutputStreamWrapper> stream = asciiTraceHelper.CreateFileStream ("trace-file-name.tr");
+  ...
+  helper.EnableAsciiIpv4 (stream, "node1Ipv4", 1);
+  helper.EnableAsciiIpv4 (stream, "node2Ipv4", 1);
+@end verbatim
+
+This would result in a single trace file called ``trace-file-name.tr'' that 
+contains all of the trace events for both interfaces.  The events would be 
+disambiguated by trace context strings.
+
+You can enable ascii tracing on a collection of protocol/interface pairs by 
+providing an @code{Ipv4InterfaceContainer}.  For each protocol of the proper 
+type (the same type as is managed by the device helper), tracing is enabled
+for the corresponding interface.  Again, the @code<Node> is implicit since 
+there is a one-to-one correspondence between each protocol and its node.
+For example, 
+
+@verbatim
+  NodeContainer nodes;
+  ...
+  NetDeviceContainer devices = deviceHelper.Install (nodes);
+  ... 
+  Ipv4AddressHelper ipv4;
+  ipv4.SetBase ("10.1.1.0", "255.255.255.0");
+  Ipv4InterfaceContainer interfaces = ipv4.Assign (devices);
+  ...
+  ...
+  helper.EnableAsciiIpv4 ("prefix", interfaces);
+@end verbatim
+
+This would result in a number of ascii trace files being created, each of which
+follows the <prefix>-n<node id>-i<interface>.tr convention.  Combining all of the
+traces into a single file is accomplished similarly to the examples above:
+
+@verbatim
+  NodeContainer nodes;
+  ...
+  NetDeviceContainer devices = deviceHelper.Install (nodes);
+  ... 
+  Ipv4AddressHelper ipv4;
+  ipv4.SetBase ("10.1.1.0", "255.255.255.0");
+  Ipv4InterfaceContainer interfaces = ipv4.Assign (devices);
+  ...
+  Ptr<OutputStreamWrapper> stream = asciiTraceHelper.CreateFileStream ("trace-file-name.tr");
+  ...
+  helper.EnableAsciiIpv4 (stream, interfaces);
+@end verbatim
+
+You can enable ascii tracing on a collection of protocol/interface pairs by 
+providing a @code{NodeContainer}.  For each @code{Node} in the @code{NodeContainer}
+the appropriate protocol is found.  For each protocol, its interfaces are 
+enumerated and tracing is enabled on the resulting pairs.  For example,
+
+@verbatim
+  NodeContainer n;
+  ...
+  helper.EnableAsciiIpv4 ("prefix", n);
+@end verbatim
+
+This would result in a number of ascii trace files being created, each of which
+follows the <prefix>-<node id>-<device id>.tr convention.  Combining all of the
+traces into a single file is accomplished similarly to the examples above:
+
+You can enable pcap tracing on the basis of node ID and device ID as well.  In
+this case, the node-id is translated to a @code{Ptr<Node>} and the appropriate
+protocol is looked up in the node.  The resulting protocol and interface are
+used to specify the resulting trace source.
+
+@verbatim
+  helper.EnableAsciiIpv4 ("prefix", 21, 1);
+@end verbatim
+
+Of course, the traces can be combined into a single file as shown above.
+
+Finally, you can enable ascii tracing for all interfaces in the system, with
+associated protocol being the same type as that managed by the device helper.
+
+@verbatim
+  helper.EnableAsciiIpv4All ("prefix");
+@end verbatim
+
+This would result in a number of ascii trace files being created, one for
+every interface in the system related to a protocol of the type managed by the
+helper.  All of these files will follow the <prefix>-n<node id>-i<interface.tr
+convention.  Combining all of the traces into a single file is accomplished 
+similarly to the examples above.
+
+@subsubsection Ascii Tracing Device Helper Filename Selection
+
+Implicit in the prefix-style method descriptions above is the construction of the
+complete filenames by the implementation method.  By convention, ascii traces
+in the @code{ns-3} system are of the form ``<prefix>-<node id>-<device id>.tr''
+
+As previously mentioned, every node in the system will have a system-assigned
+node id.  Since there is a one-to-one correspondence between protocols and nodes
+we use to node-id to identify the protocol identity.  Every interface on a 
+given protocol will have an interface index (also called simply an interface) 
+relative to its protocol.  By default, then, an ascii trace file created as a result
+of enabling tracing on the first device of node 21, using the prefix ``prefix'',
+would be ``prefix-n21-i1.tr''.  Use the prefix to disambiguate multiple protocols
+per node.
+
+You can always use the @code{ns-3} object name service to make this more clear.
+For example, if you use the object name service to assign the name ``serverIpv4''
+to the protocol on node 21, and also specify interface one, the resulting ascii 
+trace file name will automatically become, ``prefix-nserverIpv4-1.tr''.
+
 @node Tracing implementation details
 @section Implementation details

doc/manual/wimax.texi

@@ -0,0 +1,534 @@
+@node WimaxNetDevice
+@chapter WimaxNetDevice
+@anchor{chap:wimax}
+
+This chapter describes the ns-3 WimaxNetDevice and related models.  By
+adding WimaxNetDevice objects to ns-3 nodes, one can create models of
+802.16-based networks.  Below, we list some more details about what
+the ns-3 WiMAX models cover but, in summary, the most important features
+of the ns-3 model are:
+@itemize @bullet
+@item a scalable and realistic physical layer and channel model 
+@item a packet classifier for the IP convergence sublayer
+@item efficient uplink and downlink schedulers
+@item support for Multicast and Broadcast Service (MBS), and
+@item packet tracing functionality
+@end itemize
+
+The source code for the WiMAX models lives in the directory
+@code{src/devices/wimax}.
+
+There have been two academic papers published on this model:
+@itemize @bullet
+@item M.A. Ismail, G. Piro, L.A. Grieco, and T. Turletti, "An Improved
+IEEE 802.16 WiMAX Module for the NS-3 Simulator", SIMUTools 2010 Conference, 
+March 2010.
+@item J. Farooq and T. Turletti, "An IEEE 802.16 WiMAX module for the NS-3
+Simulator," SIMUTools 2009 Conference, March 2009. 
+@end itemize
+
+@menu
+* Scope of the model::
+* Using the Wimax models::
+* Wimax Attributes::
+* Wimax Tracing::
+* Wimax MAC model::
+* WimaxChannel and WimaxPhy models::
+@end menu
+
+@node Scope of the model
+@section Scope of the model
+
+From a MAC perspective, there are two basic modes of operation, that
+of a Subscriber Station (SS) or a Base Station (BS).  These are implemented
+as two subclasses of the base class @code{ns3::NetDevice}, 
+@code{class SubscriberStationNetDevice} and @code{class BaseStationNetDevice}.
+As is typical in ns-3, there is also a physical layer class
+@code{class WimaxPhy} and a channel class @code{class WimaxChannel} which
+serves to hold the references to all of the attached Phy devices.  The main
+physical layer class is the @code{SimpleOfdmWimaxChannel} class.
+
+Another important aspect of WiMAX is the uplink and downlink scheduler, 
+and there are three primary scheduler types implemented:
+@itemize @bullet
+@item SIMPLE:  a simple priority based FCFS scheduler
+@item RTPS:  a real-time polling service (rtPS) scheduler
+@item MBQOS:  a migration-based uplink scheduler
+@end itemize
+
+The following additional aspects of the 802.16 specifications, as 
+well as physical layer and channel models, are modelled:
+@itemize @bullet
+@item leverages existing ns-3 wireless propagation loss and delay models,
+as well as ns-3 mobility models
+@item Point-to-Multipoint (PMP) mode and the WirelessMAN-OFDM PHY layer
+@item Initial Ranging
+@item Service Flow Initialization
+@item Management Connection
+@item Transport Initialization
+@item UGS, rtPS, nrtPS, and BE connections
+@end itemize
+
+The following aspects are not presently modelled but would be good topics
+for future extensions:
+@itemize @bullet
+@item OFDMA PHY layer
+@item Link adaptation
+@item Mesh topologies
+@item ARQ
+@item ertPS connection
+@item packet header suppression
+@end itemize
+
+@node Using the Wimax models
+@section Using the Wimax models
+
+The main way that users who write simulation scripts will typically
+interact with the Wimax models is through the helper API and through
+the publicly visible attributes of the model.
+
+The helper API is defined in @code{src/helper/wimax-helper.{cc,h}}.  
+
+The example @code{examples/wimax/wimax-simple.cc} contains some basic
+code that shows how to set up the model:
+
+@smallformat
+@example
+  switch (schedType)
+    {
+    case 0:
+      scheduler = WimaxHelper::SCHED_TYPE_SIMPLE;
+      break;
+    case 1:
+      scheduler = WimaxHelper::SCHED_TYPE_MBQOS;
+      break;
+    case 2:
+      scheduler = WimaxHelper::SCHED_TYPE_RTPS;
+      break;
+    default:
+      scheduler = WimaxHelper::SCHED_TYPE_SIMPLE;
+    }
+
+  NodeContainer ssNodes;
+  NodeContainer bsNodes;
+
+  ssNodes.Create (2);
+  bsNodes.Create (1);
+
+  WimaxHelper wimax;
+
+  NetDeviceContainer ssDevs, bsDevs;
+
+  ssDevs = wimax.Install (ssNodes,
+                          WimaxHelper::DEVICE_TYPE_SUBSCRIBER_STATION,
+                          WimaxHelper::SIMPLE_PHY_TYPE_OFDM,
+                          scheduler);
+  bsDevs = wimax.Install (bsNodes, WimaxHelper::DEVICE_TYPE_BASE_STATION, WimaxHelper::SIMPLE_PHY_TYPE_OFDM, scheduler);
+@end example
+@end smallformat
+
+This example shows that there are two subscriber stations and one base
+station created.  The helper method @code{Install} allows the user to
+specify the scheduler type, the physical layer type, and the device type.
+
+Different variants of @code{Install} are available; for instance, the
+example @code{examples/wimax/wimax-multicast.cc} shows how to specify a
+non-default channel or propagation model:
+
+@smallformat
+@example
+  channel = CreateObject<SimpleOfdmWimaxChannel> ();
+  channel->SetPropagationModel (SimpleOfdmWimaxChannel::COST231_PROPAGATION);
+  ssDevs = wimax.Install (ssNodes,
+                          WimaxHelper::DEVICE_TYPE_SUBSCRIBER_STATION,
+                          WimaxHelper::SIMPLE_PHY_TYPE_OFDM,
+                          channel,
+                          scheduler);
+  Ptr<WimaxNetDevice> dev = wimax.Install (bsNodes.Get (0),
+                                           WimaxHelper::DEVICE_TYPE_BASE_STATION,
+                                           WimaxHelper::SIMPLE_PHY_TYPE_OFDM,
+                                           channel,
+                                           scheduler);
+@end example
+@end smallformat
+
+Mobility is also supported in the same way as in Wifi models; see the
+@code{examples/wimax/wimax-multicast.cc}.
+
+Another important concept in WiMAX is that of a service flow.  This is a
+unidirectional flow of packets with a set of QoS parameters such as 
+traffic priority, rate, scheduling type, etc.  The base station is 
+responsible for issuing service flow identifiers and mapping them to
+WiMAX connections.  The following
+code from @code{examples/wimax/wimax-multicast.cc} shows how this
+is configured from a helper level:
+
+@smallformat
+@example
+ ServiceFlow MulticastServiceFlow = wimax.CreateServiceFlow (ServiceFlow::SF_DIRECTION_DOWN,
+                                                              ServiceFlow::SF_TYPE_UGS,
+                                                              MulticastClassifier);
+
+  bs->GetServiceFlowManager ()->AddMulticastServiceFlow (MulticastServiceFlow, WimaxPhy::MODULATION_TYPE_QPSK_12);
+@end example
+@end smallformat
+
+
+@node Wimax Attributes
+@section Wimax Attributes
+
+The WimaxNetDevice makes heavy use of the ns-3 @ref{Attributes} subsystem for
+configuration and default value management.  Presently, approximately
+60 values are stored in this system.
+
+For instance, class @code{ns-3::SimpleOfdmWimaxPhy} exports these attributes:
+@itemize @bullet
+@item NoiseFigure:  Loss (dB) in the Signal-to-Noise-Ratio due to non-idealities in the receiver.
+@item TxPower:  Transmission power (dB)
+@item G:  The ratio of CP time to useful time
+@item txGain:  Transmission gain (dB)
+@item RxGain:  Reception gain (dB)
+@item Nfft:  FFT size
+@item TraceFilePath:  Path to the directory containing SNR to block error rate files
+@end itemize
+
+For a full list of attributes in these models, consult the Doxygen page
+that lists all attributes for ns-3.
+
+@node Wimax Tracing
+@section Wimax Tracing
+
+ns-3 has a sophisticated tracing infrastructure that allows users to hook
+into existing trace sources, or to define and export new ones.  
+
+Many ns-3 users use the built-in Pcap or Ascii tracing, and the
+WimaxHelper has similar APIs:
+@smallformat
+@example
+AsciiTraceHelper ascii;
+WimaxHelper wimax;
+wimax.EnablePcap ("wimax-program", false);
+wimax.EnableAsciiAll (ascii.CreateFileStream ("wimax-program.tr");
+@end example
+@end smallformat
+
+Unlike other helpers, there is also a special 
+@code{EnableAsciiForConnection()} method that limits the ascii tracing
+to a specific device and connection.
+
+These helpers access the low level trace sources that exist in the
+WiMAX physical layer, net device, and queue models.  Like other
+ns-3 trace sources, users may hook their own functions to these
+trace sources if they want to do customized things based on the
+packet events.  See the Doxygen List of trace sources for a
+complete list of these sources.
+
+@node Wimax MAC model
+@section Wimax MAC model
+
+The 802.16 model provided in ns-3 attempts to provide an accurate MAC and
+PHY level implementation of the 802.16 specification with the
+Point-to-Multipoint (PMP) mode and the WirelessMAN-OFDM PHY layer.
+The model is mainly composed of three layers:
+@itemize @bullet
+@item The convergence sublayer (CS)
+@item The MAC CP Common Part Sublayer (MAC-CPS)
+@item Physical (PHY) layer
+@end itemize
+
+The following figure @ref{fig:WimaxArchitecture} shows the relationships
+of these models.
+@float Figure,fig:WimaxArchitecture
+@caption{ns-3 WiMAX architecture.}
+@image{../WimaxArchitecture,5in}
+@end float
+
+@subsection the Convergence Sublayer
+ 
+The Convergence sublayer (CS) provided with this module implements
+the Packet CS, designed to work with the packet-based protocols at higher
+layers. The CS is responsible of receiving packet from the higher layer and
+from peer stations, classifying packets to appropriate connections (or
+service flows) and processing packets. It keeps a mapping of transport
+connections to service flows. This enables the MAC CPS identifying the Quality
+of Service (QoS) parameters associated to a transport connection and ensuring
+the QoS requirements. The CS currently employs an IP classifier.
+ 
+@subsection IP Packet Classifier
+ 
+An IP packet classifier is used to map incoming packets to appropriate
+connections based on a set of criteria. The classifier maintains a list of
+mapping rules which associate an IP flow (src IP address and mask, dst IP address
+and mask, src port range, dst port range and protocol) to one of the service flows.
+By analyzing the IP and the TCP/UDP headers the classifier will append the incoming
+packet (from the upper layer) to the queue of the appropriate WiMAX connection.
+@code{class IpcsClassifier} and @code{class IpcsClassifierRecord} implement the classifier module for
+both SS and BS
+ 
+@subsection MAC Common Part Sublayer
+ 
+The MAC Common Part Sublayer (CPS) is the main sublayer of the IEEE 802.16
+MAC and performs the fundamental functions of the MAC. The module implements
+the Point-Multi-Point (PMP) mode. In PMP mode BS is responsible of managing
+communication among multiple SSs. The key functionalities of the MAC CPS
+include framing and addressing, generation of MAC management messages, SS
+initialization and registration, service flow management, bandwidth
+management and scheduling services.
+@code{Class WimaxNetDevice} represents the MAC layer of a WiMAX network device.
+This class extends the @code{class NetDevice} of the ns-3 API that provides
+abstraction of a network device. @code{class WimaxNetDevice} is further extended by
+@code{class BaseStationNetDevice} and @code{class SubscriberStationNetDevice}, defining MAC
+layers of BS and SS, respectively. Besides these main classes, the key
+functions of MAC are distributed to several other classes.
+
+@subsection Framing and Management Messages
+ 
+The module implements a frame as a fixed duration of time, i.e., frame
+boundaries are defined with respect to time. Each frame is further
+subdivided into downlink (DL) and uplink (UL) subframes. The module implements
+the Time Division Duplex (TDD) mode where DL and UL operate on same frequency
+but are separated in time. A number of DL and UL bursts are then allocated in DL and UL
+subframes, respectively. Since the standard allows sending and
+receiving bursts of packets in a given DL or UL burst, the unit of
+transmission at the MAC layer is a packet burst. The module
+implements a special PacketBurst data structure for this purpose. A packet
+burst is essentially a list of packets. The BS downlink and uplink schedulers, implemented 
+by @code{class BSScheduler} and @code{class UplinkScheduler}, are responsible of
+generating DL and UL subframes, respectively. In the case of DL, the
+subframe is simulated by transmitting consecutive bursts (instances
+PacketBurst). In case of UL, the subframe is divided, with respect to time,
+into a number of slots. The bursts transmitted by the SSs in these slots are
+then aligned to slot boundaries. The frame is divided into integer number of
+symbols and Physical Slots (PS) which helps in managing bandwidth more
+effectively. The number of symbols per frame depends on the  underlying
+implementation of the PHY layer. The size of a DL or UL burst is specified in
+units of symbols.
+ 
+@subsection Network Entry and Initialization
+ 
+The network entry and initialization phase is basically divided into
+two sub-phases, (1) scanning and synchronization and (2) initial
+ranging. The entire phase is performed by the LinkManager component of SS
+and BS.
+Once an SS wants to join the network, it first scans the downlink
+frequencies to search for a suitable channel. The search is complete as soon
+as it detects a PHY frame. The next step is to establish synchronization
+with the BS. Once SS receives a Downlink-MAP (DL-MAP) message the synchronization
+phase is complete and it remains synchronized as long as it keeps receiving
+DL-MAP and  Downlink Channel Descriptor (DCD) messages. After the synchronization
+is established, SS waits for a Uplink Channel Descriptor (UCD) message to
+acquire uplink channel parameters. Once acquired, the first sub-phase of
+the network entry and initialization is complete.
+Once synchronization is achieved, the SS waits for a UL-MAP message to
+locate a special grant, called initial ranging interval, in the UL subframe.
+This grant is allocated by the BS Uplink Scheduler at regular
+intervals. Currently this interval is set to 0.5 ms, however the user
+is enabled to modify its value from the simulation script.
+
+@subsection Connections and Addressing
+ 
+All communication at the MAC layer is carried in terms of connections. The
+standard defines a connection as a unidirectional mapping between the SS and
+BS's MAC entities for the transmission of traffic. The standard defines two
+types of connections: management connections for transmitting
+control messages and transport connections for data transmission. A
+connection is identified by a 16-bit Connection Identifier (CID).
+@code{Class WimaxConnection} and @code{class Cid} implement the connection
+and CID, respectively. Note that each connection maintains its own
+transmission queue where packets to transmit on that connection are
+queued. The ConnectionManager component of BS is responsible
+of creating and managing connections for all SSs.
+
+The two key management connections defined by the standard, namely
+the Basic and Primary management connections, are created and
+allocated to the SS during the ranging process. Basic connection
+plays an important role throughout the operation of SS also because
+all (unicast) DL and UL grants are directed towards SS's Basic CID.
+In addition to management connections, an SS may have one or more
+transport connections to send data packets.
+The Connection Manager component of SS manages the connections associated to
+SS. As defined by the standard, a management connection is bidirectional,
+i.e., a pair of downlink and uplink connections is represented by the same
+CID. This feature is implemented in a way that one connection
+(in DL direction) is created by the BS and upon receiving the CID the SS
+then creates an identical connection (in UL direction) with the same CID.
+
+@subsection Scheduling Services
+ 
+The module supports the four scheduling services defined by the 802.16-2004
+standard:
+@itemize @bullet
+@item Unsolicited Grant Service (UGS)
+@item Real-Time Polling Services (rtPS)
+@item Non Real-Time Polling Services (nrtPS)
+@item Best Effort (BE)
+@end itemize
+ 
+These scheduling services behave differently with respect to how they request
+bandwidth as well as how the it is granted. Each service flow is associated to
+exactly one scheduling service, and the QoS parameter set associated
+to a service flow actually defines the scheduling service it belongs
+to. When a service flow is created the UplinkScheduler calculates necessary
+parameters such as grant size and grant interval based on QoS parameters
+associated to it.
+ 
+@subsection WiMAX Uplink Scheduler Model
+ 
+Uplink Scheduler at the BS decides which of the SSs will be assigned
+uplink allocations based on the QoS parameters associated to a service
+flow (or scheduling service) and bandwidth requests from the SSs. Uplink
+scheduler together with Bandwidth Manager implements the complete
+scheduling service functionality. The standard defines up to four
+scheduling services (BE, UGS, rtPS, nrtPS) for applications with
+different types of QoS requirements. The service flows of these
+scheduling services behave differently with respect to how they request
+for bandwidth as well as how the bandwidth is granted. The module
+supports all four scheduling services. Each service flow is associated
+to exactly one transport connection and one scheduling service. The QoS
+parameters associated to a service flow actually define the scheduling
+service it belongs to. Standard QoS parameters for UGS, rtPS, nrtPS and
+BE services, as specified in Tables 111a to 111d of the 802.16e
+amendment, are supported. When a service flow is created the uplink
+scheduler calculates necessary parameters such as grant size and
+allocation interval based on QoS parameters associated to it.
+The current WiMAX module provides three different versions of schedulers.
+
+@itemize @bullet
+@item The first one is a simple priority-based First Come First Serve (FCFS).
+For the real-time services (UGS and rtPS) the BS then allocates grants/polls on
+regular basis based on the calculated interval. For the non real-time
+services (nrtPS and BE) only minimum reserved bandwidth is guaranteed if
+available after servicing real-time flows. Note that not all of these
+parameters are utilized by the uplink scheduler. Also note that
+currently only service flow with fixed-size packet size are supported,
+as currently set up in simulation scenario with OnOff application of
+fixed packet size. This scheduler is implemented by @code{class BSSchedulerSimple}
+and @code{class UplinkSchedulerSimple}.
+
+@item The second one is similar to first scheduler except by rtPS service flow.
+All rtPS Connections are able to transmit all packet in the queue according
+to the available bandwidth. The bandwidth saturation control has been
+implemented to redistribute the effective available bandwidth to all rtPS
+that have at least one packet to transmit. The remaining bandwidth is allocated
+to nrtPS and BE Connections. This scheduler is implemented by
+@code{class BSSchedulerRtps} and @code{class UplinkSchedulerRtps}
+
+@item The third one is a Migration-based Quality of Service uplink scheduler
+This uplink scheduler uses three queues, the low priority
+queue, the intermediate queue and the high priority queue.
+The scheduler serves the requests in strict priority order
+from the high priority queue to the low priority queue. The
+low priority queue stores the bandwidth requests of the BE
+service flow. The intermediate queue holds bandwidth requests
+sent by rtPS and by nrtPS connections. rtPS and nrtPS requests
+can migrate to the high priority queue to guarantee that
+their QoS requirements are met. Besides the requests migrated
+from the intermediate queue, the high priority queue stores
+periodic grants and unicast request opportunities that must be
+scheduled in the following frame. To guarantee the maximum delay
+requirement, the BS assigns a deadline to each rtPS bandwidth
+request in the intermediate queue. The minimum bandwidth
+requirement of both rtPS and nrtPS connections is guaranteed
+over a window of duration T. This scheduler is implemented by
+@code{class UplinkSchedulerMBQoS}.
+@end itemize
+
+@subsection  WiMAX Outbound Schedulers Model
+ 
+Besides the uplink scheduler these are the outbound schedulers at BS and
+SS side (BSScheduler and SSScheduler). The outbound schedulers decide
+which of the packets from the outbound queues will be transmitted in a
+given allocation. The outbound scheduler at the BS schedules the
+downlink traffic, i.e., packets to be transmitted to the SSs in the
+downlink subframe. Similarly the outbound scheduler at a SS schedules
+the packet to be transmitted in the uplink allocation assigned to that
+SS in the uplink subframe. All three schedulers have been implemented to
+work as FCFS scheduler, as they allocate grants starting from highest
+priority scheduling service to the lower priority one (UGS> rtPS>
+nrtPS> BE). The standard does not suggest any scheduling algorithm and
+instead leaves this decision up to the manufacturers. Of course more
+sophisticated algorithms can be added later if required.
+
+@node WimaxChannel and WimaxPhy models
+@section WimaxChannel and WimaxPhy models
+
+The module implements the Wireless MAN OFDM PHY specifications
+as the more relevant for implementation as it is the schema chosen by the
+WiMAX Forum. This specification is designed for non-light-of-sight (NLOS)
+including fixed and mobile broadband wireless access.
+The proposed model uses a 256 FFT processor, with 192 data subcarriers.
+It supports all the seven modulation and coding schemes specified by Wireless
+MAN-OFDM. It is composed of two parts: the channel model and the physical model.
+
+@section Channel model
+
+The channel model we propose is implemented by the @code{class SimpleOFDMWimaxChannel} which
+extends the @code{class wimaxchannel}. The channel entity has a private structure named m_phyList
+which handles all the physical devices connected to it. When a physical device sends a packet (FEC Block)
+to the channel, the channel handles the packet, and then for each physical device connected to it, it
+calculates the propagation delay, the path loss according to a given propagation model and eventually forwards the
+packet to the receiver device.
+The channel class uses the method @code{GetDistanceFrom()} to calculate the distance between two physical
+entities according to their 3D coordinates. The delay is computed as @code{delay = distance/C}, where C
+is the speed of the light. 
+
+@section Physical model
+
+The physical layer performs two main operations: (i) It receives a burst from a channel and forwards it to the
+MAC layer, (ii) it receives a burst from the MAC layer and transmits it on the channel. In order to reduce the
+simulation complexity of the WiMAX physical layer, we have chosen to model offline part of the physical layer.
+More specifically we have developed an OFDM simulator to generate trace files used by the reception process to
+evaluate if a FEC block can be correctly decoded or not.
+
+Transmission Process: A burst is a set of WiMAX MAC PDUs. At the sending process, a burst is converted into
+bit-streams and then splitted into smaller FEC blocks which are then sent to the channel with a power equal
+P_tx.
+
+Reception Process: The reception process includes the following operations:
+
+@itemize @bullet
+1- Receive a FEC block from the channel.
+2- Calculate the noise level.
+3- Estimate the signal to noise ratio (SNR) with the following formula.
+4- Determine if a FEC block can be correctly decoded.
+5- Concatenate received FEC blocks to reconstruct the original burst.
+6- Forward the burst to the upper layer.
+@end itemize
+ 
+The developed process to evaluate if a FEC block can be correctly received or not uses pre-generated traces.
+The trace files are generated by an external OFDM simulator (described later). A class named
+SNRToBlockErrorRateManager handles a repository containing seven trace files (one for each modulation and coding
+scheme). A repository is specific for a particular channel model.
+
+A trace file is made of 6 columns. The first column provides the SNR value (1), whereas the other columns give
+respectively the bit error rate BER (2), the block error rate BlcER(3), the standard deviation on BlcER, and
+the confidence interval (4 and 5).
+These trace files are loaded into memory by the SNRToBlockErrorRateManager entity at the beginning of the simulation.
+
+Currently, The first process uses the first and third columns to determine if a FEC block is correctly received. When
+the physical layer receives a packet with an SNR equal to SNR_rx, it asks the SNRToBlockErrorRateManager to return
+the corresponding block error rate BlcER. A random number RAND between 0 and 1 is  then generated. If RAND is
+greater than BlcER, then the block is correctly received, otherwise the block is considered erroneous and is ignored.
+
+The module provides defaults SNR to block error rate traces in default-traces.h. The traces have been generated by an
+External WiMAX OFDM simulator. The simulator is based on an external mathematics and signal processing library IT++
+and includes : a random block generator, a Reed Solomon (RS) coder, a convolutional coder, an interleaver, a 256
+FFT-based OFDM modulator, a multi-path channel simulator and an equalizer. The multipath channel is simulated using
+the TDL_channel class of the IT++ library.
+
+Users can configure the module to use their own traces generated by another OFDM simulator or ideally by performing
+experiments in real environment. for this purpose, a path to a repository containing trace files should be provided.
+If no repository is provided the traces form default-traces.h will be loaded. A valid repository should contain 7
+files, one for each modulation and coding scheme.
+
+The names of the files should respect the following format: modulation0.txt for modulation 0, modulation1.txt for
+modulation 1 and so on...
+The file format should be as follows
+@smallformat
+@example
+SNR_value1   BER  Blc_ER  STANDARD_DEVIATION  CONFIDENCE_INTERVAL1  CONFIDENCE_INTERVAL2
+SNR_value2   BER  Blc_ER  STANDARD_DEVIATION  CONFIDENCE_INTERVAL1  CONFIDENCE_INTERVAL2
+ ...          ...  ...     ...                 ...                   ...
+ ...          ...  ...     ...                 ...                   ...
+@end example
+@end smallformat

doc/modules

@@ -60,5 +60,9 @@
  * @defgroup constants Constants
  * @brief Constants you can change
  *
+ * @defgroup utils Utils
+ * @brief The utils directory is for various programs and scripts related 
+ * to code coverage, test suites, style checking, and benchmarking.
+ * 
  * @defgroup contrib Contrib
  */

doc/release_steps.txt

@@ -94,10 +94,21 @@ Steps in doing an ns-3 release
      -- edit ~/bin/update-doxygen-release file and change RELEASE variable 
         to the right version number 
      -- run ~/bin/update-doxygen-release
-15. Final checks
+15. build release documentation
+   - if this is final release (not RC)
+     -- archive old release documentation in /var/www/html/docs/release 
+        by creating release specific folder and moving current 
+        documenation into this folder
+     -- from ns-3.x/doc, enter manual/ testing/ and tutorial directories 
+        and build the documentation using make
+     -- copy this newly created documentation into 
+        /var/www/html/docs/release making sure to copy only the 
+        necessary files
+16. Final checks
+   - check manual, testing, and tutorial documentation links
    - download tarball from web, build and run regression tests for as many
      targets as you can
    - download release from mercurial, build and run regression tests for as
      many targets as you can
    - test and verify until you're confident the release is solid.
-16. announce to ns-developers, with summary of release notes
+17. announce to ns-developers, with summary of release notes

doc/testing/background.texi

@@ -33,7 +33,7 @@ misused.
 
 There are also a number of different philosophical approaches to software 
 testing.  For example, some organizations advocate writing test programs
-before actually imlementing the desired software, yielding ``test-driven 
+before actually implementing the desired software, yielding ``test-driven 
 development.''  Some organizations advocate testing from a customer perspective
 as soon as possible, following a parallel with the agile development process:
 ``test early and test often.''  This is sometimes called ``agile testing.''  It
@@ -92,7 +92,7 @@ not-so-slow PHY-level model of the 802.11a specification.''
 
 Once this is done, one can develop an abstract model of the target system.  This
 is typically an exercise in managing the tradeoffs between complexity, resource
-requiremens and accuracy.  The process of developing an abstract model has been
+requirements and accuracy.  The process of developing an abstract model has been
 called @emph{model qualification} in the literature.  In the case of a TCP 
 protocol, this process results in a design for a collection of objects, 
 interactions and behaviors that will fully implement RFC 793 in @command{ns-3}.
@@ -140,7 +140,7 @@ generating or simulating resource exhaustion of various kinds.  This genre of
 testing is called ``stress testing.''
 
 The system and its components may be exposed to so-called ``clean tests'' that
-demostrate a positive result -- that is that the system operates correctly in 
+demonstrate a positive result -- that is that the system operates correctly in 
 response to a large variation of expected configurations.  
 
 The system and its components may also be exposed to ``dirty tests'' which 
@@ -203,7 +203,7 @@ existing functionality.  There are many kinds of regressions that may occur
 in practice.
 
 A @emph{local regression} is one in which a change affects the changed component
-directy.  For example, if a component is modified to allocate and free memory
+directly.  For example, if a component is modified to allocate and free memory
 but stale pointers are used, the component itself fails.
 
 A @emph{remote regression} is one in which a change to one component breaks

doc/testing/testing-framework.texi

@@ -68,7 +68,7 @@ undergo build and test cycles every day to verify that all is well.
 
 @node Testpy
 @section Test.py
-The buildbots use a Python program, @command{test.py}, that is reponsible for 
+The buildbots use a Python program, @command{test.py}, that is responsible for 
 running all of the tests and collecting the resulting reports into a human-
 readable form.  This program is also available for use by users and developers
 as well.
@@ -107,7 +107,7 @@ This mode is indented to be used by users who are interested in determining if
 their distribution is working correctly, and by developers who are interested
 in determining if changes they have made have caused any regressions.
 
-There are a number of options available to control the behavir of @code{test.py}.
+There are a number of options available to control the behavior of @code{test.py}.
 if you run @code{test.py --help} you should see a command summary like:
 
 @verbatim
@@ -360,7 +360,7 @@ numbers of temporary files.  Usually, the content of these files is not interest
 however in some cases it can be useful (for debugging purposes) to view these files.
 @code{test.py} provides a @command{--retain} option which will cause these temporary
 files to be kept after the run is completed.  The files are saved in a directory 
-named @code{testpy} under a subdirectory named according to the current Coordinated
+named @code{testpy-output} under a subdirectory named according to the current Coordinated
 Universal Time (also known as Greenwich Mean Time).
 
 @verbatim
@@ -487,7 +487,9 @@ You should see something like the following:
   Waf: Entering directory `/home/craigdo/repos/ns-3-allinone-test/ns-3-dev/build'
   Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone-test/ns-3-dev/build'
   'build' finished successfully (0.353s)
+  --assert:               Tell tests to segfault (like assert) if an error is detected
   --basedir=dir:          Set the base directory (where to find src) to ``dir''
+  --tempdir=dir:          Set the temporary directory (where to find data files) to ``dir''
   --constrain=test-type:  Constrain checks to test suites of type ``test-type''
   --help:                 Print this message
   --kinds:                List all of the available kinds of tests
@@ -506,24 +508,83 @@ the examples are really not @command{ns-3} tests.  @command{test.py} runs them
 as if they were to present a unified testing environment, but they are really
 completely different and not to be found here.
 
-One new option that appears here is the @code{--basedir} option.  It turns out
-that the tests may need to reference the source directory of the @code{ns-3} 
+The first new option that appears here, but not in test.py is the @code{--assert}
+option.  This option is useful when debugging a test case when running under a 
+debugger like @code{gdb}.  When selected, this option tells the underlying
+test case to cause a segmentation violation if an error is detected.  This has
+the nice side-effect of causing program execution to stop (break into the 
+debugger) when an error is detected.  If you are using gdb, you could use this
+option something like,
+
+@smallformat
+@verbatim
+  ./waf shell
+  cd build/debug/utils
+  gdb test-runner
+  run --suite=global-value --assert
+@end verbatim
+@end smallformat
+
+If an error is then found in the global-value test suite, a segfault would be 
+generated and the (source level) debugger would stop at the @code{NS_TEST_ASSERT_MSG}
+that detected the error.
+
+Another new option that appears here is the @code{--basedir} option.  It turns out
+that some tests may need to reference the source directory of the @code{ns-3} 
 distribution to find local data, so a base directory is always required to run
-a test.  To run one of the tests directly from the test-runner, you will need
-to specify the test suite to run along with the base directory.  So you could do,
+a test.
+
+If you run a test from test.py, the Python program will provide the basedir option
+for you.  To run one of the tests directly from the test-runner using @code{waf},
+ you will need to specify the test suite to run along with the base directory.  So 
+you could use the shell and do,
 
 @verbatim
   ./waf --run "test-runner --basedir=`pwd` --suite=pcap-file-object"
 @end verbatim
 
-Note the ``backward'' quotation marks on the @code{pwd} command.  This will run
-the @code{pcap-file-object} test quietly.  The only indication that
-you will get that the test passed is the @emph{absence} of a message from 
-@code{waf} saying that the program returned something other than a zero 
-exit code.  To get some output from the test, you need to specify an output
-file to which the tests will write their XML status using the @code{--out}
-option.  You need to be careful interpreting the results because the test 
-suites will @emph{append} results onto this file.  Try,
+Note the ``backward'' quotation marks on the @code{pwd} command.  
+
+If you are running the test suite out of a debugger, it can be quite painful to
+remember and constantly type the absolute path of the distribution base directory.
+Because of this, if you omit the basedir, the test-runner will try to figure one
+out for you.  It begins in the current working directory and walks up the 
+directory tree looking for a directory file with files named ``VERSION'' and
+``LICENSE.''  If it finds one, it assumes that must be the basedir and provides
+it for you.
+
+Similarly, many test suites need to write temporary files (such as pcap files)
+in the process of running the tests.  The tests then need a temporary directory
+to write to.  The Python test utility (test.py) will provide a temporary file
+automatically, but if run stand-alone this temporary directory must be provided.
+Just as in the basedir case, it can be annoying to continually have to provide
+a @code{--tempdir}, so the test runner will figure one out for you if you don't
+provide one.  It first looks for environment variables named @code{TMP} and 
+@code{TEMP} and uses those.  If neither @code{TMP} nor @code{TEMP} are defined
+it picks @code{/tmp}.  The code then tacks on an identifier indicating what 
+created the directory (ns-3) then the time (hh.mm.ss) followed by a large random
+number.  The test runner creates a directory of that name to be used as the
+temporary directory.  Temporary files then go into a directory that will be
+named something like,
+
+@smallformat
+@verbatim
+  /tmp/ns-3.10.25.37.61537845
+@end verbatim
+@end smallformat
+
+The time is provided as a hint so that you can relatively easily reconstruct
+what directory was used if you need to go back and look at the files that were
+placed in that directory.
+
+When you run a test suite using the test-runner it will run the test quietly
+by default.  The only indication that you will get that the test passed is 
+the @emph{absence} of a message from @code{waf} saying that the program 
+returned something other than a zero exit code.  To get some output from the
+test, you need to specify an output file to which the tests will write their 
+XML status using the @code{--out} option.  You need to be careful interpreting
+ the results because the test suites will @emph{append} results onto this file.
+Try,
 
 @smallformat
 @verbatim

doc/tutorial/building-topologies.texi

@@ -316,8 +316,8 @@ line enables pcap tracing in the CSMA helper and there is an extra parameter
 you haven't encountered yet.
 
 @verbatim
-  PointToPointHelper::EnablePcapAll ("second");
-  CsmaHelper::EnablePcap ("second", csmaDevices.Get (1), true);
+  pointToPoint.EnablePcapAll ("second");
+  csma.EnablePcap ("second", csmaDevices.Get (1), true);
 @end verbatim
 
 The CSMA network is a multi-point-to-point network.  This means that there 
@@ -582,9 +582,9 @@ number and device number as parameters.  Go ahead and replace the
 @code{EnablePcap} calls with the calls below.
 
 @verbatim
-  PointToPointHelper::EnablePcap ("second", p2pNodes.Get (0)->GetId (), 0);
-  CsmaHelper::EnablePcap ("second", csmaNodes.Get (nCsma)->GetId (), 0, false);
-  CsmaHelper::EnablePcap ("second", csmaNodes.Get (nCsma-1)->GetId (), 0, false);
+  pointToPoint.EnablePcap ("second", p2pNodes.Get (0)->GetId (), 0);
+  csma.EnablePcap ("second", csmaNodes.Get (nCsma)->GetId (), 0, false);
+  csma.EnablePcap ("second", csmaNodes.Get (nCsma-1)->GetId (), 0, false);
 @end verbatim
 
 We know that we want to create a pcap file with the base name "second" and
@@ -693,6 +693,99 @@ You can now see that node 101 is really the participant in the echo exchange.
   2.003822 IP 10.1.2.101.9 > 10.1.1.1.49153: UDP, length 1024
 @end verbatim
 
+@c ========================================================================
+@c Models, Attributes and Reality
+@c ========================================================================
+@node Models, Attributes and Reality
+@section Models, Attributes and Reality
+
+This is a convenient place to make a small excursion and make an important
+point.  It may or may not be obvious to you, but whenever one is using a 
+simulation, it is important to understand exactly what is being modeled and
+what is not.  It is tempting, for example, to think of the CSMA devices 
+and channels used in the previous section as if they were real Ethernet 
+devices; and to expect a simulation result to directly reflect what will 
+happen in a real Ethernet.  This is not the case.  
+
+A model is, by definition, an abstraction of reality.  It is ultimately the 
+responsibility of the simulation script author to determine the so-called
+``range of accuracy'' and ``domain of applicability'' of the simulation as
+a whole, and therefore its constituent parts.
+
+In some cases, like @code{Csma}, it can be fairly easy to determine what is 
+@emph{not} modeled.  By reading the model description (@code{csma.h}) you 
+can find that there is no collision detection in the CSMA model and decide
+on how applicable its use will be in your simulation or what caveats you 
+may want to include with your results.  In other cases, it can be quite easy
+to configure behaviors that might not agree with any reality you can go out
+and buy.  It will prove worthwhile to spend some time investigating a few
+such instances, and how easily you can swerve outside the bounds of reality
+in your simulations.
+
+As you have seen, @command{ns-3} provides @code{Attributes} which a user
+can easily set to change model behavior.  Consider two of the @code{Attributes}
+of the @code{CsmaNetDevice}:  @code{Mtu} and @code{EncapsulationMode}.  
+The @code{Mtu} attribute indicates the Maximum Transmission Unit to the 
+device.  This is the size of the largest Protocol Data Unit (PDU) that the
+device can send.  
+
+The MTU defaults to 1500 bytes in the @code{CsmaNetDevice}.  This default
+corresponds to a number found in RFC 894, ``A Standard for the Transmission
+of IP Datagrams over Ethernet Networks.''  The number is actually derived 
+from the maximum packet size for 10Base5 (full-spec Ethernet) networks -- 
+1518 bytes.  If you subtract the DIX encapsulation overhead for Ethernet 
+packets (18 bytes) you will end up with a maximum possible data size (MTU) 
+of 1500 bytes.  One can also find that the @code{MTU} for IEEE 802.3 networks
+is 1492 bytes.  This is because LLC/SNAP encapsulation adds an extra eight 
+bytes of overhead to the packet.  In both cases, the underlying hardware can
+only send 1518 bytes, but the data size is different.
+
+In order to set the encapsulation mode, the @code{CsmaNetDevice} provides
+an @code{Attribute} called @code{EncapsulationMode} which can take on the 
+values @code{Dix} or @code{Llc}.  These correspond to Ethernet and LLC/SNAP
+framing respectively.
+
+If one leaves the @code{Mtu} at 1500 bytes and changes the encapsulation mode
+to @code{Llc}, the result will be a network that encapsulates 1500 byte PDUs
+with LLC/SNAP framing resulting in packets of 1526 bytes, which would be 
+illegal in many networks, since they can transmit a maximum of 1518 bytes per
+packet.  This would most likely result in a simulation that quite subtly does
+not reflect the reality you might be expecting.
+
+Just to complicate the picture, there exist jumbo frames (1500 < MTU <= 9000 bytes)
+and super-jumbo (MTU > 9000 bytes) frames that are not officially sanctioned
+by IEEE but are available in some high-speed (Gigabit) networks and NICs.  One
+could leave the encapsulation mode set to @code{Dix}, and set the @code{Mtu}
+@code{Attribute} on a @code{CsmaNetDevice} to 64000 bytes -- even though an 
+associated @code{CsmaChannel DataRate} was set at 10 megabits per second.  
+This would essentially model an Ethernet switch made out of vampire-tapped
+1980s-style 10Base5 networks that support super-jumbo datagrams.  This is
+certainly not something that was ever made, nor is likely to ever be made,
+but it is quite easy for you to configure.
+
+In the previous example, you used the command line to create a simulation that
+had 100 @code{Csma} nodes.  You could have just as easily created a simulation
+with 500 nodes.  If you were actually modeling that 10Base5 vampire-tap network,
+the maximum length of a full-spec Ethernet cable is 500 meters, with a minimum 
+tap spacing of 2.5 meters.  That means there could only be 200 taps on a 
+real network.  You could have quite easily built an illegal network in that
+way as well.  This may or may not result in a meaningful simulation depending
+on what you are trying to model.
+
+Similar situations can occur in many places in @command{ns-3} and in any
+simulator.  For example, you may be able to position nodes in such a way that
+they occupy the same space at the same time, or you may be able to configure
+amplifiers or noise levels that violate the basic laws of physics.
+
+@command{ns-3} generally favors flexibility, and many models will allow freely
+setting @code{Attributes} without trying to enforce any arbitrary consistency
+or particular underlying spec.
+
+The thing to take home from this is that @command{ns-3} is going to provide a
+super-flexible base for you to experiment with.  It is up to you to understand
+what you are asking the system to do and to  make sure that the simulations you
+create have some meaning and some connection with a reality defined by you.
+
 @c ========================================================================
 @c Building a Wireless Network Topology
 @c ========================================================================
@@ -1082,9 +1175,9 @@ loop.
 We create just enough tracing to cover all three networks:
 
 @verbatim
-  PointToPointHelper::EnablePcapAll ("third");
+  pointToPoint.EnablePcapAll ("third");
   phy.EnablePcap ("third", apDevices.Get (0));
-  CsmaHelper::EnablePcap ("third", csmaDevices.Get (0), true);
+  csma.EnablePcap ("third", csmaDevices.Get (0), true);
 @end verbatim
 
 These three lines of code will start pcap tracing on both of the point-to-point

doc/tutorial/getting-started.texi

@@ -29,6 +29,26 @@
 @node Downloading ns-3
 @section Downloading ns-3
 
+@cindex Prerequisites
+@cindex Dependencies
+The @command{ns-3} system as a whole is a fairly complex system and has a
+number of dependencies on other components.  Along with the systems you will
+most likely deal with every day (the GNU toolchain, Mercurial, you programmer
+editor) you will need to ensure that a number of additional libraries are
+present on your system before proceeding.  @command{ns-3} provides a wiki
+for your reading pleasure that includes pages with many useful hints and tips.
+One such page is the ``Installation'' page,
+@uref{http://www.nsnam.org/wiki/index.php/Installation}.
+
+The ``Prerequisites'' section of this wiki page explains which packages are 
+required to support common @command{ns-3} options, and also provides the 
+commands used to install them for common Linux variants.  Cygwin users will
+have to use the Cygwin installer (if you are a Cygwin user, you used it to
+install Cygwin). 
+
+You may want to take this opportunity to explore the @command{ns-3} wiki 
+a bit since there really is a wealth of information there. 
+
 @cindex Linux
 @cindex Cygwin
 @cindex GNU
@@ -37,9 +57,10 @@
 @cindex Waf
 From this point forward, we are going to assume that the reader is working in
 Linux or a Linux emulation environment (Linux, Cygwin, etc.) and has the GNU
-toolchain installed and verified.  We are also going to assume that you have
-Mercurial and Waf installed and running on the target system as described in
-the Getting Started section of the  @command{ns-3} web site: 
+toolchain installed and verified along with the prerequisites mentioned 
+above.  We are also going to assume that you have Mercurial and Waf installed
+and running on the target system as described in the ``Getting Started'' section 
+of the  @command{ns-3} web site: 
 @uref{http://www.nsnam.org/getting_started.html}.
 
 @cindex tarball
@@ -415,7 +436,7 @@ default or require support from the underlying system to work properly.
 For instance, to enable XmlTo, the library libxml-2.0 must be found on the
 system.  If this library were not found, the corresponding @command{ns-3} feature 
 would not be enabled and a message would be displayed.  Note further that there is 
-a feature to use the progarm @code{sudo} to set the suid bit of certain programs.
+a feature to use the program @code{sudo} to set the suid bit of certain programs.
 This is not enabled by default and so this feature is reported as ``not enabled.''
 
 Now go ahead and switch back to the debug build.
@@ -601,6 +622,34 @@ produces the following output.
 
 @emph{Congratulations.  You are now an ns-3 user.}
 
+@emph{What do I do if I don't see the output?}
+
+If you don't see @code{waf} messages indicating that the build was 
+completed successfully, but do not see the ``Hello Simulator'' output, 
+chances are that you have switched your build mode to ``optimized'' in 
+the ``Building with Waf'' section, but have missed the change back to 
+``debug'' mode.  All of the console output used in this tutorial uses a 
+special @command{ns-3} logging component that is useful for printing 
+user messages to the console.  Output from this component is 
+automatically disabled when you compile optimized code -- it is 
+``optimized out.''  If you don't see the ``Hello Simulator'' output,
+type the following,
+
+@verbatim
+  ./waf -d debug configure
+@end verbatim
+
+to tell @code{waf} to build the debug versions of the @command{ns-3} 
+programs.  You must still build the actual debug version of the code by
+typing,
+
+@verbatim
+  ./waf
+@end verbatim
+
+Now, if you run the @code{hello-simulator} program, you should see the 
+expected output.
+
 If you want to run programs under another tool such as gdb or valgrind,
 see this @uref{http://www.nsnam.org/wiki/index.php/User_FAQ#How_to_run_NS-3_programs_under_another_tool,,wiki entry}.
 

doc/tutorial/in-process/introduction.texi

@@ -20,7 +20,7 @@ other important resources that are available to those interested in using or
 writing scripts, models and even those interested in making contributions to
 the core ns-3 system.  We provide an overview of some of the 
 important abstractions, design patterns and idioms used when writing 
-ns-3 scripts, and then dig right in by begining to write simulation 
+ns-3 scripts, and then dig right in by beginning to write simulation 
 scripts, run them and interpret results.
 
 After completing this tutorial, one should be able to:
@@ -749,8 +749,8 @@ an easy to use model.
 Topology helper functions use the abstractions (described above) of Network
 Interface Cards and Cables.  When you think of adding a new kind of network,
 you may think of going out to the local computer retailer and buying a kit.
-This kit might include a nework cable and some number of peripheral cards and
-thier associated software drivers.  You can think of topology helpers in 
+This kit might include a network cable and some number of peripheral cards and
+their associated software drivers.  You can think of topology helpers in 
 roughly the same way.  Instead of buying a kit for a given type of network,
 you will use a topology helper class for a given type of network, to accomplish
 the equivalent of installing the network ``kit.''
@@ -758,7 +758,7 @@ the equivalent of installing the network ``kit.''
 @section Important Idioms
 Now that we have identified that there are C++ classes in the system called
 @code{Node} and @code{InternetNode}, we need to understand how to bring
-objects of these classes into existance, and manage their lifetimes.  Let's
+objects of these classes into existence, and manage their lifetimes.  Let's
 examine this in some detail here.
 
 @cindex InternetNode
@@ -1164,7 +1164,7 @@ To summarize: The magic happens in the assignment operator.  Class
 Therefore, there exists a standard conversion from an @code{InternetNode *} 
 to a @code{Node *} and by extension from an @code{InternetNode &} to a
 @code{Node &}.  This conversion is applied automatically (and invisibly) 
-during paramater passing in the assignment operator we are examining.
+during parameter passing in the assignment operator we are examining.
 
 @cindex base class
 This is a rather involved way of saying there's an invisible pointer cast
@@ -1202,7 +1202,7 @@ like:
 @cindex InternetNode
 @cindex smart pointer
 Now we know that this is really a simple statement.  We create an
-@code{InternetNode} object on the heap (indirecly using operator @code{new}
+@code{InternetNode} object on the heap (indirectly using operator @code{new}
 and passing no parameters to its constructor) and assign responsibility for
 managing the new object's lifetime to a smart pointer.  This smart pointer is 
 a pointer to a @code{Node} object, so there was a hidden cast from 
@@ -1366,7 +1366,7 @@ was used in the example):
 @end itemize
 
 C++ will attempt to promote parameters appropriately, but you will typically
-see constructions that respect the type corrrectness of the constructor, as
+see constructions that respect the type correctness of the constructor, as
 in @code{Seconds (1.)} and @code{MilliSeconds (2)}.  Notice that the code
 @code{Seconds (1)} will work just as well as @code{Seconds (1.)} since the 
 integer 1 will be automatically promoted to a double 1. in the former code.
@@ -1547,7 +1547,7 @@ application as named parameters for clarity.  We are telling the application
 to generate 1024 byte packets (@code{packetSize = 1024}); and to send these
 packets to port 7 (@code{port = 7;}).  The application is told to send at most
 one packet (@code{maxPacketCount = 1;}); and to delay for one second between
-packet sends (@code{interpacketInterval = Seconds(1.)}) which is not used since
+packet sends (@code{interPacketInterval = Seconds(1.)}) which is not used since
 only one packet is sent.  We will defer addressing the type @code{Time} until
 we discuss the simulator engine.  For now just understand the semantics are
 to wait for one second.
@@ -1780,17 +1780,17 @@ In ns-3 an event is basically a pre-packaged function call called a
 a more descriptive term --- an object (in the object-oriented programming 
 sense) that can be called as if it was a function.  Typically one uses a
 functor to implement @emph{deferred execution} of a function or method.  The
-most commonly encoutered form of deferred execution is in a @emph{callback}
+most commonly encountered form of deferred execution is in a @emph{callback}
 from an I/O system.  In this case, the goal would be to start an I/O
 operation and return immediately, without having to wait for the operation 
-to complete.  One asks the I/O subsytem to notify you when an operation is
+to complete.  One asks the I/O subsystem to notify you when an operation is
 complete by calling some function you provide.  This provided function is
 known as a callback function.  [Imagine calling someone on the telephone and
 asking them to do something for you.  You also ask them to @emph{call you back}
 when they are done.]  Events in the ns-3 system work conceptually
 the same way, except that instead of an I/O completion driving the process,
 the arrival of some simulated time drives the process.  The ns-3 
-deferred exectution mechanism is via a class called @code{Callback}.
+deferred execution mechanism is via a class called @code{Callback}.
 
 @cindex Time
 @cindex Callback

doc/tutorial/in-process/other.texi

@@ -584,7 +584,7 @@ have been changed.
 
 Next, we create a point to point link to connect the two lans.  We connect
 the point-to-point channel between nodes three (on the left lan) and four
-(on the right lan).  You should recoginze this as substantially similar to
+(on the right lan).  You should recognize this as substantially similar to
 the link setup from the @code{point-to-point} example.
 
 @verbatim
@@ -735,7 +735,7 @@ give you a starting point for required classes and member variables.
 Immediately we can notice that at the highest level we are talking about the
 noun @emph{network}.  This probably won't surprise you.  We also have an 
 adjective that modifies the noun --- @emph{bus}.  This should lead us to our 
-first class defintion.  Usually class names are constructed in the same way
+first class definition.  Usually class names are constructed in the same way
 as an English language sentence would be spoken.  For example, one would speak
 of a @emph{bus network} in conversation, so we would normally create a
 @code{class BusNetwork} to represent it.  
@@ -901,7 +901,7 @@ after this initialization.  They are:
     Ipv4AddressGenerator::SeedAddress (mask, baseAddress);
 @end verbatim
 
-We provide an IP address generator class to allow us to programatically 
+We provide an IP address generator class to allow us to programmatically
 allocate IP addresses.  The first call to @code{SeedNetwork} gives the
 address generator a starting network number to use when generating addresses.
 The second call to @code{SeedAddress} gives the address generator a starting
@@ -1011,7 +1011,7 @@ relatively abstract bus class, we can create bus networks with 4, 40 or 4000
 nodes with no additional effort.
 
 A use of the bus network class is shown in the file 
-@code{bus-netowrk.cc} located in the @code{tutorial} directory.  The
+@code{bus-network.cc} located in the @code{tutorial} directory.  The
 interesting code is,
 
 @verbatim
@@ -1058,7 +1058,7 @@ In the next part of the tutorial we are going to drop down a level and begin
 examining the lower levels of the system in more detail.  We are going to
 explain how to change the behavior of the system and eventually how to write
 new models and applications.  This is a good time to make sure that you
-thorougly understand what we've gone over so far.
+thoroughly understand what we've gone over so far.
 
 @c ========================================================================
 @c Object Model
@@ -1365,7 +1365,7 @@ its aggregation via the method @code{GetObject}.
 Technically, the class named @code{Object} is simply a base class that you
 will inherit from if you want your @code{Objects} to support aggregation and
 discovery.  Many systems have a base class that implements common 
-functionality and these base classes are typically called somthing like 
+functionality and these base classes are typically called something like 
 Object.  The @command{ns-3} version of this base class relates primarily to
 @code{Object} aggregation and discovery, although it does also provide methods
 to help with intrusive reference counting and tracing as well.
@@ -1383,7 +1383,7 @@ rather than with the form of the class declaration.
 For those of you unfamiliar with Microsoft COM, CORBA or ORBit, this might 
 sound obvious.  For those of with such a background, the point we are making 
 is that there is no such thing in @command{ns-3} as a separate Interface
-declaration, no such thing as an Interface Definiition Language, no such thing
+declaration, no such thing as an Interface Definition Language, no such thing
 as a UUID or GUID, etc.  In @command{ns-3} we just work with C++ objects that
 may be given some very useful abilities by inheriting from the @command{ns-3}
 base class @code{Object}.  @command{Ns-3} @code{Objects} are not required to
@@ -1422,7 +1422,7 @@ mentioned that the @code{Node} class acts as a container.  In fact, the
 @code{Object}.  So, when the @code{Node} object is created it is really an 
 aggregation of one @code{Object} and you can call @code{AggregateObject} or
 @code{GetObject} on the resulting @code{Node} object.  Along with being an
-aggregation, the @code{Node} class also describes a public interface.  THis
+aggregation, the @code{Node} class also describes a public interface.  This
 public interface (API) is declared just as any C++ object is declared, via its
 class methods as specified in the inheritance tree.  For those steeped in 
 COM or CORBA, this is where the concept of Interface works in @command{ns-3}.
@@ -1531,7 +1531,7 @@ The right hand side illustrates how @code{GetObject} is acutally used.
 The method @code{GetObject} is templated.  The assocated template parameter 
 (between the brackets) specifies the @emph{class} that is being requested.
 This is important.  Since it is the class type that specifies the search
-criteron, there can be only one instance of a particular class present in an
+criterion, there can be only one instance of a particular class present in an
 aggregation.  Looking back a little, although the parameter to
 @code{AggregateObject} appears to be a vanilla C++ object (@code{b} or @code{c}
 above), it actually represents (is an instance of) a class that has an
@@ -1648,7 +1648,7 @@ If you can get to @code{Object B} from @code{Object A}, and you can get to
 @cindex TypeId
 @cindex GetTypeId
 The final piece of this puzzle is the @code{TypeId}.  Recall that the
-declaration our eample object above included the following code
+declaration our example object above included the following code
 
 @verbatim
   static ns3::TypeId GetTypeId (void)
@@ -1787,7 +1787,7 @@ constructor to be used when an instance of your class is created using
   AddConstructor<A> ();
 @end verbatim
 
-You can interpret this as explaining to the @command{ns-3} object ssytem that
+You can interpret this as explaining to the @command{ns-3} object system that
 you have a constructor named @code{A::A} which takes no parameters.  You are
 saying that this constructor should be used when @code{CreateObject} is called
 with no parameters.

doc/tutorial/in-process/output.texi

@@ -72,7 +72,7 @@ For Internet nodes, the ASCII trace wrapper is a wrapper around
 the @command{ns-3} low-level 
 tracing system that lets you get access to underlying trace events easily.  
 The output of a trace of a simulation run is an ASCII file --- thus the name.  
-In the spririt of keeping things simple, you won't be able to control or 
+In the spirit of keeping things simple, you won't be able to control or 
 configure the output at this stage.
 
 For those familiar with @command{ns-2} output, this type of trace is
@@ -191,7 +191,7 @@ is created it is given an identifying number that monotonically increases from
 zero.  Therefore, @code{nodeid=0} means that the node in which the given trace
 event originated is the first node we created.  In the case of our script, 
 this first node is is the node pointed to by the smart pointer @code{n0}.  Not
-too surpsisingly, this is also the node to which we attached the
+too surprisingly, this is also the node to which we attached the
 @code{UdpEchoClient}.  The device number is local to each node, and so the
 device given by @code{device=0} is the first net device that we added to the
 node in question.  In our simulation, this corresponds to the 
@@ -339,7 +339,7 @@ one has received the UDP echo packet and the @code{UdpEchoServer Application}
 on that node has turned the packet around.  Just as node zero needed to ARP
 for the MAC address of node one, now node one must ARP for the MAC address of
 node zero.  We see the ARP request enqueued on the transmit queue of node one;
-then we see the ARP request dequeued from the tranmit queue of node one (and
+then we see the ARP request dequeued from the transmit queue of node one (and
 implicitly transmitted to node zero).  Then we see an ARP response enqueued
 on the transmit queue of node zero; and finally the ARP response dequeued (and
 implicitly transmitted back to node one).
@@ -396,7 +396,7 @@ tcpdump and Wireshark can be used..
 The code used to enable pcap tracing is similar to that for ASCII tracing.  
 We have provided another file, @code{tutorial-csma-echo-pcap-trace.cc} that 
 uses the pcap trace wrapper.  We have added the code to include the pcap 
-trace wrapper defintions:
+trace wrapper definitions:
 
 @verbatim
   #include "ns3/pcap-trace.h"
@@ -447,7 +447,7 @@ those nodes.
 
 @subsubsection Reading output with Wireshark
 @cindex Wireshark
-If you are unfamilar with Wireshark, there is a web site available from which
+If you are unfamiliar with Wireshark, there is a web site available from which
 you can download programs and documentation:  @uref{http://www.wireshark.org/}.
 
 If you have Wireshark available, you can open each of the trace files and

doc/tutorial/tweaking.texi

@@ -628,7 +628,7 @@ to some other value than one.
 How would you go about that?  Give it a try.  Remember you have to comment 
 out the place we override the default @code{Attribute} and explicitly set 
 @code{MaxPackets} in the script.  Then you have to rebuild the script.  You 
-will also have to find the syntax for actually setting the new default atribute
+will also have to find the syntax for actually setting the new default attribute
 value using the command line help facility.  Once you have this figured out 
 you should be able to control the number of packets echoed from the command 
 line.  Since we're nice folks, we'll tell you that your command line should 
@@ -812,32 +812,32 @@ generated by many scripts.
 
 @cindex tracing packets
 Let's just jump right in and add some ASCII tracing output to our 
-@code{scratch/myfirst.cc} script.  
-
-The first thing you need to do is to add the following include to the top of
-the script just after the GNU GPL comment:
+@code{scratch/myfirst.cc} script.  Right before the call to 
+@code{Simulator::Run ()}, add the following lines of code:
 
 @verbatim
-  #include <fstream>
+  AsciiTraceHelper ascii;
+  pointToPoint.EnableAsciiAll (ascii.CreateFileStream ("myfirst.tr"));
 @end verbatim
 
-Then, right before the call to @code{Simulator::Run ()}, add the
-following lines of code:
+Like in many other @command{ns-3} idioms, this code uses a  helper object to 
+help create ASCII traces.  The second line contains two nested method calls.  
+The ``inside'' method, @code{CreateFileStream()} uses an unnamed object idiom
+to create a file stream object on the stack (without an object  name) and pass
+it down to the called method.  We'll go into this more in the future, but all
+you have to know at this point is that you are creating an object representing
+a file named ``myfirst.tr'' and passing it into @code{ns-3}.  You are telling 
+@code{ns-3} to deal with the lifetime issues of the created object and also to 
+deal with problems caused by a little-known (intentional) limitation of C++ 
+ofstream objects relating to copy constructors.
 
-@verbatim
-  std::ofstream ascii;
-  ascii.open ("myfirst.tr");
-  PointToPointHelper::EnableAsciiAll (ascii);
-@end verbatim
+The outside call, to @code{EnableAsciiAll()}, tells the helper that you 
+want to enable ASCII tracing on all point-to-point devices in your simulation; 
+and you want the (provided) trace sinks to write out information about packet 
+movement in ASCII format.
 
-The first two lines are just vanilla C++ code to open a stream that will be
-written to a file named ``myfirst.tr''.  See your favorite C++ tutorial if you
-are unfamiliar with this code.  The last line of code in the snippet above
-tells @command{ns-3} that you want to enable ASCII tracing on all 
-point-to-point devices in your simulation; and you want the (provided) trace
-sinks to write out information about packet movement in ASCII format to the 
-stream provided. For those familiar with @command{ns-2}, the traced events are
-equivalent to the popular trace points that log "+", "-", "d", and "r" events.
+For those familiar with @command{ns-2}, the traced events are equivalent to 
+the popular trace points that log "+", "-", "d", and "r" events.
 
 You can now build the script and run it from the command line:
 
@@ -984,7 +984,7 @@ traces.  In this tutorial, we concentrate on viewing pcap traces with tcpdump.
 The code used to enable pcap tracing is a one-liner.  
 
 @verbatim
-  PointToPointHelper::EnablePcapAll ("myfirst");
+  pointToPoint.EnablePcapAll ("myfirst");
 @end verbatim
 
 Go ahead and insert this line of code after the ASCII tracing code we just 
@@ -993,7 +993,7 @@ added to @code{scratch/myfirst.cc}.  Notice that we only passed the string
 parameter is a prefix, not a complete file name.  The helper will actually 
 create a trace file for every point-to-point device in the simulation.  The 
 file names will be built using the prefix, the node number, the device number
- and a ``.pcap'' suffix.
+and a ``.pcap'' suffix.
 
 In our example script, we will eventually see files named ``myfirst-0-0.pcap'' 
 and ``myfirst-1-0.pcap'' which are the pcap traces for node 0-device 0 and 
@@ -1037,7 +1037,7 @@ the client in the first dump at 2.514648 seconds.
 
 @subsubsection Reading output with Wireshark
 @cindex Wireshark
-If you are unfamilar with Wireshark, there is a web site available from which
+If you are unfamiliar with Wireshark, there is a web site available from which
 you can download programs and documentation:  @uref{http://www.wireshark.org/}.
 
 Wireshark is a graphical user interface which can be used for displaying these

examples/csma/csma-bridge-one-hop.cc

@@ -209,23 +209,23 @@ main (int argc, char *argv[])
   sink2.Start (Seconds (1.1));
   sink2.Stop (Seconds (10.0));
 
+  NS_LOG_INFO ("Configure Tracing.");
+
   //
   // Configure tracing of all enqueue, dequeue, and NetDevice receive events.
   // Trace output will be sent to the file "csma-bridge-one-hop.tr"
   //
-  NS_LOG_INFO ("Configure Tracing.");
-  std::ofstream ascii;
-  ascii.open ("csma-bridge-one-hop.tr");
-  CsmaHelper::EnableAsciiAll (ascii);
+  AsciiTraceHelper ascii;
+  csma.EnableAsciiAll (ascii.CreateFileStream ("csma-bridge-one-hop.tr"));
 
   //
   // Also configure some tcpdump traces; each interface will be traced.
   // The output files will be named:
-  //     csma-bridge-<nodeId>-<interfaceId>.pcap
+  //     csma-bridge-one-hop-<nodeId>-<interfaceId>.pcap
   // and can be read by the "tcpdump -r" command (use "-tt" option to
   // display timestamps correctly)
   //
-  CsmaHelper::EnablePcapAll ("csma-bridge-one-hop", false);
+  csma.EnablePcapAll ("csma-bridge-one-hop", false);
 
   //
   // Now, do the actual simulation.

examples/csma/csma-bridge.cc

@@ -137,15 +137,14 @@ main (int argc, char *argv[])
   app = sink.Install (terminals.Get (0));
   app.Start (Seconds (0.0));
 
+  NS_LOG_INFO ("Configure Tracing.");
 
   //
   // Configure tracing of all enqueue, dequeue, and NetDevice receive events.
   // Trace output will be sent to the file "csma-bridge.tr"
   //
-  NS_LOG_INFO ("Configure Tracing.");
-  std::ofstream ascii;
-  ascii.open ("csma-bridge.tr");
-  CsmaHelper::EnableAsciiAll (ascii);
+  AsciiTraceHelper ascii;
+  csma.EnableAsciiAll (ascii.CreateFileStream ("csma-bridge.tr"));
 
   //
   // Also configure some tcpdump traces; each interface will be traced.
@@ -154,7 +153,7 @@ main (int argc, char *argv[])
   // and can be read by the "tcpdump -r" command (use "-tt" option to
   // display timestamps correctly)
   //
-  CsmaHelper::EnablePcapAll ("csma-bridge", false);
+  csma.EnablePcapAll ("csma-bridge", false);
 
   //
   // Now, do the actual simulation.

examples/csma/csma-bridge.py

@@ -123,9 +123,8 @@ def main(argv):
     # Trace output will be sent to the file "csma-bridge.tr"
     #
     #print "Configure Tracing."
-    #std.ofstream ascii
-    #ascii.open("csma-bridge.tr")
-    #CsmaHelper.EnableAsciiAll(ascii)
+    #ascii = ns3.AsciiTraceHelper();
+    #csma.EnableAsciiAll(ascii.CreateFileStream ("csma-bridge.tr"));
 
     #
     # Also configure some tcpdump traces; each interface will be traced.
@@ -134,7 +133,7 @@ def main(argv):
     # and can be read by the "tcpdump -r" command(use "-tt" option to
     # display timestamps correctly)
     #
-    ns3.CsmaHelper.EnablePcapAll("csma-bridge", False)
+    csma.EnablePcapAll("csma-bridge", False)
 
     #
     # Now, do the actual simulation.

examples/csma/csma-broadcast.cc

@@ -107,14 +107,17 @@ main (int argc, char *argv[])
   app.Start (Seconds (1.0));
   app.Stop (Seconds (10.0));
 
+  // Configure ascii tracing of all enqueue, dequeue, and NetDevice receive 
+  // events on all devices.  Trace output will be sent to the file 
+  // "csma-one-subnet.tr"
+  AsciiTraceHelper ascii;
+  csma.EnableAsciiAll (ascii.CreateFileStream ("csma-broadcast.tr"));
+
   // Also configure some tcpdump traces; each interface will be traced
   // The output files will be named 
   // csma-broadcast-<nodeId>-<interfaceId>.pcap
   // and can be read by the "tcpdump -tt -r" command 
-  CsmaHelper::EnablePcapAll ("csma-broadcast", false);
-  std::ofstream ascii;
-  ascii.open ("csma-broadcast.tr", std::ios_base::binary | std::ios_base::out);
-  CsmaHelper::EnableAsciiAll (ascii);
+  csma.EnablePcapAll ("csma-broadcast", false);
 
   NS_LOG_INFO ("Run Simulation.");
   Simulator::Run ();    

examples/csma/csma-multicast.cc

@@ -155,22 +155,21 @@ main (int argc, char *argv[])
   sinkC.Start (Seconds (1.0));
   sinkC.Stop (Seconds (10.0));
 
-  //
-  // Configure tracing of all enqueue, dequeue, and NetDevice receive events.
   NS_LOG_INFO ("Configure Tracing.");
   //
+  // Configure tracing of all enqueue, dequeue, and NetDevice receive events.
   // Ascii trace output will be sent to the file "csma-multicast.tr"
   //
-  std::ofstream ascii;
-  ascii.open ("csma-multicast.tr",std::ios_base::binary | std::ios_base::out);
-  CsmaHelper::EnableAsciiAll (ascii);
+  AsciiTraceHelper ascii;
+  csma.EnableAsciiAll (ascii.CreateFileStream ("csma-multicast.tr"));
 
   // Also configure some tcpdump traces; each interface will be traced.
   // The output files will be named:
   //     csma-multicast-<nodeId>-<interfaceId>.pcap
   // and can be read by the "tcpdump -r" command (use "-tt" option to
   // display timestamps correctly)
-  CsmaHelper::EnablePcapAll ("csma-multicast", false);
+  csma.EnablePcapAll ("csma-multicast", false);
+
   //
   // Now, do the actual simulation.
   //

examples/csma/csma-one-subnet.cc

@@ -114,22 +114,25 @@ main (int argc, char *argv[])
   app = sink.Install (nodes.Get (0));
   app.Start (Seconds (0.0));
 
-//
-// Configure tracing of all enqueue, dequeue, and NetDevice receive events.
-// Trace output will be sent to the file "csma-one-subnet.tr"
-//
   NS_LOG_INFO ("Configure Tracing.");
-  std::ofstream ascii;
-  ascii.open ("csma-one-subnet.tr", std::ios_base::binary | std::ios_base::out);
-  CsmaHelper::EnableAsciiAll (ascii);
+//
+// Configure ascii tracing of all enqueue, dequeue, and NetDevice receive 
+// events on all devices.  Trace output will be sent to the file 
+// "csma-one-subnet.tr"
+//
+  AsciiTraceHelper ascii;
+  csma.EnableAsciiAll (ascii.CreateFileStream ("csma-one-subnet.tr"));
+
 //
 // Also configure some tcpdump traces; each interface will be traced.
 // The output files will be named:
-//     csma-one-subnet-<nodeId>-<interfaceId>.pcap
+//
+//     csma-one-subnet-<node ID>-<device's interface index>.pcap
+//
 // and can be read by the "tcpdump -r" command (use "-tt" option to
 // display timestamps correctly)
 //
-  CsmaHelper::EnablePcapAll ("csma-one-subnet", false);
+  csma.EnablePcapAll ("csma-one-subnet", false);
 //
 // Now, do the actual simulation.
 //

examples/csma/csma-packet-socket.cc

@@ -14,7 +14,6 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
-// Port of ns-2/tcl/ex/simple.tcl to ns-3
 //
 // Network topology
 //
@@ -22,11 +21,9 @@
 //       |     |    |    |
 //     =====================
 //
-// - CBR/UDP flows from n0 to n1, and from n3 to n0
-// - UDP packet size of 210 bytes, with per-packet interval 0.00375 sec.
-//   (i.e., DataRate of 448,000 bps)
-// - DropTail queues 
-// - Tracing of queues and packet receptions to file "csma-one-subnet.tr"
+// - Packet socket flow from n0 to n3
+// - Default 512 byte packets generated by traffic generator
+//   Trace output will be sent to the csma-packet-socket.tr file
 
 #include <iostream>
 #include <fstream>
@@ -116,9 +113,9 @@ main (int argc, char *argv[])
   // Configure tracing of all enqueue, dequeue, and NetDevice receive events
   // Trace output will be sent to the csma-packet-socket.tr file
   NS_LOG_INFO ("Configure Tracing.");
-  std::ofstream os;
-  os.open ("csma-packet-socket.tr", std::ios_base::binary | std::ios_base::out);
-  csma.EnableAsciiAll (os);
+
+  AsciiTraceHelper ascii;
+  csma.EnableAsciiAll (ascii.CreateFileStream ("csma-packet-socket.tr"));
 
   NS_LOG_INFO ("Run Simulation.");
   Simulator::Run ();

examples/csma/csma-ping.cc

@@ -14,19 +14,14 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
-// Port of ns-2/tcl/ex/simple.tcl to ns-3
-//
 // Network topology
 //
 //       n0    n1   n2   n3
 //       |     |    |    |
 //     =====================
 //
-// - CBR/UDP flows from n0 to n1, and from n3 to n0
-// - UDP packet size of 210 bytes, with per-packet interval 0.00375 sec.
-//   (i.e., DataRate of 448,000 bps)
-// - DropTail queues 
-// - Tracing of queues and packet receptions to file "csma-one-subnet.tr"
+//  node n0,n1,n3 pings to node n2
+//  node n0 generates protocol 2 (IGMP) to node n3
 
 #include <iostream>
 #include <fstream>
@@ -83,8 +78,6 @@ main (int argc, char *argv[])
   ip.SetBase ("192.168.1.0", "255.255.255.0");
   Ipv4InterfaceContainer addresses = ip.Assign (devs);
 
-  // setup global router
-  Ipv4GlobalRoutingHelper::PopulateRoutingTables ();
   NS_LOG_INFO ("Create Source");
   Config::SetDefault ("ns3::Ipv4RawSocketImpl::Protocol", StringValue ("2"));
   InetSocketAddress dst = InetSocketAddress (addresses.GetAddress (3));

examples/csma/csma-raw-ip-socket.cc

@@ -14,19 +14,17 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
-// Port of ns-2/tcl/ex/simple.tcl to ns-3
 //
 // Network topology
-//
+//    (sender)         (receiver)
 //       n0    n1   n2   n3
 //       |     |    |    |
 //     =====================
 //
-// - CBR/UDP flows from n0 to n1, and from n3 to n0
-// - UDP packet size of 210 bytes, with per-packet interval 0.00375 sec.
-//   (i.e., DataRate of 448,000 bps)
-// - DropTail queues 
-// - Tracing of queues and packet receptions to file "csma-one-subnet.tr"
+// Node n0 sends data to node n3 over a raw IP socket.  The protocol
+// number used is 2.
+// The default traffic rate is to send 1250 bytes/second for 10 kb/s 
+// The data rate can be toggled by command line argument
 
 #include <iostream>
 #include <fstream>
@@ -44,7 +42,9 @@ NS_LOG_COMPONENT_DEFINE ("CsmaPacketSocketExample");
 
 static void SinkRx (Ptr<const Packet> p, const Address &ad)
 {
-  //std::cout << *p << std::endl;
+  // Enable the below line to see the packet contents printed out at the
+  // receive sink
+  //std::cout << Simulator::Now().GetSeconds () << " " << *p << std::endl;
 }
 
 int
@@ -53,8 +53,9 @@ main (int argc, char *argv[])
 #if 0 
   LogComponentEnable ("CsmaPacketSocketExample", LOG_LEVEL_INFO);
 #endif
-
+  uint32_t dataRate = 10;
   CommandLine cmd;
+  cmd.AddValue ("dataRate", "application dataRate (Kb/s)", dataRate);
   cmd.Parse (argc, argv);
 
   // Here, we will explicitly create four nodes.
@@ -82,23 +83,24 @@ main (int argc, char *argv[])
   Ipv4InterfaceContainer addresses = ip.Assign (devs);
 
   NS_LOG_INFO ("Create Source");
+  // IP protocol configuration
   Config::SetDefault ("ns3::Ipv4RawSocketImpl::Protocol", StringValue ("2"));
   InetSocketAddress dst = InetSocketAddress (addresses.GetAddress (3));
   OnOffHelper onoff = OnOffHelper ("ns3::Ipv4RawSocketFactory", dst);
   onoff.SetAttribute ("OnTime", RandomVariableValue (ConstantVariable (1.0)));
   onoff.SetAttribute ("OffTime", RandomVariableValue (ConstantVariable (0.0)));
-  onoff.SetAttribute ("DataRate", DataRateValue (DataRate (6000)));
-  onoff.SetAttribute ("PacketSize", UintegerValue (1200));
+  onoff.SetAttribute ("DataRate", DataRateValue (DataRate (dataRate*1000)));
+  onoff.SetAttribute ("PacketSize", UintegerValue (1250));
 
   ApplicationContainer apps = onoff.Install (c.Get (0));
-  apps.Start (Seconds (1.0));
-  apps.Stop (Seconds (10.0));
+  apps.Start (Seconds (0.5));
+  apps.Stop (Seconds (11));
 
   NS_LOG_INFO ("Create Sink.");
   PacketSinkHelper sink = PacketSinkHelper ("ns3::Ipv4RawSocketFactory", dst);
   apps = sink.Install (c.Get (3));
   apps.Start (Seconds (0.0));
-  apps.Stop (Seconds (11.0));
+  apps.Stop (Seconds (12.0));
 
   NS_LOG_INFO ("Configure Tracing.");
   // first, pcap tracing in non-promiscuous mode

examples/csma/csma-star.cc

@@ -182,7 +182,7 @@ main (int argc, char *argv[])
   //
   // Do pcap tracing on all devices on all nodes.
   //
-  CsmaHelper::EnablePcapAll ("csma-star", false);
+  csma.EnablePcapAll ("csma-star", false);
 
   NS_LOG_INFO ("Run Simulation.");
   Simulator::Run ();

examples/emulation/emu-ping.cc

@@ -203,7 +203,8 @@ main (int argc, char *argv[])
   //
   // Enable a promiscuous pcap trace to see what is coming and going on our device.
   //
-  EmuHelper::EnablePcap ("emu-ping", device, true);
+  EmuHelper emu;
+  emu.EnablePcap ("emu-ping", device, true);
 
   //
   // Now, do the actual emulation.

examples/emulation/emu-udp-echo.cc

@@ -150,7 +150,7 @@ main (int argc, char *argv[])
 
   std::ofstream ascii;
   ascii.open ("emu-udp-echo.tr");
-  EmuHelper::EnablePcapAll ("emu-udp-echo", true);
+  emu.EnablePcapAll ("emu-udp-echo", true);
 
   //
   // Now, do the actual simulation.

examples/error-model/simple-error-model.cc

@@ -13,12 +13,8 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  *
- * ns-2 simple.tcl script (ported from ns-2)
- * Originally authored by Steve McCanne, 12/19/1996
  */
 
-// Port of ns-2/tcl/ex/simple.tcl to ns-3
-//
 // Network topology
 //
 //  n0
@@ -166,10 +162,9 @@ main (int argc, char *argv[])
   pem->SetList (sampleList);
   d0d2.Get (1)->SetAttribute ("ReceiveErrorModel", PointerValue (pem));
 
-  std::ofstream ascii;
-  ascii.open ("simple-error-model.tr");
-  PointToPointHelper::EnablePcapAll ("simple-error-model");
-  PointToPointHelper::EnableAsciiAll (ascii);
+  AsciiTraceHelper ascii;
+  p2p.EnableAsciiAll (ascii.CreateFileStream ("simple-error-model.tr"));
+  p2p.EnablePcapAll ("simple-error-model");
 
   NS_LOG_INFO ("Run Simulation.");
   Simulator::Run ();    

examples/ipv6/fragmentation-ipv6.cc

@@ -150,10 +150,9 @@ int main (int argc, char** argv)
   apps.Start (Seconds (2.0));
   apps.Stop (Seconds (20.0));
 
-  std::ofstream ascii;
-  ascii.open ("fragmentation-ipv6.tr");
-  CsmaHelper::EnablePcapAll (std::string ("fragmentation-ipv6"), true);
-  CsmaHelper::EnableAsciiAll (ascii);
+  AsciiTraceHelper ascii;
+  csma.EnableAsciiAll (ascii.CreateFileStream ("fragmentation-ipv6.tr"));
+  csma.EnablePcapAll (std::string ("fragmentation-ipv6"), true);
 
   NS_LOG_INFO ("Run Simulation.");
   Simulator::Run ();

examples/ipv6/icmpv6-redirect.cc

@@ -173,10 +173,9 @@ int main (int argc, char **argv)
   apps.Start (Seconds (2.0));
   apps.Stop (Seconds (10.0));
 
-  std::ofstream ascii;
-  ascii.open ("icmpv6-redirect.tr");
-  CsmaHelper::EnablePcapAll ("icmpv6-redirect", true);
-  CsmaHelper::EnableAsciiAll (ascii);
+  AsciiTraceHelper ascii;
+  csma.EnableAsciiAll (ascii.CreateFileStream ("icmpv6-redirect.tr"));
+  csma.EnablePcapAll ("icmpv6-redirect", true);
 
   /* Now, do the actual simulation. */
   NS_LOG_INFO ("Run Simulation.");

examples/ipv6/loose-routing-ipv6.cc

@@ -158,10 +158,9 @@ int main (int argc, char **argv)
   apps.Start (Seconds (1.0));
   apps.Stop (Seconds (10.0));
 
-  std::ofstream ascii;
-  ascii.open ("loose-routing-ipv6.tr");
-  CsmaHelper::EnablePcapAll ("loose-routing-ipv6", true);
-  CsmaHelper::EnableAsciiAll (ascii);
+  AsciiTraceHelper ascii;
+  csma.EnableAsciiAll (ascii.CreateFileStream ("loose-routing-ipv6.tr"));
+  csma.EnablePcapAll ("loose-routing-ipv6", true);
 
   NS_LOG_INFO ("Run Simulation.");
   Simulator::Run ();

examples/ipv6/ping6.cc

@@ -98,10 +98,9 @@ int main (int argc, char **argv)
   apps.Start (Seconds (2.0));
   apps.Stop (Seconds (10.0));
 
-  std::ofstream ascii;
-  ascii.open ("ping6.tr");
-  CsmaHelper::EnablePcapAll (std::string ("ping6"), true);
-  CsmaHelper::EnableAsciiAll (ascii);
+  AsciiTraceHelper ascii;
+  csma.EnableAsciiAll (ascii.CreateFileStream ("ping6.tr"));
+  csma.EnablePcapAll (std::string ("ping6"), true);
 
   NS_LOG_INFO ("Run Simulation.");
   Simulator::Run ();

examples/ipv6/radvd-two-prefix.cc

@@ -208,10 +208,9 @@ int main (int argc, char** argv)
   /* at the end, RA addresses and routes should be cleared */
   Simulator::Schedule (Seconds (10.0), &StackHelper::PrintRoutingTable, &stackHelper, n0); 
 
-  std::ofstream ascii;
-  ascii.open ("radvd-two-prefix.tr");
-  CsmaHelper::EnablePcapAll (std::string ("radvd-two-prefix"), true);
-  CsmaHelper::EnableAsciiAll (ascii);
+  AsciiTraceHelper ascii;
+  csma.EnableAsciiAll (ascii.CreateFileStream ("radvd-two-prefix.tr"));
+  csma.EnablePcapAll (std::string ("radvd-two-prefix"), true);
 
   NS_LOG_INFO ("Run Simulation.");
   Simulator::Run ();