branch merge
authorCraig Dowell <craigdo@ee.washington.edu>
Mon, 21 Jul 2008 15:53:03 -0700
changeset 3472 190ce8107098
parent 3471 0896bd4a38dd (current diff)
parent 3468 0bb5275704fc (diff)
child 3473 6bce86ea4778
branch merge
RELEASE_NOTES
--- a/RELEASE_NOTES	Fri Jul 18 21:59:43 2008 -0700
+++ b/RELEASE_NOTES	Mon Jul 21 15:53:03 2008 -0700
@@ -3,8 +3,13 @@
 
 This file contains ns-3 release notes (most recent releases first).
 
-Next Release (in ns-3-dev)
-==========================
+Release 3.2 (pending)
+=====================
+
+New functionality added
+-----------------------
+- Add learning bridge (IEEE 802.1D) implementation: BridgeNetDevice;
+- Python bindings added
 - Kernel thread support (class SystemThread) added;
 - Kernel mutual exclusion support (class SystemMutex) added;
 - Kernel critical section RAII support (class CriticalSection) added;
@@ -15,6 +20,44 @@
   implementation a replaceable component via the 
   "SimulatorImplementationType" global value.
   Hint:  try ./waf --run "udp-echo --PrintGlobals"
+- implement Packet::PeekHeader and Packet::PeekTrailer to avoid evil workarounds when receiving tcp packets. 
+
+Bugs fixed
+----------
+- add optional support for TCP and UDP checksum (bug 236)
+- close socket upon PacketSink::StopApplication (bug 243)
+- fix build failure with gcc 4.3.x (bug 245)
+
+API changes from 3.1 to 3.2
+---------------------------
+- several helper APIs related to attribute setting (changeset d5f8e5fae1c6, 
+  bug 234); old variants are currently deprecated API and will be removed
+  in a future release
+- remove references to Parameter in helper APIs (changeset 3cdd9d60f7c7,
+  bug 232); old variants are currently deprecated API and will be removed
+  in a future release
+- New NetDevice APIs: SendFrom and SetPromiscRxCallback;
+
+In order to support the learning bridge, some API changes in Node and
+NetDevice were made.
+
+In NetDevice, devices may optionally implement the virtual methods
+SendFrom, SupportsPromiscuous, and SetPromiscReceiveCallback.  If
+these new methods are not implemented, the code still compiles and
+works, except if they are used in a BridgeNetDevice.
+
+In Node, the signature for protocol handler callbacks (used in
+AddProtocolHandler) has changed.  Now it looks like:
+
+  void ReceiveFromDevice (Ptr<NetDevice> device, Ptr<Packet> packet, 
+    uint16_t protocol, Address const &source, Address const &destination, 
+    PacketType packetType);
+
+The extra parameters 'destination' and 'packetType' are present for
+all protocol handlers, but only have valid values for promiscuous
+protocol handlers.  Protocol handlers are non-promiscuous by default,
+so no action is needed to adapt existing code besides updating the
+callback signature.
 
 Release 3.1 (2008/06/30)
 ========================
--- a/bindings/python/callbacks_list.py	Fri Jul 18 21:59:43 2008 -0700
+++ b/bindings/python/callbacks_list.py	Mon Jul 21 15:53:03 2008 -0700
@@ -1,12 +1,13 @@
 callback_classes = [
     ['void', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
-    ['bool', 'ns3::Ptr<ns3::NetDevice>', 'ns3::Ptr<ns3::Packet>', 'unsigned short', 'ns3::Address const&', 'ns3::empty', 'ns3::empty'],
     ['void', 'ns3::Ptr<ns3::Socket>', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['void', 'ns3::Ptr<ns3::Socket>', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['void', 'ns3::Ptr<ns3::Socket>', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['bool', 'ns3::Ptr<ns3::Socket>', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['void', 'ns3::Ptr<ns3::Packet>', 'ns3::Mac48Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
-    ['void', 'ns3::Ptr<ns3::NetDevice>', 'ns3::Ptr<ns3::Packet>', 'unsigned short', 'ns3::Address const&', 'ns3::empty', 'ns3::empty'],
+    ['bool', 'ns3::Ptr<ns3::NetDevice>', 'ns3::Ptr<ns3::Packet>', 'unsigned short', 'ns3::Address const&', 'ns3::Address const&', 'ns3::NetDevice::PacketType'],
+    ['bool', 'ns3::Ptr<ns3::NetDevice>', 'ns3::Ptr<ns3::Packet>', 'unsigned short', 'ns3::Address const&', 'ns3::empty', 'ns3::empty'],
+    ['void', 'ns3::Ptr<ns3::NetDevice>', 'ns3::Ptr<ns3::Packet>', 'unsigned short', 'ns3::Address const&', 'ns3::Address const&', 'ns3::NetDevice::PacketType'],
     ['void', 'ns3::Ptr<ns3::Packet>', 'double', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['void', 'ns3::Ptr<ns3::Packet>', 'double', 'ns3::WifiMode', 'ns3::WifiPreamble', 'ns3::empty', 'ns3::empty'],
 ]
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bindings/python/ns3_module_bridge.py	Mon Jul 21 15:53:03 2008 -0700
@@ -0,0 +1,263 @@
+from pybindgen import Module, FileCodeSink, param, retval, cppclass
+
+def register_types(module):
+    root_module = module.get_root()
+    
+    ## bridge-net-device.h: ns3::BridgeNetDevice [class]
+    module.add_class('BridgeNetDevice', parent=root_module['ns3::NetDevice'])
+    ## bridge-channel.h: ns3::BridgeChannel [class]
+    module.add_class('BridgeChannel', parent=root_module['ns3::Channel'])
+    
+    ## 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 TimeStepPrecision
+    
+    nested_module = module.add_cpp_namespace('TimeStepPrecision')
+    register_types_ns3_TimeStepPrecision(nested_module)
+    
+    
+    ## 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 olsr
+    
+    nested_module = module.add_cpp_namespace('olsr')
+    register_types_ns3_olsr(nested_module)
+    
+
+def register_types_ns3_internal(module):
+    root_module = module.get_root()
+    
+
+def register_types_ns3_TimeStepPrecision(module):
+    root_module = module.get_root()
+    
+
+def register_types_ns3_Config(module):
+    root_module = module.get_root()
+    
+
+def register_types_ns3_olsr(module):
+    root_module = module.get_root()
+    
+
+def register_methods(root_module):
+    register_Ns3BridgeNetDevice_methods(root_module, root_module['ns3::BridgeNetDevice'])
+    register_Ns3BridgeChannel_methods(root_module, root_module['ns3::BridgeChannel'])
+    return
+
+def register_Ns3BridgeNetDevice_methods(root_module, cls):
+    ## bridge-net-device.h: static ns3::TypeId ns3::BridgeNetDevice::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## bridge-net-device.h: ns3::BridgeNetDevice::BridgeNetDevice() [constructor]
+    cls.add_constructor([])
+    ## bridge-net-device.h: void ns3::BridgeNetDevice::AddBridgePort(ns3::Ptr<ns3::NetDevice> bridgePort) [member function]
+    cls.add_method('AddBridgePort', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::NetDevice >', 'bridgePort')])
+    ## bridge-net-device.h: void ns3::BridgeNetDevice::SetName(std::string const name) [member function]
+    cls.add_method('SetName', 
+                   'void', 
+                   [param('std::string', 'name', is_const=True)], 
+                   is_virtual=True)
+    ## bridge-net-device.h: std::string ns3::BridgeNetDevice::GetName() const [member function]
+    cls.add_method('GetName', 
+                   'std::string', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## bridge-net-device.h: void ns3::BridgeNetDevice::SetIfIndex(uint32_t const index) [member function]
+    cls.add_method('SetIfIndex', 
+                   'void', 
+                   [param('uint32_t', 'index', is_const=True)], 
+                   is_virtual=True)
+    ## bridge-net-device.h: uint32_t ns3::BridgeNetDevice::GetIfIndex() const [member function]
+    cls.add_method('GetIfIndex', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## bridge-net-device.h: ns3::Ptr<ns3::Channel> ns3::BridgeNetDevice::GetChannel() const [member function]
+    cls.add_method('GetChannel', 
+                   'ns3::Ptr< ns3::Channel >', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## bridge-net-device.h: ns3::Address ns3::BridgeNetDevice::GetAddress() const [member function]
+    cls.add_method('GetAddress', 
+                   'ns3::Address', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## bridge-net-device.h: bool ns3::BridgeNetDevice::SetMtu(uint16_t const mtu) [member function]
+    cls.add_method('SetMtu', 
+                   'bool', 
+                   [param('uint16_t', 'mtu', is_const=True)], 
+                   is_virtual=True)
+    ## bridge-net-device.h: uint16_t ns3::BridgeNetDevice::GetMtu() const [member function]
+    cls.add_method('GetMtu', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## bridge-net-device.h: bool ns3::BridgeNetDevice::IsLinkUp() const [member function]
+    cls.add_method('IsLinkUp', 
+                   'bool', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## bridge-net-device.h: void ns3::BridgeNetDevice::SetLinkChangeCallback(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function]
+    cls.add_method('SetLinkChangeCallback', 
+                   'void', 
+                   [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')], 
+                   is_virtual=True)
+    ## bridge-net-device.h: bool ns3::BridgeNetDevice::IsBroadcast() const [member function]
+    cls.add_method('IsBroadcast', 
+                   'bool', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## bridge-net-device.h: ns3::Address ns3::BridgeNetDevice::GetBroadcast() const [member function]
+    cls.add_method('GetBroadcast', 
+                   'ns3::Address', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## bridge-net-device.h: bool ns3::BridgeNetDevice::IsMulticast() const [member function]
+    cls.add_method('IsMulticast', 
+                   'bool', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## bridge-net-device.h: ns3::Address ns3::BridgeNetDevice::GetMulticast() const [member function]
+    cls.add_method('GetMulticast', 
+                   'ns3::Address', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## bridge-net-device.h: ns3::Address ns3::BridgeNetDevice::MakeMulticastAddress(ns3::Ipv4Address multicastGroup) const [member function]
+    cls.add_method('MakeMulticastAddress', 
+                   'ns3::Address', 
+                   [param('ns3::Ipv4Address', 'multicastGroup')], 
+                   is_const=True, is_virtual=True)
+    ## bridge-net-device.h: bool ns3::BridgeNetDevice::IsPointToPoint() const [member function]
+    cls.add_method('IsPointToPoint', 
+                   'bool', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## bridge-net-device.h: bool ns3::BridgeNetDevice::Send(ns3::Ptr<ns3::Packet> packet, ns3::Address const & dest, uint16_t protocolNumber) [member function]
+    cls.add_method('Send', 
+                   'bool', 
+                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address&', 'dest', is_const=True), param('uint16_t', 'protocolNumber')], 
+                   is_virtual=True)
+    ## bridge-net-device.h: bool ns3::BridgeNetDevice::SendFrom(ns3::Ptr<ns3::Packet> packet, ns3::Address const & source, ns3::Address const & dest, uint16_t protocolNumber) [member function]
+    cls.add_method('SendFrom', 
+                   'bool', 
+                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address&', 'source', is_const=True), param('ns3::Address&', 'dest', is_const=True), param('uint16_t', 'protocolNumber')], 
+                   is_virtual=True)
+    ## bridge-net-device.h: ns3::Ptr<ns3::Node> ns3::BridgeNetDevice::GetNode() const [member function]
+    cls.add_method('GetNode', 
+                   'ns3::Ptr< ns3::Node >', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## bridge-net-device.h: void ns3::BridgeNetDevice::SetNode(ns3::Ptr<ns3::Node> node) [member function]
+    cls.add_method('SetNode', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Node >', 'node')], 
+                   is_virtual=True)
+    ## bridge-net-device.h: bool ns3::BridgeNetDevice::NeedsArp() const [member function]
+    cls.add_method('NeedsArp', 
+                   'bool', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## bridge-net-device.h: void ns3::BridgeNetDevice::SetReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> cb) [member function]
+    cls.add_method('SetReceiveCallback', 
+                   'void', 
+                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], 
+                   is_virtual=True)
+    ## bridge-net-device.h: void ns3::BridgeNetDevice::SetPromiscReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType> cb) [member function]
+    cls.add_method('SetPromiscReceiveCallback', 
+                   'void', 
+                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'cb')], 
+                   is_virtual=True)
+    ## bridge-net-device.h: bool ns3::BridgeNetDevice::SupportsPromiscuous() const [member function]
+    cls.add_method('SupportsPromiscuous', 
+                   'bool', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## bridge-net-device.h: void ns3::BridgeNetDevice::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
+    ## bridge-net-device.h: void ns3::BridgeNetDevice::ReceiveFromDevice(ns3::Ptr<ns3::NetDevice> device, ns3::Ptr<ns3::Packet> packet, uint16_t protocol, ns3::Address const & source, ns3::Address const & destination, ns3::NetDevice::PacketType packetType) [member function]
+    cls.add_method('ReceiveFromDevice', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::NetDevice >', 'device'), param('ns3::Ptr< ns3::Packet >', 'packet'), param('uint16_t', 'protocol'), param('ns3::Address&', 'source', is_const=True), param('ns3::Address&', 'destination', is_const=True), param('ns3::NetDevice::PacketType', 'packetType')], 
+                   visibility='protected')
+    ## bridge-net-device.h: void ns3::BridgeNetDevice::ForwardUnicast(ns3::Ptr<ns3::NetDevice> incomingPort, ns3::Ptr<ns3::Packet> packet, uint16_t protocol, ns3::Mac48Address src, ns3::Mac48Address dst) [member function]
+    cls.add_method('ForwardUnicast', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::NetDevice >', 'incomingPort'), param('ns3::Ptr< ns3::Packet >', 'packet'), param('uint16_t', 'protocol'), param('ns3::Mac48Address', 'src'), param('ns3::Mac48Address', 'dst')], 
+                   visibility='protected')
+    ## bridge-net-device.h: void ns3::BridgeNetDevice::ForwardBroadcast(ns3::Ptr<ns3::NetDevice> incomingPort, ns3::Ptr<ns3::Packet> packet, uint16_t protocol, ns3::Mac48Address src, ns3::Mac48Address dst) [member function]
+    cls.add_method('ForwardBroadcast', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::NetDevice >', 'incomingPort'), param('ns3::Ptr< ns3::Packet >', 'packet'), param('uint16_t', 'protocol'), param('ns3::Mac48Address', 'src'), param('ns3::Mac48Address', 'dst')], 
+                   visibility='protected')
+    ## bridge-net-device.h: void ns3::BridgeNetDevice::Learn(ns3::Mac48Address source, ns3::Ptr<ns3::NetDevice> port) [member function]
+    cls.add_method('Learn', 
+                   'void', 
+                   [param('ns3::Mac48Address', 'source'), param('ns3::Ptr< ns3::NetDevice >', 'port')], 
+                   visibility='protected')
+    ## bridge-net-device.h: ns3::Ptr<ns3::NetDevice> ns3::BridgeNetDevice::GetLearnedState(ns3::Mac48Address source) [member function]
+    cls.add_method('GetLearnedState', 
+                   'ns3::Ptr< ns3::NetDevice >', 
+                   [param('ns3::Mac48Address', 'source')], 
+                   visibility='protected')
+    return
+
+def register_Ns3BridgeChannel_methods(root_module, cls):
+    ## bridge-channel.h: static ns3::TypeId ns3::BridgeChannel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## bridge-channel.h: ns3::BridgeChannel::BridgeChannel() [constructor]
+    cls.add_constructor([])
+    ## bridge-channel.h: void ns3::BridgeChannel::AddChannel(ns3::Ptr<ns3::Channel> bridgedChannel) [member function]
+    cls.add_method('AddChannel', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Channel >', 'bridgedChannel')])
+    ## bridge-channel.h: uint32_t ns3::BridgeChannel::GetNDevices() const [member function]
+    cls.add_method('GetNDevices', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## bridge-channel.h: ns3::Ptr<ns3::NetDevice> ns3::BridgeChannel::GetDevice(uint32_t i) const [member function]
+    cls.add_method('GetDevice', 
+                   'ns3::Ptr< ns3::NetDevice >', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True, is_virtual=True)
+    return
+
+def register_functions(root_module):
+    module = root_module
+    register_functions_ns3_internal(module.get_submodule('internal'), root_module)
+    register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
+    register_functions_ns3_Config(module.get_submodule('Config'), root_module)
+    register_functions_ns3_olsr(module.get_submodule('olsr'), root_module)
+    return
+
+def register_functions_ns3_internal(module, root_module):
+    return
+
+def register_functions_ns3_TimeStepPrecision(module, root_module):
+    return
+
+def register_functions_ns3_Config(module, root_module):
+    return
+
+def register_functions_ns3_olsr(module, root_module):
+    return
+
--- a/bindings/python/ns3_module_common.py	Fri Jul 18 21:59:43 2008 -0700
+++ b/bindings/python/ns3_module_common.py	Mon Jul 21 15:53:03 2008 -0700
@@ -1,4 +1,4 @@
-from pybindgen import Module, FileCodeSink, write_preamble, param, retval
+from pybindgen import Module, FileCodeSink, param, retval, cppclass
 
 def register_types(module):
     root_module = module.get_root()
@@ -6,7 +6,7 @@
     ## error-model.h: ns3::ErrorUnit [enumeration]
     module.add_enum('ErrorUnit', ['EU_BIT', 'EU_BYTE', 'EU_PKT'])
     ## packet.h: ns3::Packet [class]
-    module.add_class('Packet', incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount')
+    module.add_class('Packet', memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
     ## packet.h: ns3::TagIterator [class]
     module.add_class('TagIterator')
     ## packet.h: ns3::TagIterator::Item [class]
@@ -24,27 +24,27 @@
     ## buffer.h: ns3::Buffer::Iterator [class]
     module.add_class('Iterator', outer_class=root_module['ns3::Buffer'])
     ## chunk.h: ns3::Chunk [class]
-    module.add_class('Chunk', allow_subclassing=True, parent=root_module['ns3::ObjectBase'])
+    module.add_class('Chunk', parent=root_module['ns3::ObjectBase'])
     ## data-rate.h: ns3::DataRate [class]
     module.add_class('DataRate')
     ## tag.h: ns3::Tag [class]
-    module.add_class('Tag', allow_subclassing=True, parent=root_module['ns3::ObjectBase'])
+    module.add_class('Tag', parent=root_module['ns3::ObjectBase'])
     ## pcap-writer.h: ns3::PcapWriter [class]
     module.add_class('PcapWriter', parent=root_module['ns3::RefCountBase'])
     ## data-rate.h: ns3::DataRateChecker [class]
     module.add_class('DataRateChecker', parent=root_module['ns3::AttributeChecker'])
     ## error-model.h: ns3::ErrorModel [class]
-    module.add_class('ErrorModel', allow_subclassing=True, parent=root_module['ns3::Object'])
+    module.add_class('ErrorModel', parent=root_module['ns3::Object'])
     ## header.h: ns3::Header [class]
-    module.add_class('Header', allow_subclassing=True, parent=root_module['ns3::Chunk'])
+    module.add_class('Header', parent=root_module['ns3::Chunk'])
     ## trailer.h: ns3::Trailer [class]
-    module.add_class('Trailer', allow_subclassing=True, parent=root_module['ns3::Chunk'])
+    module.add_class('Trailer', parent=root_module['ns3::Chunk'])
     ## error-model.h: ns3::ListErrorModel [class]
-    module.add_class('ListErrorModel', allow_subclassing=True, parent=root_module['ns3::ErrorModel'])
+    module.add_class('ListErrorModel', parent=root_module['ns3::ErrorModel'])
     ## data-rate.h: ns3::DataRateValue [class]
-    module.add_class('DataRateValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue'])
+    module.add_class('DataRateValue', parent=root_module['ns3::AttributeValue'])
     ## error-model.h: ns3::RateErrorModel [class]
-    module.add_class('RateErrorModel', allow_subclassing=True, parent=root_module['ns3::ErrorModel'])
+    module.add_class('RateErrorModel', parent=root_module['ns3::ErrorModel'])
     
     ## Register a nested module for the namespace internal
     
@@ -111,110 +111,211 @@
 
 def register_Ns3Packet_methods(root_module, cls):
     ## packet.h: ns3::Packet::Packet() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## packet.h: ns3::Packet::Packet(ns3::Packet const & o) [copy constructor]
-    cls.add_constructor([param('ns3::Packet&', 'o', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::Packet&', 'o', is_const=True)])
     ## packet.h: ns3::Packet::Packet(uint32_t size) [constructor]
-    cls.add_constructor([param('uint32_t', 'size')], visibility='public')
+    cls.add_constructor([param('uint32_t', 'size')])
     ## packet.h: ns3::Packet::Packet(uint8_t const * buffer, uint32_t size) [constructor]
-    cls.add_constructor([param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint32_t', 'size')], visibility='public')
+    cls.add_constructor([param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint32_t', 'size')])
     ## packet.h: void ns3::Packet::AddAtEnd(ns3::Ptr<const ns3::Packet> packet) [member function]
-    cls.add_method('AddAtEnd', 'void', [param('ns3::Ptr< const ns3::Packet >', 'packet')])
+    cls.add_method('AddAtEnd', 
+                   'void', 
+                   [param('ns3::Ptr< const ns3::Packet >', 'packet')])
     ## packet.h: void ns3::Packet::AddHeader(ns3::Header const & header) [member function]
-    cls.add_method('AddHeader', 'void', [param('ns3::Header&', 'header', is_const=True)])
+    cls.add_method('AddHeader', 
+                   'void', 
+                   [param('ns3::Header&', 'header', is_const=True)])
     ## packet.h: void ns3::Packet::AddPaddingAtEnd(uint32_t size) [member function]
-    cls.add_method('AddPaddingAtEnd', 'void', [param('uint32_t', 'size')])
+    cls.add_method('AddPaddingAtEnd', 
+                   'void', 
+                   [param('uint32_t', 'size')])
     ## packet.h: void ns3::Packet::AddTag(ns3::Tag const & tag) const [member function]
-    cls.add_method('AddTag', 'void', [param('ns3::Tag&', 'tag', is_const=True)], is_const=True)
+    cls.add_method('AddTag', 
+                   'void', 
+                   [param('ns3::Tag&', 'tag', is_const=True)], 
+                   is_const=True)
     ## packet.h: void ns3::Packet::AddTrailer(ns3::Trailer const & trailer) [member function]
-    cls.add_method('AddTrailer', 'void', [param('ns3::Trailer&', 'trailer', is_const=True)])
+    cls.add_method('AddTrailer', 
+                   'void', 
+                   [param('ns3::Trailer&', 'trailer', is_const=True)])
     ## packet.h: ns3::PacketMetadata::ItemIterator ns3::Packet::BeginItem() const [member function]
-    cls.add_method('BeginItem', 'ns3::PacketMetadata::ItemIterator', [], is_const=True)
+    cls.add_method('BeginItem', 
+                   'ns3::PacketMetadata::ItemIterator', 
+                   [], 
+                   is_const=True)
     ## packet.h: ns3::Ptr<ns3::Packet> ns3::Packet::Copy() const [member function]
-    cls.add_method('Copy', 'ns3::Ptr< ns3::Packet >', [], is_const=True)
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::Packet >', 
+                   [], 
+                   is_const=True)
     ## packet.h: ns3::Ptr<ns3::Packet> ns3::Packet::CreateFragment(uint32_t start, uint32_t length) const [member function]
-    cls.add_method('CreateFragment', 'ns3::Ptr< ns3::Packet >', [param('uint32_t', 'start'), param('uint32_t', 'length')], is_const=True)
+    cls.add_method('CreateFragment', 
+                   'ns3::Ptr< ns3::Packet >', 
+                   [param('uint32_t', 'start'), param('uint32_t', 'length')], 
+                   is_const=True)
     ## packet.h: void ns3::Packet::Deserialize(ns3::Buffer buffer) [member function]
-    cls.add_method('Deserialize', 'void', [param('ns3::Buffer', 'buffer')])
+    cls.add_method('Deserialize', 
+                   'void', 
+                   [param('ns3::Buffer', 'buffer')])
     ## packet.h: static void ns3::Packet::EnableMetadata() [member function]
-    cls.add_method('EnableMetadata', 'void', [], is_static=True)
+    cls.add_method('EnableMetadata', 
+                   'void', 
+                   [], 
+                   is_static=True)
     ## packet.h: bool ns3::Packet::FindFirstMatchingTag(ns3::Tag & tag) const [member function]
-    cls.add_method('FindFirstMatchingTag', 'bool', [param('ns3::Tag&', 'tag')], is_const=True)
+    cls.add_method('FindFirstMatchingTag', 
+                   'bool', 
+                   [param('ns3::Tag&', 'tag')], 
+                   is_const=True)
     ## packet.h: uint32_t ns3::Packet::GetSize() const [member function]
-    cls.add_method('GetSize', 'uint32_t', [], is_const=True)
+    cls.add_method('GetSize', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## packet.h: ns3::TagIterator ns3::Packet::GetTagIterator() const [member function]
-    cls.add_method('GetTagIterator', 'ns3::TagIterator', [], is_const=True)
+    cls.add_method('GetTagIterator', 
+                   'ns3::TagIterator', 
+                   [], 
+                   is_const=True)
     ## packet.h: uint32_t ns3::Packet::GetUid() const [member function]
-    cls.add_method('GetUid', 'uint32_t', [], is_const=True)
+    cls.add_method('GetUid', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## packet.h: uint8_t const * ns3::Packet::PeekData() const [member function]
-    cls.add_method('PeekData', retval('uint8_t *', is_const=True, caller_owns_return=False), [], is_const=True)
+    cls.add_method('PeekData', 
+                   retval('uint8_t *', is_const=True, caller_owns_return=False), 
+                   [], 
+                   is_const=True)
     ## packet.h: uint32_t ns3::Packet::PeekHeader(ns3::Header & header) [member function]
-    cls.add_method('PeekHeader', 'uint32_t', [param('ns3::Header&', 'header')])
+    cls.add_method('PeekHeader', 
+                   'uint32_t', 
+                   [param('ns3::Header&', 'header')])
     ## packet.h: uint32_t ns3::Packet::PeekTrailer(ns3::Trailer & trailer) [member function]
-    cls.add_method('PeekTrailer', 'uint32_t', [param('ns3::Trailer&', 'trailer')])
+    cls.add_method('PeekTrailer', 
+                   'uint32_t', 
+                   [param('ns3::Trailer&', 'trailer')])
     ## packet.h: void ns3::Packet::Print(std::ostream & os) const [member function]
-    cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True)
+    cls.add_method('Print', 
+                   'void', 
+                   [param('std::ostream&', 'os')], 
+                   is_const=True)
     ## packet.h: void ns3::Packet::PrintTags(std::ostream & os) const [member function]
-    cls.add_method('PrintTags', 'void', [param('std::ostream&', 'os')], is_const=True)
+    cls.add_method('PrintTags', 
+                   'void', 
+                   [param('std::ostream&', 'os')], 
+                   is_const=True)
     ## packet.h: void ns3::Packet::RemoveAllTags() [member function]
-    cls.add_method('RemoveAllTags', 'void', [])
+    cls.add_method('RemoveAllTags', 
+                   'void', 
+                   [])
     ## packet.h: void ns3::Packet::RemoveAtEnd(uint32_t size) [member function]
-    cls.add_method('RemoveAtEnd', 'void', [param('uint32_t', 'size')])
+    cls.add_method('RemoveAtEnd', 
+                   'void', 
+                   [param('uint32_t', 'size')])
     ## packet.h: void ns3::Packet::RemoveAtStart(uint32_t size) [member function]
-    cls.add_method('RemoveAtStart', 'void', [param('uint32_t', 'size')])
+    cls.add_method('RemoveAtStart', 
+                   'void', 
+                   [param('uint32_t', 'size')])
     ## packet.h: uint32_t ns3::Packet::RemoveHeader(ns3::Header & header) [member function]
-    cls.add_method('RemoveHeader', 'uint32_t', [param('ns3::Header&', 'header')])
+    cls.add_method('RemoveHeader', 
+                   'uint32_t', 
+                   [param('ns3::Header&', 'header')])
     ## packet.h: uint32_t ns3::Packet::RemoveTrailer(ns3::Trailer & trailer) [member function]
-    cls.add_method('RemoveTrailer', 'uint32_t', [param('ns3::Trailer&', 'trailer')])
+    cls.add_method('RemoveTrailer', 
+                   'uint32_t', 
+                   [param('ns3::Trailer&', 'trailer')])
     ## packet.h: ns3::Buffer ns3::Packet::Serialize() const [member function]
-    cls.add_method('Serialize', 'ns3::Buffer', [], is_const=True)
+    cls.add_method('Serialize', 
+                   'ns3::Buffer', 
+                   [], 
+                   is_const=True)
     cls.add_output_stream_operator()
     return
 
 def register_Ns3TagIterator_methods(root_module, cls):
     ## packet.h: bool ns3::TagIterator::HasNext() const [member function]
-    cls.add_method('HasNext', 'bool', [], is_const=True)
+    cls.add_method('HasNext', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## packet.h: ns3::TagIterator::Item ns3::TagIterator::Next() [member function]
-    cls.add_method('Next', 'ns3::TagIterator::Item', [])
+    cls.add_method('Next', 
+                   'ns3::TagIterator::Item', 
+                   [])
     return
 
 def register_Ns3TagIteratorItem_methods(root_module, cls):
     ## packet.h: ns3::TypeId ns3::TagIterator::Item::GetTypeId() const [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_const=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_const=True)
     ## packet.h: uint32_t ns3::TagIterator::Item::GetStart() const [member function]
-    cls.add_method('GetStart', 'uint32_t', [], is_const=True)
+    cls.add_method('GetStart', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## packet.h: uint32_t ns3::TagIterator::Item::GetEnd() const [member function]
-    cls.add_method('GetEnd', 'uint32_t', [], is_const=True)
+    cls.add_method('GetEnd', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## packet.h: void ns3::TagIterator::Item::GetTag(ns3::Tag & tag) const [member function]
-    cls.add_method('GetTag', 'void', [param('ns3::Tag&', 'tag')], is_const=True)
+    cls.add_method('GetTag', 
+                   'void', 
+                   [param('ns3::Tag&', 'tag')], 
+                   is_const=True)
     return
 
 def register_Ns3TagList_methods(root_module, cls):
     ## tag-list.h: ns3::TagList::TagList() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## tag-list.h: ns3::TagList::TagList(ns3::TagList const & o) [copy constructor]
-    cls.add_constructor([param('ns3::TagList&', 'o', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::TagList&', 'o', is_const=True)])
     ## tag-list.h: ns3::TagBuffer ns3::TagList::Add(ns3::TypeId tid, uint32_t bufferSize, int32_t start, int32_t end) [member function]
-    cls.add_method('Add', 'ns3::TagBuffer', [param('ns3::TypeId', 'tid'), param('uint32_t', 'bufferSize'), param('int32_t', 'start'), param('int32_t', 'end')])
+    cls.add_method('Add', 
+                   'ns3::TagBuffer', 
+                   [param('ns3::TypeId', 'tid'), param('uint32_t', 'bufferSize'), param('int32_t', 'start'), param('int32_t', 'end')])
     ## tag-list.h: void ns3::TagList::Add(ns3::TagList const & o) [member function]
-    cls.add_method('Add', 'void', [param('ns3::TagList&', 'o', is_const=True)])
+    cls.add_method('Add', 
+                   'void', 
+                   [param('ns3::TagList&', 'o', is_const=True)])
     ## tag-list.h: void ns3::TagList::RemoveAll() [member function]
-    cls.add_method('RemoveAll', 'void', [])
+    cls.add_method('RemoveAll', 
+                   'void', 
+                   [])
     ## tag-list.h: ns3::TagList::Iterator ns3::TagList::Begin(int32_t offsetStart, int32_t offsetEnd) const [member function]
-    cls.add_method('Begin', 'ns3::TagList::Iterator', [param('int32_t', 'offsetStart'), param('int32_t', 'offsetEnd')], is_const=True)
+    cls.add_method('Begin', 
+                   'ns3::TagList::Iterator', 
+                   [param('int32_t', 'offsetStart'), param('int32_t', 'offsetEnd')], 
+                   is_const=True)
     ## tag-list.h: void ns3::TagList::AddAtEnd(int32_t adjustment, int32_t appendOffset) [member function]
-    cls.add_method('AddAtEnd', 'void', [param('int32_t', 'adjustment'), param('int32_t', 'appendOffset')])
+    cls.add_method('AddAtEnd', 
+                   'void', 
+                   [param('int32_t', 'adjustment'), param('int32_t', 'appendOffset')])
     ## tag-list.h: void ns3::TagList::AddAtStart(int32_t adjustment, int32_t prependOffset) [member function]
-    cls.add_method('AddAtStart', 'void', [param('int32_t', 'adjustment'), param('int32_t', 'prependOffset')])
+    cls.add_method('AddAtStart', 
+                   'void', 
+                   [param('int32_t', 'adjustment'), param('int32_t', 'prependOffset')])
     return
 
 def register_Ns3TagListIterator_methods(root_module, cls):
     ## tag-list.h: bool ns3::TagList::Iterator::HasNext() const [member function]
-    cls.add_method('HasNext', 'bool', [], is_const=True)
+    cls.add_method('HasNext', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## tag-list.h: ns3::TagList::Iterator::Item ns3::TagList::Iterator::Next() [member function]
-    cls.add_method('Next', 'ns3::TagList::Iterator::Item', [])
+    cls.add_method('Next', 
+                   'ns3::TagList::Iterator::Item', 
+                   [])
     ## tag-list.h: uint32_t ns3::TagList::Iterator::GetOffsetStart() const [member function]
-    cls.add_method('GetOffsetStart', 'uint32_t', [], is_const=True)
+    cls.add_method('GetOffsetStart', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     return
 
 def register_Ns3TagListIteratorItem_methods(root_module, cls):
@@ -229,208 +330,384 @@
     ## tag-list.h: ns3::TagList::Iterator::Item::buf [variable]
     cls.add_instance_attribute('buf', 'ns3::TagBuffer', is_const=False)
     ## tag-list.h: ns3::TagList::Iterator::Item::Item(ns3::TagBuffer buf) [constructor]
-    cls.add_constructor([param('ns3::TagBuffer', 'buf')], visibility='public')
+    cls.add_constructor([param('ns3::TagBuffer', 'buf')])
     return
 
 def register_Ns3TagBuffer_methods(root_module, cls):
     ## tag-buffer.h: ns3::TagBuffer::TagBuffer(uint8_t * start, uint8_t * end) [constructor]
-    cls.add_constructor([param('uint8_t *', 'start'), param('uint8_t *', 'end')], visibility='public')
+    cls.add_constructor([param('uint8_t *', 'start'), param('uint8_t *', 'end')])
     ## tag-buffer.h: void ns3::TagBuffer::TrimAtEnd(uint32_t trim) [member function]
-    cls.add_method('TrimAtEnd', 'void', [param('uint32_t', 'trim')])
+    cls.add_method('TrimAtEnd', 
+                   'void', 
+                   [param('uint32_t', 'trim')])
     ## tag-buffer.h: void ns3::TagBuffer::CopyFrom(ns3::TagBuffer o) [member function]
-    cls.add_method('CopyFrom', 'void', [param('ns3::TagBuffer', 'o')])
+    cls.add_method('CopyFrom', 
+                   'void', 
+                   [param('ns3::TagBuffer', 'o')])
     ## tag-buffer.h: void ns3::TagBuffer::WriteU8(uint8_t v) [member function]
-    cls.add_method('WriteU8', 'void', [param('uint8_t', 'v')])
+    cls.add_method('WriteU8', 
+                   'void', 
+                   [param('uint8_t', 'v')])
     ## tag-buffer.h: void ns3::TagBuffer::WriteU16(uint16_t data) [member function]
-    cls.add_method('WriteU16', 'void', [param('uint16_t', 'data')])
+    cls.add_method('WriteU16', 
+                   'void', 
+                   [param('uint16_t', 'data')])
     ## tag-buffer.h: void ns3::TagBuffer::WriteU32(uint32_t data) [member function]
-    cls.add_method('WriteU32', 'void', [param('uint32_t', 'data')])
+    cls.add_method('WriteU32', 
+                   'void', 
+                   [param('uint32_t', 'data')])
     ## tag-buffer.h: void ns3::TagBuffer::WriteU64(uint64_t v) [member function]
-    cls.add_method('WriteU64', 'void', [param('uint64_t', 'v')])
+    cls.add_method('WriteU64', 
+                   'void', 
+                   [param('uint64_t', 'v')])
     ## tag-buffer.h: void ns3::TagBuffer::WriteDouble(double v) [member function]
-    cls.add_method('WriteDouble', 'void', [param('double', 'v')])
+    cls.add_method('WriteDouble', 
+                   'void', 
+                   [param('double', 'v')])
     ## tag-buffer.h: void ns3::TagBuffer::Write(uint8_t const * buffer, uint32_t size) [member function]
-    cls.add_method('Write', 'void', [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint32_t', 'size')])
+    cls.add_method('Write', 
+                   'void', 
+                   [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint32_t', 'size')])
     ## tag-buffer.h: uint8_t ns3::TagBuffer::ReadU8() [member function]
-    cls.add_method('ReadU8', 'uint8_t', [])
+    cls.add_method('ReadU8', 
+                   'uint8_t', 
+                   [])
     ## tag-buffer.h: uint16_t ns3::TagBuffer::ReadU16() [member function]
-    cls.add_method('ReadU16', 'uint16_t', [])
+    cls.add_method('ReadU16', 
+                   'uint16_t', 
+                   [])
     ## tag-buffer.h: uint32_t ns3::TagBuffer::ReadU32() [member function]
-    cls.add_method('ReadU32', 'uint32_t', [])
+    cls.add_method('ReadU32', 
+                   'uint32_t', 
+                   [])
     ## tag-buffer.h: uint64_t ns3::TagBuffer::ReadU64() [member function]
-    cls.add_method('ReadU64', 'uint64_t', [])
+    cls.add_method('ReadU64', 
+                   'uint64_t', 
+                   [])
     ## tag-buffer.h: double ns3::TagBuffer::ReadDouble() [member function]
-    cls.add_method('ReadDouble', 'double', [])
+    cls.add_method('ReadDouble', 
+                   'double', 
+                   [])
     ## tag-buffer.h: void ns3::TagBuffer::Read(uint8_t * buffer, uint32_t size) [member function]
-    cls.add_method('Read', 'void', [param('uint8_t *', 'buffer'), param('uint32_t', 'size')])
+    cls.add_method('Read', 
+                   'void', 
+                   [param('uint8_t *', 'buffer'), param('uint32_t', 'size')])
     return
 
 def register_Ns3Buffer_methods(root_module, cls):
     ## buffer.h: uint32_t ns3::Buffer::GetSize() const [member function]
-    cls.add_method('GetSize', 'uint32_t', [], is_const=True)
+    cls.add_method('GetSize', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## buffer.h: uint8_t const * ns3::Buffer::PeekData() const [member function]
-    cls.add_method('PeekData', retval('uint8_t *', is_const=True, caller_owns_return=False), [], is_const=True)
+    cls.add_method('PeekData', 
+                   retval('uint8_t *', is_const=True, caller_owns_return=False), 
+                   [], 
+                   is_const=True)
     ## buffer.h: bool ns3::Buffer::AddAtStart(uint32_t start) [member function]
-    cls.add_method('AddAtStart', 'bool', [param('uint32_t', 'start')])
+    cls.add_method('AddAtStart', 
+                   'bool', 
+                   [param('uint32_t', 'start')])
     ## buffer.h: bool ns3::Buffer::AddAtEnd(uint32_t end) [member function]
-    cls.add_method('AddAtEnd', 'bool', [param('uint32_t', 'end')])
+    cls.add_method('AddAtEnd', 
+                   'bool', 
+                   [param('uint32_t', 'end')])
     ## buffer.h: void ns3::Buffer::AddAtEnd(ns3::Buffer const & o) [member function]
-    cls.add_method('AddAtEnd', 'void', [param('ns3::Buffer&', 'o', is_const=True)])
+    cls.add_method('AddAtEnd', 
+                   'void', 
+                   [param('ns3::Buffer&', 'o', is_const=True)])
     ## buffer.h: void ns3::Buffer::RemoveAtStart(uint32_t start) [member function]
-    cls.add_method('RemoveAtStart', 'void', [param('uint32_t', 'start')])
+    cls.add_method('RemoveAtStart', 
+                   'void', 
+                   [param('uint32_t', 'start')])
     ## buffer.h: void ns3::Buffer::RemoveAtEnd(uint32_t end) [member function]
-    cls.add_method('RemoveAtEnd', 'void', [param('uint32_t', 'end')])
+    cls.add_method('RemoveAtEnd', 
+                   'void', 
+                   [param('uint32_t', 'end')])
     ## buffer.h: ns3::Buffer ns3::Buffer::CreateFragment(uint32_t start, uint32_t length) const [member function]
-    cls.add_method('CreateFragment', 'ns3::Buffer', [param('uint32_t', 'start'), param('uint32_t', 'length')], is_const=True)
+    cls.add_method('CreateFragment', 
+                   'ns3::Buffer', 
+                   [param('uint32_t', 'start'), param('uint32_t', 'length')], 
+                   is_const=True)
     ## buffer.h: ns3::Buffer::Iterator ns3::Buffer::Begin() const [member function]
-    cls.add_method('Begin', 'ns3::Buffer::Iterator', [], is_const=True)
+    cls.add_method('Begin', 
+                   'ns3::Buffer::Iterator', 
+                   [], 
+                   is_const=True)
     ## buffer.h: ns3::Buffer::Iterator ns3::Buffer::End() const [member function]
-    cls.add_method('End', 'ns3::Buffer::Iterator', [], is_const=True)
+    cls.add_method('End', 
+                   'ns3::Buffer::Iterator', 
+                   [], 
+                   is_const=True)
     ## buffer.h: ns3::Buffer ns3::Buffer::CreateFullCopy() const [member function]
-    cls.add_method('CreateFullCopy', 'ns3::Buffer', [], is_const=True)
+    cls.add_method('CreateFullCopy', 
+                   'ns3::Buffer', 
+                   [], 
+                   is_const=True)
     ## buffer.h: int32_t ns3::Buffer::GetCurrentStartOffset() const [member function]
-    cls.add_method('GetCurrentStartOffset', 'int32_t', [], is_const=True)
+    cls.add_method('GetCurrentStartOffset', 
+                   'int32_t', 
+                   [], 
+                   is_const=True)
     ## buffer.h: int32_t ns3::Buffer::GetCurrentEndOffset() const [member function]
-    cls.add_method('GetCurrentEndOffset', 'int32_t', [], is_const=True)
+    cls.add_method('GetCurrentEndOffset', 
+                   'int32_t', 
+                   [], 
+                   is_const=True)
     ## buffer.h: ns3::Buffer::Buffer(ns3::Buffer const & o) [copy constructor]
-    cls.add_constructor([param('ns3::Buffer&', 'o', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::Buffer&', 'o', is_const=True)])
     ## buffer.h: ns3::Buffer::Buffer() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## buffer.h: ns3::Buffer::Buffer(uint32_t dataSize) [constructor]
-    cls.add_constructor([param('uint32_t', 'dataSize')], visibility='public')
+    cls.add_constructor([param('uint32_t', 'dataSize')])
     return
 
 def register_Ns3BufferIterator_methods(root_module, cls):
     ## buffer.h: ns3::Buffer::Iterator::Iterator() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## buffer.h: void ns3::Buffer::Iterator::Next() [member function]
-    cls.add_method('Next', 'void', [])
+    cls.add_method('Next', 
+                   'void', 
+                   [])
     ## buffer.h: void ns3::Buffer::Iterator::Prev() [member function]
-    cls.add_method('Prev', 'void', [])
+    cls.add_method('Prev', 
+                   'void', 
+                   [])
     ## buffer.h: void ns3::Buffer::Iterator::Next(uint32_t delta) [member function]
-    cls.add_method('Next', 'void', [param('uint32_t', 'delta')])
+    cls.add_method('Next', 
+                   'void', 
+                   [param('uint32_t', 'delta')])
     ## buffer.h: void ns3::Buffer::Iterator::Prev(uint32_t delta) [member function]
-    cls.add_method('Prev', 'void', [param('uint32_t', 'delta')])
+    cls.add_method('Prev', 
+                   'void', 
+                   [param('uint32_t', 'delta')])
     ## buffer.h: uint32_t ns3::Buffer::Iterator::GetDistanceFrom(ns3::Buffer::Iterator const & o) const [member function]
-    cls.add_method('GetDistanceFrom', 'uint32_t', [param('ns3::Buffer::Iterator&', 'o', is_const=True)], is_const=True)
+    cls.add_method('GetDistanceFrom', 
+                   'uint32_t', 
+                   [param('ns3::Buffer::Iterator&', 'o', is_const=True)], 
+                   is_const=True)
     ## buffer.h: bool ns3::Buffer::Iterator::IsEnd() const [member function]
-    cls.add_method('IsEnd', 'bool', [], is_const=True)
+    cls.add_method('IsEnd', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## buffer.h: bool ns3::Buffer::Iterator::IsStart() const [member function]
-    cls.add_method('IsStart', 'bool', [], is_const=True)
+    cls.add_method('IsStart', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## buffer.h: void ns3::Buffer::Iterator::WriteU8(uint8_t data) [member function]
-    cls.add_method('WriteU8', 'void', [param('uint8_t', 'data')])
+    cls.add_method('WriteU8', 
+                   'void', 
+                   [param('uint8_t', 'data')])
     ## buffer.h: void ns3::Buffer::Iterator::WriteU8(uint8_t data, uint32_t len) [member function]
-    cls.add_method('WriteU8', 'void', [param('uint8_t', 'data'), param('uint32_t', 'len')])
+    cls.add_method('WriteU8', 
+                   'void', 
+                   [param('uint8_t', 'data'), param('uint32_t', 'len')])
     ## buffer.h: void ns3::Buffer::Iterator::WriteU16(uint16_t data) [member function]
-    cls.add_method('WriteU16', 'void', [param('uint16_t', 'data')])
+    cls.add_method('WriteU16', 
+                   'void', 
+                   [param('uint16_t', 'data')])
     ## buffer.h: void ns3::Buffer::Iterator::WriteU32(uint32_t data) [member function]
-    cls.add_method('WriteU32', 'void', [param('uint32_t', 'data')])
+    cls.add_method('WriteU32', 
+                   'void', 
+                   [param('uint32_t', 'data')])
     ## buffer.h: void ns3::Buffer::Iterator::WriteU64(uint64_t data) [member function]
-    cls.add_method('WriteU64', 'void', [param('uint64_t', 'data')])
+    cls.add_method('WriteU64', 
+                   'void', 
+                   [param('uint64_t', 'data')])
     ## buffer.h: void ns3::Buffer::Iterator::WriteHtolsbU16(uint16_t data) [member function]
-    cls.add_method('WriteHtolsbU16', 'void', [param('uint16_t', 'data')])
+    cls.add_method('WriteHtolsbU16', 
+                   'void', 
+                   [param('uint16_t', 'data')])
     ## buffer.h: void ns3::Buffer::Iterator::WriteHtolsbU32(uint32_t data) [member function]
-    cls.add_method('WriteHtolsbU32', 'void', [param('uint32_t', 'data')])
+    cls.add_method('WriteHtolsbU32', 
+                   'void', 
+                   [param('uint32_t', 'data')])
     ## buffer.h: void ns3::Buffer::Iterator::WriteHtolsbU64(uint64_t data) [member function]
-    cls.add_method('WriteHtolsbU64', 'void', [param('uint64_t', 'data')])
+    cls.add_method('WriteHtolsbU64', 
+                   'void', 
+                   [param('uint64_t', 'data')])
     ## buffer.h: void ns3::Buffer::Iterator::WriteHtonU16(uint16_t data) [member function]
-    cls.add_method('WriteHtonU16', 'void', [param('uint16_t', 'data')])
+    cls.add_method('WriteHtonU16', 
+                   'void', 
+                   [param('uint16_t', 'data')])
     ## buffer.h: void ns3::Buffer::Iterator::WriteHtonU32(uint32_t data) [member function]
-    cls.add_method('WriteHtonU32', 'void', [param('uint32_t', 'data')])
+    cls.add_method('WriteHtonU32', 
+                   'void', 
+                   [param('uint32_t', 'data')])
     ## buffer.h: void ns3::Buffer::Iterator::WriteHtonU64(uint64_t data) [member function]
-    cls.add_method('WriteHtonU64', 'void', [param('uint64_t', 'data')])
+    cls.add_method('WriteHtonU64', 
+                   'void', 
+                   [param('uint64_t', 'data')])
     ## buffer.h: void ns3::Buffer::Iterator::Write(uint8_t const * buffer, uint32_t size) [member function]
-    cls.add_method('Write', 'void', [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint32_t', 'size')])
+    cls.add_method('Write', 
+                   'void', 
+                   [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint32_t', 'size')])
     ## buffer.h: void ns3::Buffer::Iterator::Write(ns3::Buffer::Iterator start, ns3::Buffer::Iterator end) [member function]
-    cls.add_method('Write', 'void', [param('ns3::Buffer::Iterator', 'start'), param('ns3::Buffer::Iterator', 'end')])
+    cls.add_method('Write', 
+                   'void', 
+                   [param('ns3::Buffer::Iterator', 'start'), param('ns3::Buffer::Iterator', 'end')])
     ## buffer.h: uint8_t ns3::Buffer::Iterator::ReadU8() [member function]
-    cls.add_method('ReadU8', 'uint8_t', [])
+    cls.add_method('ReadU8', 
+                   'uint8_t', 
+                   [])
     ## buffer.h: uint16_t ns3::Buffer::Iterator::ReadU16() [member function]
-    cls.add_method('ReadU16', 'uint16_t', [])
+    cls.add_method('ReadU16', 
+                   'uint16_t', 
+                   [])
     ## buffer.h: uint32_t ns3::Buffer::Iterator::ReadU32() [member function]
-    cls.add_method('ReadU32', 'uint32_t', [])
+    cls.add_method('ReadU32', 
+                   'uint32_t', 
+                   [])
     ## buffer.h: uint64_t ns3::Buffer::Iterator::ReadU64() [member function]
-    cls.add_method('ReadU64', 'uint64_t', [])
+    cls.add_method('ReadU64', 
+                   'uint64_t', 
+                   [])
     ## buffer.h: uint16_t ns3::Buffer::Iterator::ReadNtohU16() [member function]
-    cls.add_method('ReadNtohU16', 'uint16_t', [])
+    cls.add_method('ReadNtohU16', 
+                   'uint16_t', 
+                   [])
     ## buffer.h: uint32_t ns3::Buffer::Iterator::ReadNtohU32() [member function]
-    cls.add_method('ReadNtohU32', 'uint32_t', [])
+    cls.add_method('ReadNtohU32', 
+                   'uint32_t', 
+                   [])
     ## buffer.h: uint64_t ns3::Buffer::Iterator::ReadNtohU64() [member function]
-    cls.add_method('ReadNtohU64', 'uint64_t', [])
+    cls.add_method('ReadNtohU64', 
+                   'uint64_t', 
+                   [])
     ## buffer.h: uint16_t ns3::Buffer::Iterator::ReadLsbtohU16() [member function]
-    cls.add_method('ReadLsbtohU16', 'uint16_t', [])
+    cls.add_method('ReadLsbtohU16', 
+                   'uint16_t', 
+                   [])
     ## buffer.h: uint32_t ns3::Buffer::Iterator::ReadLsbtohU32() [member function]
-    cls.add_method('ReadLsbtohU32', 'uint32_t', [])
+    cls.add_method('ReadLsbtohU32', 
+                   'uint32_t', 
+                   [])
     ## buffer.h: uint64_t ns3::Buffer::Iterator::ReadLsbtohU64() [member function]
-    cls.add_method('ReadLsbtohU64', 'uint64_t', [])
+    cls.add_method('ReadLsbtohU64', 
+                   'uint64_t', 
+                   [])
     ## buffer.h: void ns3::Buffer::Iterator::Read(uint8_t * buffer, uint32_t size) [member function]
-    cls.add_method('Read', 'void', [param('uint8_t *', 'buffer'), param('uint32_t', 'size')])
+    cls.add_method('Read', 
+                   'void', 
+                   [param('uint8_t *', 'buffer'), param('uint32_t', 'size')])
     ## buffer.h: uint16_t ns3::Buffer::Iterator::CalculateIpChecksum(uint16_t size) [member function]
-    cls.add_method('CalculateIpChecksum', 'uint16_t', [param('uint16_t', 'size')])
+    cls.add_method('CalculateIpChecksum', 
+                   'uint16_t', 
+                   [param('uint16_t', 'size')])
     ## buffer.h: uint16_t ns3::Buffer::Iterator::CalculateIpChecksum(uint16_t size, uint32_t initialChecksum) [member function]
-    cls.add_method('CalculateIpChecksum', 'uint16_t', [param('uint16_t', 'size'), param('uint32_t', 'initialChecksum')])
+    cls.add_method('CalculateIpChecksum', 
+                   'uint16_t', 
+                   [param('uint16_t', 'size'), param('uint32_t', 'initialChecksum')])
     ## buffer.h: uint32_t ns3::Buffer::Iterator::GetSize() const [member function]
-    cls.add_method('GetSize', 'uint32_t', [], is_const=True)
+    cls.add_method('GetSize', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     return
 
 def register_Ns3Chunk_methods(root_module, cls):
     ## chunk.h: ns3::Chunk::Chunk() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## chunk.h: ns3::Chunk::Chunk(ns3::Chunk const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Chunk&', 'arg0', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::Chunk&', 'arg0', is_const=True)])
     ## chunk.h: static ns3::TypeId ns3::Chunk::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## chunk.h: uint32_t ns3::Chunk::Deserialize(ns3::Buffer::Iterator start) [member function]
-    cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'start')], is_pure_virtual=True, is_virtual=True)
+    cls.add_method('Deserialize', 
+                   'uint32_t', 
+                   [param('ns3::Buffer::Iterator', 'start')], 
+                   is_pure_virtual=True, is_virtual=True)
     ## chunk.h: void ns3::Chunk::Print(std::ostream & os) const [member function]
-    cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('Print', 
+                   'void', 
+                   [param('std::ostream&', 'os')], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     return
 
 def register_Ns3DataRate_methods(root_module, cls):
     ## data-rate.h: ns3::DataRate::DataRate(ns3::DataRate const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::DataRate&', 'arg0', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::DataRate&', 'arg0', is_const=True)])
     ## data-rate.h: ns3::DataRate::DataRate() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## data-rate.h: ns3::DataRate::DataRate(uint64_t bps) [constructor]
-    cls.add_constructor([param('uint64_t', 'bps')], visibility='public')
+    cls.add_constructor([param('uint64_t', 'bps')])
     ## data-rate.h: ns3::DataRate::DataRate(std::string rate) [constructor]
-    cls.add_constructor([param('std::string', 'rate')], visibility='public')
+    cls.add_constructor([param('std::string', 'rate')])
     ## data-rate.h: double ns3::DataRate::CalculateTxTime(uint32_t bytes) const [member function]
-    cls.add_method('CalculateTxTime', 'double', [param('uint32_t', 'bytes')], is_const=True)
+    cls.add_method('CalculateTxTime', 
+                   'double', 
+                   [param('uint32_t', 'bytes')], 
+                   is_const=True)
     ## data-rate.h: uint64_t ns3::DataRate::GetBitRate() const [member function]
-    cls.add_method('GetBitRate', 'uint64_t', [], is_const=True)
+    cls.add_method('GetBitRate', 
+                   'uint64_t', 
+                   [], 
+                   is_const=True)
     cls.add_output_stream_operator()
     return
 
 def register_Ns3Tag_methods(root_module, cls):
     ## tag.h: static ns3::TypeId ns3::Tag::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## tag.h: uint32_t ns3::Tag::GetSerializedSize() const [member function]
-    cls.add_method('GetSerializedSize', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('GetSerializedSize', 
+                   'uint32_t', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     ## tag.h: void ns3::Tag::Serialize(ns3::TagBuffer i) const [member function]
-    cls.add_method('Serialize', 'void', [param('ns3::TagBuffer', 'i')], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('Serialize', 
+                   'void', 
+                   [param('ns3::TagBuffer', 'i')], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     ## tag.h: void ns3::Tag::Deserialize(ns3::TagBuffer i) [member function]
-    cls.add_method('Deserialize', 'void', [param('ns3::TagBuffer', 'i')], is_pure_virtual=True, is_virtual=True)
+    cls.add_method('Deserialize', 
+                   'void', 
+                   [param('ns3::TagBuffer', 'i')], 
+                   is_pure_virtual=True, is_virtual=True)
     ## tag.h: void ns3::Tag::Print(std::ostream & os) const [member function]
-    cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('Print', 
+                   'void', 
+                   [param('std::ostream&', 'os')], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     cls.add_constructor([])
     return
 
 def register_Ns3PcapWriter_methods(root_module, cls):
     ## pcap-writer.h: ns3::PcapWriter::PcapWriter() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## pcap-writer.h: void ns3::PcapWriter::Open(std::string const & name) [member function]
-    cls.add_method('Open', 'void', [param('std::string&', 'name', is_const=True)])
+    cls.add_method('Open', 
+                   'void', 
+                   [param('std::string&', 'name', is_const=True)])
     ## pcap-writer.h: void ns3::PcapWriter::WriteEthernetHeader() [member function]
-    cls.add_method('WriteEthernetHeader', 'void', [])
+    cls.add_method('WriteEthernetHeader', 
+                   'void', 
+                   [])
     ## pcap-writer.h: void ns3::PcapWriter::WriteIpHeader() [member function]
-    cls.add_method('WriteIpHeader', 'void', [])
+    cls.add_method('WriteIpHeader', 
+                   'void', 
+                   [])
     ## pcap-writer.h: void ns3::PcapWriter::WriteWifiHeader() [member function]
-    cls.add_method('WriteWifiHeader', 'void', [])
+    cls.add_method('WriteWifiHeader', 
+                   'void', 
+                   [])
     ## pcap-writer.h: void ns3::PcapWriter::WritePppHeader() [member function]
-    cls.add_method('WritePppHeader', 'void', [])
+    cls.add_method('WritePppHeader', 
+                   'void', 
+                   [])
     ## pcap-writer.h: void ns3::PcapWriter::WritePacket(ns3::Ptr<const ns3::Packet> packet) [member function]
-    cls.add_method('WritePacket', 'void', [param('ns3::Ptr< const ns3::Packet >', 'packet')])
+    cls.add_method('WritePacket', 
+                   'void', 
+                   [param('ns3::Ptr< const ns3::Packet >', 'packet')])
     return
 
 def register_Ns3DataRateChecker_methods(root_module, cls):
@@ -439,124 +716,234 @@
 
 def register_Ns3ErrorModel_methods(root_module, cls):
     ## error-model.h: static ns3::TypeId ns3::ErrorModel::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## error-model.h: ns3::ErrorModel::ErrorModel() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## error-model.h: bool ns3::ErrorModel::IsCorrupt(ns3::Ptr<ns3::Packet> pkt) [member function]
-    cls.add_method('IsCorrupt', 'bool', [param('ns3::Ptr< ns3::Packet >', 'pkt')])
+    cls.add_method('IsCorrupt', 
+                   'bool', 
+                   [param('ns3::Ptr< ns3::Packet >', 'pkt')])
     ## error-model.h: void ns3::ErrorModel::Reset() [member function]
-    cls.add_method('Reset', 'void', [])
+    cls.add_method('Reset', 
+                   'void', 
+                   [])
     ## error-model.h: void ns3::ErrorModel::Enable() [member function]
-    cls.add_method('Enable', 'void', [])
+    cls.add_method('Enable', 
+                   'void', 
+                   [])
     ## error-model.h: void ns3::ErrorModel::Disable() [member function]
-    cls.add_method('Disable', 'void', [])
+    cls.add_method('Disable', 
+                   'void', 
+                   [])
     ## error-model.h: bool ns3::ErrorModel::IsEnabled() const [member function]
-    cls.add_method('IsEnabled', 'bool', [], is_const=True)
+    cls.add_method('IsEnabled', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## error-model.h: bool ns3::ErrorModel::DoCorrupt(ns3::Ptr<ns3::Packet> arg0) [member function]
-    cls.add_method('DoCorrupt', 'bool', [param('ns3::Ptr< ns3::Packet >', 'arg0')], is_pure_virtual=True, visibility='private', is_virtual=True)
+    cls.add_method('DoCorrupt', 
+                   'bool', 
+                   [param('ns3::Ptr< ns3::Packet >', 'arg0')], 
+                   is_pure_virtual=True, visibility='private', is_virtual=True)
     ## error-model.h: void ns3::ErrorModel::DoReset() [member function]
-    cls.add_method('DoReset', 'void', [], is_pure_virtual=True, visibility='private', is_virtual=True)
+    cls.add_method('DoReset', 
+                   'void', 
+                   [], 
+                   is_pure_virtual=True, visibility='private', is_virtual=True)
     return
 
 def register_Ns3Header_methods(root_module, cls):
     ## header.h: ns3::Header::Header() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## header.h: ns3::Header::Header(ns3::Header const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Header&', 'arg0', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::Header&', 'arg0', is_const=True)])
     ## header.h: uint32_t ns3::Header::Deserialize(ns3::Buffer::Iterator start) [member function]
-    cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'start')], is_pure_virtual=True, is_virtual=True)
+    cls.add_method('Deserialize', 
+                   'uint32_t', 
+                   [param('ns3::Buffer::Iterator', 'start')], 
+                   is_pure_virtual=True, is_virtual=True)
     ## header.h: uint32_t ns3::Header::GetSerializedSize() const [member function]
-    cls.add_method('GetSerializedSize', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('GetSerializedSize', 
+                   'uint32_t', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     ## header.h: static ns3::TypeId ns3::Header::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## header.h: void ns3::Header::Print(std::ostream & os) const [member function]
-    cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('Print', 
+                   'void', 
+                   [param('std::ostream&', 'os')], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     ## header.h: void ns3::Header::Serialize(ns3::Buffer::Iterator start) const [member function]
-    cls.add_method('Serialize', 'void', [param('ns3::Buffer::Iterator', 'start')], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('Serialize', 
+                   'void', 
+                   [param('ns3::Buffer::Iterator', 'start')], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     cls.add_output_stream_operator()
     return
 
 def register_Ns3Trailer_methods(root_module, cls):
     ## trailer.h: ns3::Trailer::Trailer() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## trailer.h: ns3::Trailer::Trailer(ns3::Trailer const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Trailer&', 'arg0', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::Trailer&', 'arg0', is_const=True)])
     ## trailer.h: uint32_t ns3::Trailer::Deserialize(ns3::Buffer::Iterator end) [member function]
-    cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'end')], is_pure_virtual=True, is_virtual=True)
+    cls.add_method('Deserialize', 
+                   'uint32_t', 
+                   [param('ns3::Buffer::Iterator', 'end')], 
+                   is_pure_virtual=True, is_virtual=True)
     ## trailer.h: uint32_t ns3::Trailer::GetSerializedSize() const [member function]
-    cls.add_method('GetSerializedSize', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('GetSerializedSize', 
+                   'uint32_t', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     ## trailer.h: static ns3::TypeId ns3::Trailer::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## trailer.h: void ns3::Trailer::Print(std::ostream & os) const [member function]
-    cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('Print', 
+                   'void', 
+                   [param('std::ostream&', 'os')], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     ## trailer.h: void ns3::Trailer::Serialize(ns3::Buffer::Iterator start) const [member function]
-    cls.add_method('Serialize', 'void', [param('ns3::Buffer::Iterator', 'start')], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('Serialize', 
+                   'void', 
+                   [param('ns3::Buffer::Iterator', 'start')], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     cls.add_output_stream_operator()
     return
 
 def register_Ns3ListErrorModel_methods(root_module, cls):
     ## error-model.h: static ns3::TypeId ns3::ListErrorModel::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## error-model.h: ns3::ListErrorModel::ListErrorModel() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## error-model.h: std::list<unsigned int, std::allocator<unsigned int> > ns3::ListErrorModel::GetList() const [member function]
-    cls.add_method('GetList', 'std::list< unsigned int, std::allocator< unsigned int > >', [], is_const=True)
+    cls.add_method('GetList', 
+                   'std::list< unsigned int, std::allocator< unsigned int > >', 
+                   [], 
+                   is_const=True)
     ## error-model.h: void ns3::ListErrorModel::SetList(std::list<unsigned int, std::allocator<unsigned int> > const & packetlist) [member function]
-    cls.add_method('SetList', 'void', [param('std::list< unsigned int, std::allocator< unsigned int > >&', 'packetlist', is_const=True)])
+    cls.add_method('SetList', 
+                   'void', 
+                   [param('std::list< unsigned int, std::allocator< unsigned int > >&', 'packetlist', is_const=True)])
     ## error-model.h: bool ns3::ListErrorModel::DoCorrupt(ns3::Ptr<ns3::Packet> p) [member function]
-    cls.add_method('DoCorrupt', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p')], visibility='private', is_virtual=True)
+    cls.add_method('DoCorrupt', 
+                   'bool', 
+                   [param('ns3::Ptr< ns3::Packet >', 'p')], 
+                   visibility='private', is_virtual=True)
     ## error-model.h: void ns3::ListErrorModel::DoReset() [member function]
-    cls.add_method('DoReset', 'void', [], visibility='private', is_virtual=True)
+    cls.add_method('DoReset', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
     return
 
 def register_Ns3DataRateValue_methods(root_module, cls):
     ## data-rate.h: ns3::DataRateValue::DataRateValue() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## data-rate.h: ns3::DataRateValue::DataRateValue(ns3::DataRate const & value) [constructor]
-    cls.add_constructor([param('ns3::DataRate&', 'value', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::DataRate&', 'value', is_const=True)])
     ## data-rate.h: void ns3::DataRateValue::Set(ns3::DataRate const & value) [member function]
-    cls.add_method('Set', 'void', [param('ns3::DataRate&', 'value', is_const=True)])
+    cls.add_method('Set', 
+                   'void', 
+                   [param('ns3::DataRate&', 'value', is_const=True)])
     ## data-rate.h: ns3::DataRate ns3::DataRateValue::Get() const [member function]
-    cls.add_method('Get', 'ns3::DataRate', [], is_const=True)
+    cls.add_method('Get', 
+                   'ns3::DataRate', 
+                   [], 
+                   is_const=True)
     ## data-rate.h: ns3::Ptr<ns3::AttributeValue> ns3::DataRateValue::Copy() const [member function]
-    cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## data-rate.h: std::string ns3::DataRateValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
-    cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True)
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, is_virtual=True)
     ## data-rate.h: bool ns3::DataRateValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
-    cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True)
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_virtual=True)
     return
 
 def register_Ns3RateErrorModel_methods(root_module, cls):
     ## error-model.h: static ns3::TypeId ns3::RateErrorModel::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## error-model.h: ns3::RateErrorModel::RateErrorModel() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## error-model.h: ns3::ErrorUnit ns3::RateErrorModel::GetUnit() const [member function]
-    cls.add_method('GetUnit', 'ns3::ErrorUnit', [], is_const=True)
+    cls.add_method('GetUnit', 
+                   'ns3::ErrorUnit', 
+                   [], 
+                   is_const=True)
     ## error-model.h: void ns3::RateErrorModel::SetUnit(ns3::ErrorUnit error_unit) [member function]
-    cls.add_method('SetUnit', 'void', [param('ns3::ErrorUnit', 'error_unit')])
+    cls.add_method('SetUnit', 
+                   'void', 
+                   [param('ns3::ErrorUnit', 'error_unit')])
     ## error-model.h: double ns3::RateErrorModel::GetRate() const [member function]
-    cls.add_method('GetRate', 'double', [], is_const=True)
+    cls.add_method('GetRate', 
+                   'double', 
+                   [], 
+                   is_const=True)
     ## error-model.h: void ns3::RateErrorModel::SetRate(double rate) [member function]
-    cls.add_method('SetRate', 'void', [param('double', 'rate')])
+    cls.add_method('SetRate', 
+                   'void', 
+                   [param('double', 'rate')])
     ## error-model.h: void ns3::RateErrorModel::SetRandomVariable(ns3::RandomVariable const & ranvar) [member function]
-    cls.add_method('SetRandomVariable', 'void', [param('ns3::RandomVariable&', 'ranvar', is_const=True)])
+    cls.add_method('SetRandomVariable', 
+                   'void', 
+                   [param('ns3::RandomVariable&', 'ranvar', is_const=True)])
     ## error-model.h: bool ns3::RateErrorModel::DoCorrupt(ns3::Ptr<ns3::Packet> p) [member function]
-    cls.add_method('DoCorrupt', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p')], visibility='private', is_virtual=True)
+    cls.add_method('DoCorrupt', 
+                   'bool', 
+                   [param('ns3::Ptr< ns3::Packet >', 'p')], 
+                   visibility='private', is_virtual=True)
     ## error-model.h: bool ns3::RateErrorModel::DoCorruptPkt(ns3::Ptr<ns3::Packet> p) [member function]
-    cls.add_method('DoCorruptPkt', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p')], visibility='private', is_virtual=True)
+    cls.add_method('DoCorruptPkt', 
+                   'bool', 
+                   [param('ns3::Ptr< ns3::Packet >', 'p')], 
+                   visibility='private', is_virtual=True)
     ## error-model.h: bool ns3::RateErrorModel::DoCorruptByte(ns3::Ptr<ns3::Packet> p) [member function]
-    cls.add_method('DoCorruptByte', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p')], visibility='private', is_virtual=True)
+    cls.add_method('DoCorruptByte', 
+                   'bool', 
+                   [param('ns3::Ptr< ns3::Packet >', 'p')], 
+                   visibility='private', is_virtual=True)
     ## error-model.h: bool ns3::RateErrorModel::DoCorruptBit(ns3::Ptr<ns3::Packet> p) [member function]
-    cls.add_method('DoCorruptBit', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p')], visibility='private', is_virtual=True)
+    cls.add_method('DoCorruptBit', 
+                   'bool', 
+                   [param('ns3::Ptr< ns3::Packet >', 'p')], 
+                   visibility='private', is_virtual=True)
     ## error-model.h: void ns3::RateErrorModel::DoReset() [member function]
-    cls.add_method('DoReset', 'void', [], visibility='private', is_virtual=True)
+    cls.add_method('DoReset', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
     return
 
 def register_functions(root_module):
     module = root_module
     ## data-rate.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeDataRateChecker() [free function]
-    module.add_function('MakeDataRateChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [])
+    module.add_function('MakeDataRateChecker', 
+                        'ns3::Ptr< ns3::AttributeChecker const >', 
+                        [])
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
--- a/bindings/python/ns3_module_contrib.py	Fri Jul 18 21:59:43 2008 -0700
+++ b/bindings/python/ns3_module_contrib.py	Mon Jul 21 15:53:03 2008 -0700
@@ -1,4 +1,4 @@
-from pybindgen import Module, FileCodeSink, write_preamble, param, retval
+from pybindgen import Module, FileCodeSink, param, retval, cppclass
 
 def register_types(module):
     root_module = module.get_root()
@@ -16,7 +16,7 @@
     ## gtk-config-store.h: ns3::GtkConfigStore [class]
     module.add_class('GtkConfigStore')
     ## config-store.h: ns3::ConfigStore [class]
-    module.add_class('ConfigStore', allow_subclassing=True, parent=root_module['ns3::ObjectBase'])
+    module.add_class('ConfigStore', parent=root_module['ns3::ObjectBase'])
     ## delay-jitter-estimation.h: ns3::DelayJitterEstimation [class]
     module.add_class('DelayJitterEstimation')
     
@@ -71,66 +71,103 @@
 
 def register_Ns3Gnuplot_methods(root_module, cls):
     ## gnuplot.h: ns3::Gnuplot::Gnuplot(std::string pngFilename) [constructor]
-    cls.add_constructor([param('std::string', 'pngFilename')], visibility='public')
+    cls.add_constructor([param('std::string', 'pngFilename')])
     ## gnuplot.h: void ns3::Gnuplot::SetLegend(std::string xLegend, std::string yLegend) [member function]
-    cls.add_method('SetLegend', 'void', [param('std::string', 'xLegend'), param('std::string', 'yLegend')])
+    cls.add_method('SetLegend', 
+                   'void', 
+                   [param('std::string', 'xLegend'), param('std::string', 'yLegend')])
     ## gnuplot.h: void ns3::Gnuplot::AddDataset(ns3::GnuplotDataset const & dataset) [member function]
-    cls.add_method('AddDataset', 'void', [param('ns3::GnuplotDataset&', 'dataset', is_const=True)])
+    cls.add_method('AddDataset', 
+                   'void', 
+                   [param('ns3::GnuplotDataset&', 'dataset', is_const=True)])
     ## gnuplot.h: void ns3::Gnuplot::GenerateOutput(std::ostream & os) [member function]
-    cls.add_method('GenerateOutput', 'void', [param('std::ostream&', 'os')])
+    cls.add_method('GenerateOutput', 
+                   'void', 
+                   [param('std::ostream&', 'os')])
     return
 
 def register_Ns3EventGarbageCollector_methods(root_module, cls):
     ## event-garbage-collector.h: ns3::EventGarbageCollector::EventGarbageCollector() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## event-garbage-collector.h: void ns3::EventGarbageCollector::Track(ns3::EventId event) [member function]
-    cls.add_method('Track', 'void', [param('ns3::EventId', 'event')])
+    cls.add_method('Track', 
+                   'void', 
+                   [param('ns3::EventId', 'event')])
     return
 
 def register_Ns3GnuplotDataset_methods(root_module, cls):
     ## gnuplot.h: ns3::GnuplotDataset::GnuplotDataset() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## gnuplot.h: ns3::GnuplotDataset::GnuplotDataset(std::string title) [constructor]
-    cls.add_constructor([param('std::string', 'title')], visibility='public')
+    cls.add_constructor([param('std::string', 'title')])
     ## gnuplot.h: void ns3::GnuplotDataset::SetStyle(ns3::GnuplotDataset::Style style) [member function]
-    cls.add_method('SetStyle', 'void', [param('ns3::GnuplotDataset::Style', 'style')])
+    cls.add_method('SetStyle', 
+                   'void', 
+                   [param('ns3::GnuplotDataset::Style', 'style')])
     ## gnuplot.h: void ns3::GnuplotDataset::SetErrorBars(ns3::GnuplotDataset::ErrorBars errorBars) [member function]
-    cls.add_method('SetErrorBars', 'void', [param('ns3::GnuplotDataset::ErrorBars', 'errorBars')])
+    cls.add_method('SetErrorBars', 
+                   'void', 
+                   [param('ns3::GnuplotDataset::ErrorBars', 'errorBars')])
     ## gnuplot.h: void ns3::GnuplotDataset::Add(double x, double y) [member function]
-    cls.add_method('Add', 'void', [param('double', 'x'), param('double', 'y')])
+    cls.add_method('Add', 
+                   'void', 
+                   [param('double', 'x'), param('double', 'y')])
     ## gnuplot.h: void ns3::GnuplotDataset::Add(double x, double y, double errorDelta) [member function]
-    cls.add_method('Add', 'void', [param('double', 'x'), param('double', 'y'), param('double', 'errorDelta')])
+    cls.add_method('Add', 
+                   'void', 
+                   [param('double', 'x'), param('double', 'y'), param('double', 'errorDelta')])
     return
 
 def register_Ns3GtkConfigStore_methods(root_module, cls):
     ## gtk-config-store.h: ns3::GtkConfigStore::GtkConfigStore() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## gtk-config-store.h: void ns3::GtkConfigStore::Configure() [member function]
-    cls.add_method('Configure', 'void', [])
+    cls.add_method('Configure', 
+                   'void', 
+                   [])
     return
 
 def register_Ns3ConfigStore_methods(root_module, cls):
     ## config-store.h: static ns3::TypeId ns3::ConfigStore::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## config-store.h: ns3::TypeId ns3::ConfigStore::GetInstanceTypeId() const [member function]
-    cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True)
+    cls.add_method('GetInstanceTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## config-store.h: ns3::ConfigStore::ConfigStore() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## config-store.h: void ns3::ConfigStore::Configure() [member function]
-    cls.add_method('Configure', 'void', [])
+    cls.add_method('Configure', 
+                   'void', 
+                   [])
     return
 
 def register_Ns3DelayJitterEstimation_methods(root_module, cls):
     ## delay-jitter-estimation.h: ns3::DelayJitterEstimation::DelayJitterEstimation() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## delay-jitter-estimation.h: static void ns3::DelayJitterEstimation::PrepareTx(ns3::Ptr<const ns3::Packet> packet) [member function]
-    cls.add_method('PrepareTx', 'void', [param('ns3::Ptr< const ns3::Packet >', 'packet')], is_static=True)
+    cls.add_method('PrepareTx', 
+                   'void', 
+                   [param('ns3::Ptr< const ns3::Packet >', 'packet')], 
+                   is_static=True)
     ## delay-jitter-estimation.h: void ns3::DelayJitterEstimation::RecordRx(ns3::Ptr<const ns3::Packet> packet) [member function]
-    cls.add_method('RecordRx', 'void', [param('ns3::Ptr< const ns3::Packet >', 'packet')])
+    cls.add_method('RecordRx', 
+                   'void', 
+                   [param('ns3::Ptr< const ns3::Packet >', 'packet')])
     ## delay-jitter-estimation.h: ns3::Time ns3::DelayJitterEstimation::GetLastDelay() const [member function]
-    cls.add_method('GetLastDelay', 'ns3::Time', [], is_const=True)
+    cls.add_method('GetLastDelay', 
+                   'ns3::Time', 
+                   [], 
+                   is_const=True)
     ## delay-jitter-estimation.h: ns3::Time ns3::DelayJitterEstimation::GetLastJitter() const [member function]
-    cls.add_method('GetLastJitter', 'ns3::Time', [], is_const=True)
+    cls.add_method('GetLastJitter', 
+                   'ns3::Time', 
+                   [], 
+                   is_const=True)
     return
 
 def register_functions(root_module):
--- a/bindings/python/ns3_module_core.py	Fri Jul 18 21:59:43 2008 -0700
+++ b/bindings/python/ns3_module_core.py	Mon Jul 21 15:53:03 2008 -0700
@@ -1,4 +1,4 @@
-from pybindgen import Module, FileCodeSink, write_preamble, param, retval
+from pybindgen import Module, FileCodeSink, param, retval, cppclass
 
 def register_types(module):
     root_module = module.get_root()
@@ -10,7 +10,7 @@
     ## global-value.h: ns3::GlobalValue [class]
     module.add_class('GlobalValue')
     ## ref-count-base.h: ns3::RefCountBase [class]
-    module.add_class('RefCountBase', incref_method='Ref', automatic_type_narrowing=True, decref_method='Unref', peekref_method='GetReferenceCount')
+    module.add_class('RefCountBase', automatic_type_narrowing=True, memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
     ## type-id.h: ns3::TypeId [class]
     module.add_class('TypeId')
     ## type-id.h: ns3::TypeId::AttributeFlag [enumeration]
@@ -20,27 +20,33 @@
     ## system-wall-clock-ms.h: ns3::SystemWallClockMs [class]
     module.add_class('SystemWallClockMs')
     ## callback.h: ns3::CallbackImplBase [class]
-    module.add_class('CallbackImplBase', incref_method='Ref', allow_subclassing=True, decref_method='Unref', peekref_method='GetReferenceCount')
+    module.add_class('CallbackImplBase', allow_subclassing=True, memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
+    ## system-mutex.h: ns3::CriticalSection [class]
+    module.add_class('CriticalSection')
     ## trace-source-accessor.h: ns3::TraceSourceAccessor [class]
     module.add_class('TraceSourceAccessor', allow_subclassing=True)
     ## attribute.h: ns3::AttributeChecker [class]
-    module.add_class('AttributeChecker', incref_method='Ref', allow_subclassing=False, automatic_type_narrowing=True, decref_method='Unref', parent=root_module['ns3::RefCountBase'])
+    module.add_class('AttributeChecker', allow_subclassing=False, automatic_type_narrowing=True, parent=root_module['ns3::RefCountBase'])
     ## random-variable.h: ns3::RandomVariableChecker [class]
     module.add_class('RandomVariableChecker', parent=root_module['ns3::AttributeChecker'])
+    ## system-mutex.h: ns3::SystemMutex [class]
+    module.add_class('SystemMutex')
     ## random-variable.h: ns3::NormalVariable [class]
     module.add_class('NormalVariable', parent=root_module['ns3::RandomVariable'])
     ## object-factory.h: ns3::ObjectFactory [class]
     module.add_class('ObjectFactory')
     ## attribute.h: ns3::AttributeAccessor [class]
-    module.add_class('AttributeAccessor', allow_subclassing=True, parent=root_module['ns3::RefCountBase'])
+    module.add_class('AttributeAccessor', parent=root_module['ns3::RefCountBase'])
     ## random-variable.h: ns3::ParetoVariable [class]
     module.add_class('ParetoVariable', parent=root_module['ns3::RandomVariable'])
     ## random-variable.h: ns3::ConstantVariable [class]
     module.add_class('ConstantVariable', parent=root_module['ns3::RandomVariable'])
+    ## system-thread.h: ns3::SystemThread [class]
+    module.add_class('SystemThread')
     ## random-variable.h: ns3::EmpiricalVariable [class]
     module.add_class('EmpiricalVariable', parent=root_module['ns3::RandomVariable'])
     ## enum.h: ns3::EnumChecker [class]
-    module.add_class('EnumChecker', allow_subclassing=True, parent=root_module['ns3::AttributeChecker'])
+    module.add_class('EnumChecker', parent=root_module['ns3::AttributeChecker'])
     ## empty.h: ns3::empty [class]
     module.add_class('empty')
     ## object-base.h: ns3::ObjectBase [class]
@@ -82,7 +88,7 @@
     ## random-variable.h: ns3::IntEmpiricalVariable [class]
     module.add_class('IntEmpiricalVariable', parent=root_module['ns3::EmpiricalVariable'])
     ## pointer.h: ns3::PointerChecker [class]
-    module.add_class('PointerChecker', allow_subclassing=True, parent=root_module['ns3::AttributeChecker'])
+    module.add_class('PointerChecker', parent=root_module['ns3::AttributeChecker'])
     ## random-variable.h: ns3::WeibullVariable [class]
     module.add_class('WeibullVariable', parent=root_module['ns3::RandomVariable'])
     ## callback.h: ns3::CallbackBase [class]
@@ -114,51 +120,53 @@
     ## attribute-list.h: ns3::AttributeList [class]
     module.add_class('AttributeList')
     ## attribute.h: ns3::AttributeValue [class]
-    module.add_class('AttributeValue', incref_method='Ref', allow_subclassing=False, automatic_type_narrowing=True, decref_method='Unref', parent=root_module['ns3::RefCountBase'])
+    module.add_class('AttributeValue', allow_subclassing=False, automatic_type_narrowing=True, parent=root_module['ns3::RefCountBase'])
     ## random-variable.h: ns3::UniformVariable [class]
     module.add_class('UniformVariable', parent=root_module['ns3::RandomVariable'])
     ## object.h: ns3::Object [class]
-    module.add_class('Object', peekref_method='GetReferenceCount', parent=root_module['ns3::ObjectBase'], incref_method='Ref', decref_method='Unref', allow_subclassing=True, automatic_type_narrowing=True)
+    module.add_class('Object', automatic_type_narrowing=True, parent=root_module['ns3::ObjectBase'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
     ## object.h: ns3::Object::AggregateIterator [class]
     module.add_class('AggregateIterator', outer_class=root_module['ns3::Object'])
+    ## system-condition.h: ns3::SystemCondition [class]
+    module.add_class('SystemCondition')
     ## random-variable.h: ns3::SequentialVariable [class]
     module.add_class('SequentialVariable', parent=root_module['ns3::RandomVariable'])
     ## object-vector.h: ns3::ObjectVectorChecker [class]
-    module.add_class('ObjectVectorChecker', allow_subclassing=True, parent=root_module['ns3::AttributeChecker'])
+    module.add_class('ObjectVectorChecker', parent=root_module['ns3::AttributeChecker'])
     ## string.h: ns3::StringChecker [class]
     module.add_class('StringChecker', parent=root_module['ns3::AttributeChecker'])
     ## object-vector.h: ns3::ObjectVectorValue [class]
-    module.add_class('ObjectVectorValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue'])
+    module.add_class('ObjectVectorValue', parent=root_module['ns3::AttributeValue'])
     ## boolean.h: ns3::BooleanChecker [class]
     module.add_class('BooleanChecker', parent=root_module['ns3::AttributeChecker'])
     ## uinteger.h: ns3::UintegerValue [class]
-    module.add_class('UintegerValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue'])
+    module.add_class('UintegerValue', parent=root_module['ns3::AttributeValue'])
     ## object-vector.h: ns3::ObjectVectorAccessor [class]
-    module.add_class('ObjectVectorAccessor', allow_subclassing=True, parent=root_module['ns3::AttributeAccessor'])
+    module.add_class('ObjectVectorAccessor', parent=root_module['ns3::AttributeAccessor'])
     ## pointer.h: ns3::PointerValue [class]
-    module.add_class('PointerValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue'])
+    module.add_class('PointerValue', parent=root_module['ns3::AttributeValue'])
     ## object-factory.h: ns3::ObjectFactoryChecker [class]
     module.add_class('ObjectFactoryChecker', parent=root_module['ns3::AttributeChecker'])
     ## type-id.h: ns3::TypeIdChecker [class]
     module.add_class('TypeIdChecker', parent=root_module['ns3::AttributeChecker'])
     ## double.h: ns3::DoubleValue [class]
-    module.add_class('DoubleValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue'])
-    ## string.h: ns3::StringValue [class]
-    module.add_class('StringValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue'])
+    module.add_class('DoubleValue', parent=root_module['ns3::AttributeValue'])
     ## type-id.h: ns3::TypeIdValue [class]
-    module.add_class('TypeIdValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue'])
+    module.add_class('TypeIdValue', parent=root_module['ns3::AttributeValue'])
     ## enum.h: ns3::EnumValue [class]
-    module.add_class('EnumValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue'])
+    module.add_class('EnumValue', parent=root_module['ns3::AttributeValue'])
     ## random-variable.h: ns3::RandomVariableValue [class]
-    module.add_class('RandomVariableValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue'])
+    module.add_class('RandomVariableValue', parent=root_module['ns3::AttributeValue'])
     ## object-factory.h: ns3::ObjectFactoryValue [class]
-    module.add_class('ObjectFactoryValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue'])
+    module.add_class('ObjectFactoryValue', parent=root_module['ns3::AttributeValue'])
     ## integer.h: ns3::IntegerValue [class]
-    module.add_class('IntegerValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue'])
+    module.add_class('IntegerValue', parent=root_module['ns3::AttributeValue'])
+    ## boolean.h: ns3::BooleanValue [class]
+    module.add_class('BooleanValue', parent=root_module['ns3::AttributeValue'])
+    ## string.h: ns3::StringValue [class]
+    module.add_class('StringValue', parent=root_module['ns3::AttributeValue'])
     ## attribute.h: ns3::EmptyAttributeValue [class]
-    module.add_class('EmptyAttributeValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue'])
-    ## boolean.h: ns3::BooleanValue [class]
-    module.add_class('BooleanValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue'])
+    module.add_class('EmptyAttributeValue', 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]
@@ -219,14 +227,17 @@
     register_Ns3TypeIdAttributeInfo_methods(root_module, root_module['ns3::TypeId::AttributeInfo'])
     register_Ns3SystemWallClockMs_methods(root_module, root_module['ns3::SystemWallClockMs'])
     register_Ns3CallbackImplBase_methods(root_module, root_module['ns3::CallbackImplBase'])
+    register_Ns3CriticalSection_methods(root_module, root_module['ns3::CriticalSection'])
     register_Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::TraceSourceAccessor'])
     register_Ns3AttributeChecker_methods(root_module, root_module['ns3::AttributeChecker'])
     register_Ns3RandomVariableChecker_methods(root_module, root_module['ns3::RandomVariableChecker'])
+    register_Ns3SystemMutex_methods(root_module, root_module['ns3::SystemMutex'])
     register_Ns3NormalVariable_methods(root_module, root_module['ns3::NormalVariable'])
     register_Ns3ObjectFactory_methods(root_module, root_module['ns3::ObjectFactory'])
     register_Ns3AttributeAccessor_methods(root_module, root_module['ns3::AttributeAccessor'])
     register_Ns3ParetoVariable_methods(root_module, root_module['ns3::ParetoVariable'])
     register_Ns3ConstantVariable_methods(root_module, root_module['ns3::ConstantVariable'])
+    register_Ns3SystemThread_methods(root_module, root_module['ns3::SystemThread'])
     register_Ns3EmpiricalVariable_methods(root_module, root_module['ns3::EmpiricalVariable'])
     register_Ns3EnumChecker_methods(root_module, root_module['ns3::EnumChecker'])
     register_Ns3Empty_methods(root_module, root_module['ns3::empty'])
@@ -262,6 +273,7 @@
     register_Ns3UniformVariable_methods(root_module, root_module['ns3::UniformVariable'])
     register_Ns3Object_methods(root_module, root_module['ns3::Object'])
     register_Ns3ObjectAggregateIterator_methods(root_module, root_module['ns3::Object::AggregateIterator'])
+    register_Ns3SystemCondition_methods(root_module, root_module['ns3::SystemCondition'])
     register_Ns3SequentialVariable_methods(root_module, root_module['ns3::SequentialVariable'])
     register_Ns3ObjectVectorChecker_methods(root_module, root_module['ns3::ObjectVectorChecker'])
     register_Ns3StringChecker_methods(root_module, root_module['ns3::StringChecker'])
@@ -273,151 +285,293 @@
     register_Ns3ObjectFactoryChecker_methods(root_module, root_module['ns3::ObjectFactoryChecker'])
     register_Ns3TypeIdChecker_methods(root_module, root_module['ns3::TypeIdChecker'])
     register_Ns3DoubleValue_methods(root_module, root_module['ns3::DoubleValue'])
-    register_Ns3StringValue_methods(root_module, root_module['ns3::StringValue'])
     register_Ns3TypeIdValue_methods(root_module, root_module['ns3::TypeIdValue'])
     register_Ns3EnumValue_methods(root_module, root_module['ns3::EnumValue'])
     register_Ns3RandomVariableValue_methods(root_module, root_module['ns3::RandomVariableValue'])
     register_Ns3ObjectFactoryValue_methods(root_module, root_module['ns3::ObjectFactoryValue'])
     register_Ns3IntegerValue_methods(root_module, root_module['ns3::IntegerValue'])
+    register_Ns3BooleanValue_methods(root_module, root_module['ns3::BooleanValue'])
+    register_Ns3StringValue_methods(root_module, root_module['ns3::StringValue'])
     register_Ns3EmptyAttributeValue_methods(root_module, root_module['ns3::EmptyAttributeValue'])
-    register_Ns3BooleanValue_methods(root_module, root_module['ns3::BooleanValue'])
     register_Ns3TracedValue__Unsigned_int_methods(root_module, root_module['ns3::TracedValue< unsigned int >'])
     return
 
 def register_Ns3RandomVariable_methods(root_module, cls):
     ## random-variable.h: ns3::RandomVariable::RandomVariable() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## random-variable.h: ns3::RandomVariable::RandomVariable(ns3::RandomVariable const & o) [copy constructor]
-    cls.add_constructor([param('ns3::RandomVariable&', 'o', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::RandomVariable&', 'o', is_const=True)])
     ## random-variable.h: uint32_t ns3::RandomVariable::GetInteger() const [member function]
-    cls.add_method('GetInteger', 'uint32_t', [], is_const=True)
+    cls.add_method('GetInteger', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## random-variable.h: void ns3::RandomVariable::GetSeed(uint32_t * seed) const [member function]
-    cls.add_method('GetSeed', 'void', [param('uint32_t *', 'seed', direction=2, array_length=6)], is_const=True)
+    cls.add_method('GetSeed', 
+                   'void', 
+                   [param('uint32_t *', 'seed', direction=2, array_length=6)], 
+                   is_const=True)
     ## random-variable.h: double ns3::RandomVariable::GetValue() const [member function]
-    cls.add_method('GetValue', 'double', [], is_const=True)
+    cls.add_method('GetValue', 
+                   'double', 
+                   [], 
+                   is_const=True)
     ## random-variable.h: static void ns3::RandomVariable::SetRunNumber(uint32_t n) [member function]
-    cls.add_method('SetRunNumber', 'void', [param('uint32_t', 'n')], is_static=True)
+    cls.add_method('SetRunNumber', 
+                   'void', 
+                   [param('uint32_t', 'n')], 
+                   is_static=True)
     ## random-variable.h: static void ns3::RandomVariable::UseDevRandom(bool udr=true) [member function]
-    cls.add_method('UseDevRandom', 'void', [param('bool', 'udr', default_value='true')], is_static=True)
+    cls.add_method('UseDevRandom', 
+                   'void', 
+                   [param('bool', 'udr', default_value='true')], 
+                   is_static=True)
     ## random-variable.h: static void ns3::RandomVariable::UseGlobalSeed(uint32_t s0, uint32_t s1, uint32_t s2, uint32_t s3, uint32_t s4, uint32_t s5) [member function]
-    cls.add_method('UseGlobalSeed', 'void', [param('uint32_t', 's0'), param('uint32_t', 's1'), param('uint32_t', 's2'), param('uint32_t', 's3'), param('uint32_t', 's4'), param('uint32_t', 's5')], is_static=True)
+    cls.add_method('UseGlobalSeed', 
+                   'void', 
+                   [param('uint32_t', 's0'), param('uint32_t', 's1'), param('uint32_t', 's2'), param('uint32_t', 's3'), param('uint32_t', 's4'), param('uint32_t', 's5')], 
+                   is_static=True)
     cls.add_output_stream_operator()
     return
 
 def register_Ns3TriangularVariable_methods(root_module, cls):
     ## random-variable.h: ns3::TriangularVariable::TriangularVariable() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## random-variable.h: ns3::TriangularVariable::TriangularVariable(double s, double l, double mean) [constructor]
-    cls.add_constructor([param('double', 's'), param('double', 'l'), param('double', 'mean')], visibility='public')
+    cls.add_constructor([param('double', 's'), param('double', 'l'), param('double', 'mean')])
     ## random-variable.h: static double ns3::TriangularVariable::GetSingleValue(double s, double l, double mean) [member function]
-    cls.add_method('GetSingleValue', 'double', [param('double', 's'), param('double', 'l'), param('double', 'mean')], is_static=True)
+    cls.add_method('GetSingleValue', 
+                   'double', 
+                   [param('double', 's'), param('double', 'l'), param('double', 'mean')], 
+                   is_static=True)
     return
 
 def register_Ns3GlobalValue_methods(root_module, cls):
     ## global-value.h: ns3::GlobalValue::GlobalValue(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr<ns3::AttributeChecker const> checker) [constructor]
-    cls.add_constructor([param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue&', 'initialValue', is_const=True), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], visibility='public')
+    cls.add_constructor([param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue&', 'initialValue', is_const=True), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')])
     ## global-value.h: std::string ns3::GlobalValue::GetName() const [member function]
-    cls.add_method('GetName', 'std::string', [], is_const=True)
+    cls.add_method('GetName', 
+                   'std::string', 
+                   [], 
+                   is_const=True)
     ## global-value.h: std::string ns3::GlobalValue::GetHelp() const [member function]
-    cls.add_method('GetHelp', 'std::string', [], is_const=True)
+    cls.add_method('GetHelp', 
+                   'std::string', 
+                   [], 
+                   is_const=True)
     ## global-value.h: void ns3::GlobalValue::GetValue(ns3::AttributeValue & value) const [member function]
-    cls.add_method('GetValue', 'void', [param('ns3::AttributeValue&', 'value')], is_const=True)
+    cls.add_method('GetValue', 
+                   'void', 
+                   [param('ns3::AttributeValue&', 'value')], 
+                   is_const=True)
     ## global-value.h: ns3::Ptr<ns3::AttributeChecker const> ns3::GlobalValue::GetChecker() const [member function]
-    cls.add_method('GetChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [], is_const=True)
+    cls.add_method('GetChecker', 
+                   'ns3::Ptr< ns3::AttributeChecker const >', 
+                   [], 
+                   is_const=True)
     ## global-value.h: bool ns3::GlobalValue::SetValue(ns3::AttributeValue const & value) [member function]
-    cls.add_method('SetValue', 'bool', [param('ns3::AttributeValue&', 'value', is_const=True)])
+    cls.add_method('SetValue', 
+                   'bool', 
+                   [param('ns3::AttributeValue&', 'value', is_const=True)])
     ## global-value.h: static void ns3::GlobalValue::Bind(std::string name, ns3::AttributeValue const & value) [member function]
-    cls.add_method('Bind', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)], is_static=True)
+    cls.add_method('Bind', 
+                   'void', 
+                   [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)], 
+                   is_static=True)
     ## global-value.h: static bool ns3::GlobalValue::BindFailSafe(std::string name, ns3::AttributeValue const & value) [member function]
-    cls.add_method('BindFailSafe', 'bool', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)], is_static=True)
+    cls.add_method('BindFailSafe', 
+                   'bool', 
+                   [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)], 
+                   is_static=True)
     ## global-value.h: static __gnu_cxx::__normal_iterator<ns3::GlobalValue* const*,std::vector<ns3::GlobalValue*, std::allocator<ns3::GlobalValue*> > > ns3::GlobalValue::Begin() [member function]
-    cls.add_method('Begin', '__gnu_cxx::__normal_iterator< ns3::GlobalValue* const*, std::vector< ns3::GlobalValue*, std::allocator< ns3::GlobalValue* > > >', [], is_static=True)
+    cls.add_method('Begin', 
+                   '__gnu_cxx::__normal_iterator< ns3::GlobalValue* const*, std::vector< ns3::GlobalValue*, std::allocator< ns3::GlobalValue* > > >', 
+                   [], 
+                   is_static=True)
     ## global-value.h: static __gnu_cxx::__normal_iterator<ns3::GlobalValue* const*,std::vector<ns3::GlobalValue*, std::allocator<ns3::GlobalValue*> > > ns3::GlobalValue::End() [member function]
-    cls.add_method('End', '__gnu_cxx::__normal_iterator< ns3::GlobalValue* const*, std::vector< ns3::GlobalValue*, std::allocator< ns3::GlobalValue* > > >', [], is_static=True)
+    cls.add_method('End', 
+                   '__gnu_cxx::__normal_iterator< ns3::GlobalValue* const*, std::vector< ns3::GlobalValue*, std::allocator< ns3::GlobalValue* > > >', 
+                   [], 
+                   is_static=True)
     return
 
 def register_Ns3RefCountBase_methods(root_module, cls):
     ## ref-count-base.h: ns3::RefCountBase::RefCountBase() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## ref-count-base.h: ns3::RefCountBase::RefCountBase(ns3::RefCountBase const & o) [copy constructor]
-    cls.add_constructor([param('ns3::RefCountBase&', 'o', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::RefCountBase&', 'o', is_const=True)])
     return
 
 def register_Ns3TypeId_methods(root_module, cls):
     ## type-id.h: ns3::TypeId::TypeId(ns3::TypeId const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::TypeId&', 'arg0', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::TypeId&', 'arg0', is_const=True)])
     ## type-id.h: ns3::TypeId::TypeId(char const * name) [constructor]
-    cls.add_constructor([param('char *', 'name', transfer_ownership=False, is_const=True)], visibility='public')
+    cls.add_constructor([param('char *', 'name', transfer_ownership=False, is_const=True)])
     ## type-id.h: ns3::TypeId::TypeId() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## type-id.h: ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr<ns3::AttributeAccessor const> accessor, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
-    cls.add_method('AddAttribute', 'ns3::TypeId', [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue&', 'initialValue', is_const=True), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')])
+    cls.add_method('AddAttribute', 
+                   'ns3::TypeId', 
+                   [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue&', 'initialValue', is_const=True), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')])
     ## type-id.h: ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, uint32_t flags, ns3::AttributeValue const & initialValue, ns3::Ptr<ns3::AttributeAccessor const> accessor, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
-    cls.add_method('AddAttribute', 'ns3::TypeId', [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue&', 'initialValue', is_const=True), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')])
+    cls.add_method('AddAttribute', 
+                   'ns3::TypeId', 
+                   [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue&', 'initialValue', is_const=True), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')])
     ## type-id.h: ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr<ns3::TraceSourceAccessor const> accessor) [member function]
-    cls.add_method('AddTraceSource', 'ns3::TypeId', [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')])
+    cls.add_method('AddTraceSource', 
+                   'ns3::TypeId', 
+                   [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')])
     ## type-id.h: ns3::Ptr<ns3::AttributeAccessor const> ns3::TypeId::GetAttributeAccessor(uint32_t i) const [member function]
-    cls.add_method('GetAttributeAccessor', 'ns3::Ptr< ns3::AttributeAccessor const >', [param('uint32_t', 'i')], is_const=True)
+    cls.add_method('GetAttributeAccessor', 
+                   'ns3::Ptr< ns3::AttributeAccessor const >', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
     ## type-id.h: ns3::Ptr<ns3::AttributeChecker const> ns3::TypeId::GetAttributeChecker(uint32_t i) const [member function]
-    cls.add_method('GetAttributeChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [param('uint32_t', 'i')], is_const=True)
+    cls.add_method('GetAttributeChecker', 
+                   'ns3::Ptr< ns3::AttributeChecker const >', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
     ## type-id.h: uint32_t ns3::TypeId::GetAttributeFlags(uint32_t i) const [member function]
-    cls.add_method('GetAttributeFlags', 'uint32_t', [param('uint32_t', 'i')], is_const=True)
+    cls.add_method('GetAttributeFlags', 
+                   'uint32_t', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
     ## type-id.h: std::string ns3::TypeId::GetAttributeFullName(uint32_t i) const [member function]
-    cls.add_method('GetAttributeFullName', 'std::string', [param('uint32_t', 'i')], is_const=True)
+    cls.add_method('GetAttributeFullName', 
+                   'std::string', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
     ## type-id.h: std::string ns3::TypeId::GetAttributeHelp(uint32_t i) const [member function]
-    cls.add_method('GetAttributeHelp', 'std::string', [param('uint32_t', 'i')], is_const=True)
+    cls.add_method('GetAttributeHelp', 
+                   'std::string', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
     ## type-id.h: ns3::Ptr<ns3::AttributeValue const> ns3::TypeId::GetAttributeInitialValue(uint32_t i) const [member function]
-    cls.add_method('GetAttributeInitialValue', 'ns3::Ptr< ns3::AttributeValue const >', [param('uint32_t', 'i')], is_const=True)
+    cls.add_method('GetAttributeInitialValue', 
+                   'ns3::Ptr< ns3::AttributeValue const >', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
     ## type-id.h: uint32_t ns3::TypeId::GetAttributeN() const [member function]
-    cls.add_method('GetAttributeN', 'uint32_t', [], is_const=True)
+    cls.add_method('GetAttributeN', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## type-id.h: std::string ns3::TypeId::GetAttributeName(uint32_t i) const [member function]
-    cls.add_method('GetAttributeName', 'std::string', [param('uint32_t', 'i')], is_const=True)
+    cls.add_method('GetAttributeName', 
+                   'std::string', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
     ## type-id.h: ns3::Callback<ns3::ObjectBase*,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ns3::TypeId::GetConstructor() const [member function]
-    cls.add_method('GetConstructor', 'ns3::Callback< ns3::ObjectBase*, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', [], is_const=True)
+    cls.add_method('GetConstructor', 
+                   'ns3::Callback< ns3::ObjectBase*, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 
+                   [], 
+                   is_const=True)
     ## type-id.h: std::string ns3::TypeId::GetGroupName() const [member function]
-    cls.add_method('GetGroupName', 'std::string', [], is_const=True)
+    cls.add_method('GetGroupName', 
+                   'std::string', 
+                   [], 
+                   is_const=True)
     ## type-id.h: std::string ns3::TypeId::GetName() const [member function]
-    cls.add_method('GetName', 'std::string', [], is_const=True)
+    cls.add_method('GetName', 
+                   'std::string', 
+                   [], 
+                   is_const=True)
     ## type-id.h: ns3::TypeId ns3::TypeId::GetParent() const [member function]
-    cls.add_method('GetParent', 'ns3::TypeId', [], is_const=True)
+    cls.add_method('GetParent', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_const=True)
     ## type-id.h: static ns3::TypeId ns3::TypeId::GetRegistered(uint32_t i) [member function]
-    cls.add_method('GetRegistered', 'ns3::TypeId', [param('uint32_t', 'i')], is_static=True)
+    cls.add_method('GetRegistered', 
+                   'ns3::TypeId', 
+                   [param('uint32_t', 'i')], 
+                   is_static=True)
     ## type-id.h: static uint32_t ns3::TypeId::GetRegisteredN() [member function]
-    cls.add_method('GetRegisteredN', 'uint32_t', [], is_static=True)
+    cls.add_method('GetRegisteredN', 
+                   'uint32_t', 
+                   [], 
+                   is_static=True)
     ## type-id.h: ns3::Ptr<ns3::TraceSourceAccessor const> ns3::TypeId::GetTraceSourceAccessor(uint32_t i) const [member function]
-    cls.add_method('GetTraceSourceAccessor', 'ns3::Ptr< ns3::TraceSourceAccessor const >', [param('uint32_t', 'i')], is_const=True)
+    cls.add_method('GetTraceSourceAccessor', 
+                   'ns3::Ptr< ns3::TraceSourceAccessor const >', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
     ## type-id.h: std::string ns3::TypeId::GetTraceSourceHelp(uint32_t i) const [member function]
-    cls.add_method('GetTraceSourceHelp', 'std::string', [param('uint32_t', 'i')], is_const=True)
+    cls.add_method('GetTraceSourceHelp', 
+                   'std::string', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
     ## type-id.h: uint32_t ns3::TypeId::GetTraceSourceN() const [member function]
-    cls.add_method('GetTraceSourceN', 'uint32_t', [], is_const=True)
+    cls.add_method('GetTraceSourceN', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## type-id.h: std::string ns3::TypeId::GetTraceSourceName(uint32_t i) const [member function]
-    cls.add_method('GetTraceSourceName', 'std::string', [param('uint32_t', 'i')], is_const=True)
+    cls.add_method('GetTraceSourceName', 
+                   'std::string', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
     ## type-id.h: uint16_t ns3::TypeId::GetUid() const [member function]
-    cls.add_method('GetUid', 'uint16_t', [], is_const=True)
+    cls.add_method('GetUid', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
     ## type-id.h: bool ns3::TypeId::HasConstructor() const [member function]
-    cls.add_method('HasConstructor', 'bool', [], is_const=True)
+    cls.add_method('HasConstructor', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## type-id.h: bool ns3::TypeId::HasParent() const [member function]
-    cls.add_method('HasParent', 'bool', [], is_const=True)
+    cls.add_method('HasParent', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## type-id.h: ns3::TypeId ns3::TypeId::HideFromDocumentation() [member function]
-    cls.add_method('HideFromDocumentation', 'ns3::TypeId', [])
+    cls.add_method('HideFromDocumentation', 
+                   'ns3::TypeId', 
+                   [])
     ## type-id.h: bool ns3::TypeId::IsChildOf(ns3::TypeId other) const [member function]
-    cls.add_method('IsChildOf', 'bool', [param('ns3::TypeId', 'other')], is_const=True)
+    cls.add_method('IsChildOf', 
+                   'bool', 
+                   [param('ns3::TypeId', 'other')], 
+                   is_const=True)
     ## type-id.h: bool ns3::TypeId::LookupAttributeByName(std::string name, ns3::TypeId::AttributeInfo * info) const [member function]
-    cls.add_method('LookupAttributeByName', 'bool', [param('std::string', 'name'), param('ns3::TypeId::AttributeInfo *', 'info', transfer_ownership=False)], is_const=True)
+    cls.add_method('LookupAttributeByName', 
+                   'bool', 
+                   [param('std::string', 'name'), param('ns3::TypeId::AttributeInfo *', 'info', transfer_ownership=False)], 
+                   is_const=True)
     ## type-id.h: static ns3::TypeId ns3::TypeId::LookupByName(std::string name) [member function]
-    cls.add_method('LookupByName', 'ns3::TypeId', [param('std::string', 'name')], is_static=True)
+    cls.add_method('LookupByName', 
+                   'ns3::TypeId', 
+                   [param('std::string', 'name')], 
+                   is_static=True)
     ## type-id.h: static bool ns3::TypeId::LookupByNameFailSafe(std::string name, ns3::TypeId * tid) [member function]
-    cls.add_method('LookupByNameFailSafe', 'bool', [param('std::string', 'name'), param('ns3::TypeId *', 'tid', transfer_ownership=False)], is_static=True)
+    cls.add_method('LookupByNameFailSafe', 
+                   'bool', 
+                   [param('std::string', 'name'), param('ns3::TypeId *', 'tid', transfer_ownership=False)], 
+                   is_static=True)
     ## type-id.h: ns3::Ptr<ns3::TraceSourceAccessor const> ns3::TypeId::LookupTraceSourceByName(std::string name) const [member function]
-    cls.add_method('LookupTraceSourceByName', 'ns3::Ptr< ns3::TraceSourceAccessor const >', [param('std::string', 'name')], is_const=True)
+    cls.add_method('LookupTraceSourceByName', 
+                   'ns3::Ptr< ns3::TraceSourceAccessor const >', 
+                   [param('std::string', 'name')], 
+                   is_const=True)
     ## type-id.h: bool ns3::TypeId::MustHideFromDocumentation() const [member function]
-    cls.add_method('MustHideFromDocumentation', 'bool', [], is_const=True)
+    cls.add_method('MustHideFromDocumentation', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## type-id.h: ns3::TypeId ns3::TypeId::SetGroupName(std::string groupName) [member function]
-    cls.add_method('SetGroupName', 'ns3::TypeId', [param('std::string', 'groupName')])
+    cls.add_method('SetGroupName', 
+                   'ns3::TypeId', 
+                   [param('std::string', 'groupName')])
     ## type-id.h: ns3::TypeId ns3::TypeId::SetParent(ns3::TypeId tid) [member function]
-    cls.add_method('SetParent', 'ns3::TypeId', [param('ns3::TypeId', 'tid')])
+    cls.add_method('SetParent', 
+                   'ns3::TypeId', 
+                   [param('ns3::TypeId', 'tid')])
     ## type-id.h: void ns3::TypeId::SetUid(uint16_t tid) [member function]
-    cls.add_method('SetUid', 'void', [param('uint16_t', 'tid')])
+    cls.add_method('SetUid', 
+                   'void', 
+                   [param('uint16_t', 'tid')])
     cls.add_output_stream_operator()
     return
 
@@ -435,152 +589,297 @@
 
 def register_Ns3SystemWallClockMs_methods(root_module, cls):
     ## system-wall-clock-ms.h: ns3::SystemWallClockMs::SystemWallClockMs() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## system-wall-clock-ms.h: void ns3::SystemWallClockMs::Start() [member function]
-    cls.add_method('Start', 'void', [])
+    cls.add_method('Start', 
+                   'void', 
+                   [])
     ## system-wall-clock-ms.h: long long unsigned int ns3::SystemWallClockMs::End() [member function]
-    cls.add_method('End', 'long long unsigned int', [])
+    cls.add_method('End', 
+                   'long long unsigned int', 
+                   [])
     return
 
 def register_Ns3CallbackImplBase_methods(root_module, cls):
     ## callback.h: ns3::CallbackImplBase::CallbackImplBase() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## callback.h: bool ns3::CallbackImplBase::IsEqual(ns3::Ptr<ns3::CallbackImplBase const> other) const [member function]
-    cls.add_method('IsEqual', 'bool', [param('ns3::Ptr< ns3::CallbackImplBase const >', 'other')], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('IsEqual', 
+                   'bool', 
+                   [param('ns3::Ptr< ns3::CallbackImplBase const >', 'other')], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
+    return
+
+def register_Ns3CriticalSection_methods(root_module, cls):
+    ## system-mutex.h: ns3::CriticalSection::CriticalSection(ns3::SystemMutex & mutex) [constructor]
+    cls.add_constructor([param('ns3::SystemMutex&', 'mutex')])
     return
 
 def register_Ns3TraceSourceAccessor_methods(root_module, cls):
     ## trace-source-accessor.h: ns3::TraceSourceAccessor::TraceSourceAccessor() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## trace-source-accessor.h: void ns3::TraceSourceAccessor::Ref() const [member function]
-    cls.add_method('Ref', 'void', [], is_const=True)
+    cls.add_method('Ref', 
+                   'void', 
+                   [], 
+                   is_const=True)
     ## trace-source-accessor.h: void ns3::TraceSourceAccessor::Unref() const [member function]
-    cls.add_method('Unref', 'void', [], is_const=True)
+    cls.add_method('Unref', 
+                   'void', 
+                   [], 
+                   is_const=True)
     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::ConnectWithoutContext(ns3::ObjectBase * obj, ns3::CallbackBase const & cb) const [member function]
-    cls.add_method('ConnectWithoutContext', 'bool', [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase&', 'cb', is_const=True)], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('ConnectWithoutContext', 
+                   'bool', 
+                   [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase&', 'cb', is_const=True)], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::Connect(ns3::ObjectBase * obj, std::string context, ns3::CallbackBase const & cb) const [member function]
-    cls.add_method('Connect', 'bool', [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase&', 'cb', is_const=True)], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('Connect', 
+                   'bool', 
+                   [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase&', 'cb', is_const=True)], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::DisconnectWithoutContext(ns3::ObjectBase * obj, ns3::CallbackBase const & cb) const [member function]
-    cls.add_method('DisconnectWithoutContext', 'bool', [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase&', 'cb', is_const=True)], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('DisconnectWithoutContext', 
+                   'bool', 
+                   [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase&', 'cb', is_const=True)], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::Disconnect(ns3::ObjectBase * obj, std::string context, ns3::CallbackBase const & cb) const [member function]
-    cls.add_method('Disconnect', 'bool', [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase&', 'cb', is_const=True)], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('Disconnect', 
+                   'bool', 
+                   [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase&', 'cb', is_const=True)], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     return
 
 def register_Ns3AttributeChecker_methods(root_module, cls):
     ## attribute.h: ns3::AttributeChecker::AttributeChecker() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## attribute.h: bool ns3::AttributeChecker::Check(ns3::AttributeValue const & value) const [member function]
-    cls.add_method('Check', 'bool', [param('ns3::AttributeValue&', 'value', is_const=True)], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('Check', 
+                   'bool', 
+                   [param('ns3::AttributeValue&', 'value', is_const=True)], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     ## attribute.h: std::string ns3::AttributeChecker::GetValueTypeName() const [member function]
-    cls.add_method('GetValueTypeName', 'std::string', [], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('GetValueTypeName', 
+                   'std::string', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     ## attribute.h: bool ns3::AttributeChecker::HasUnderlyingTypeInformation() const [member function]
-    cls.add_method('HasUnderlyingTypeInformation', 'bool', [], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('HasUnderlyingTypeInformation', 
+                   'bool', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     ## attribute.h: std::string ns3::AttributeChecker::GetUnderlyingTypeInformation() const [member function]
-    cls.add_method('GetUnderlyingTypeInformation', 'std::string', [], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('GetUnderlyingTypeInformation', 
+                   'std::string', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     ## attribute.h: ns3::Ptr<ns3::AttributeValue> ns3::AttributeChecker::Create() const [member function]
-    cls.add_method('Create', 'ns3::Ptr< ns3::AttributeValue >', [], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('Create', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     ## attribute.h: bool ns3::AttributeChecker::Copy(ns3::AttributeValue const & source, ns3::AttributeValue & destination) const [member function]
-    cls.add_method('Copy', 'bool', [param('ns3::AttributeValue&', 'source', is_const=True), param('ns3::AttributeValue&', 'destination')], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('Copy', 
+                   'bool', 
+                   [param('ns3::AttributeValue&', 'source', is_const=True), param('ns3::AttributeValue&', 'destination')], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     return
 
 def register_Ns3RandomVariableChecker_methods(root_module, cls):
     cls.add_constructor([])
     return
 
+def register_Ns3SystemMutex_methods(root_module, cls):
+    ## system-mutex.h: ns3::SystemMutex::SystemMutex() [constructor]
+    cls.add_constructor([])
+    ## system-mutex.h: void ns3::SystemMutex::Lock() [member function]
+    cls.add_method('Lock', 
+                   'void', 
+                   [])
+    ## system-mutex.h: void ns3::SystemMutex::Unlock() [member function]
+    cls.add_method('Unlock', 
+                   'void', 
+                   [])
+    return
+
 def register_Ns3NormalVariable_methods(root_module, cls):
     ## random-variable.h: ns3::NormalVariable::NormalVariable() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## random-variable.h: ns3::NormalVariable::NormalVariable(double m, double v) [constructor]
-    cls.add_constructor([param('double', 'm'), param('double', 'v')], visibility='public')
+    cls.add_constructor([param('double', 'm'), param('double', 'v')])
     ## random-variable.h: ns3::NormalVariable::NormalVariable(double m, double v, double b) [constructor]
-    cls.add_constructor([param('double', 'm'), param('double', 'v'), param('double', 'b')], visibility='public')
+    cls.add_constructor([param('double', 'm'), param('double', 'v'), param('double', 'b')])
     ## random-variable.h: static double ns3::NormalVariable::GetSingleValue(double m, double v) [member function]
-    cls.add_method('GetSingleValue', 'double', [param('double', 'm'), param('double', 'v')], is_static=True)
+    cls.add_method('GetSingleValue', 
+                   'double', 
+                   [param('double', 'm'), param('double', 'v')], 
+                   is_static=True)
     ## random-variable.h: static double ns3::NormalVariable::GetSingleValue(double m, double v, double b) [member function]
-    cls.add_method('GetSingleValue', 'double', [param('double', 'm'), param('double', 'v'), param('double', 'b')], is_static=True)
+    cls.add_method('GetSingleValue', 
+                   'double', 
+                   [param('double', 'm'), param('double', 'v'), param('double', 'b')], 
+                   is_static=True)
     return
 
 def register_Ns3ObjectFactory_methods(root_module, cls):
     ## object-factory.h: ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::ObjectFactory&', 'arg0', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::ObjectFactory&', 'arg0', is_const=True)])
     ## object-factory.h: ns3::ObjectFactory::ObjectFactory() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## object-factory.h: ns3::Ptr<ns3::Object> ns3::ObjectFactory::Create() const [member function]
-    cls.add_method('Create', 'ns3::Ptr< ns3::Object >', [], is_const=True)
+    cls.add_method('Create', 
+                   'ns3::Ptr< ns3::Object >', 
+                   [], 
+                   is_const=True)
     ## object-factory.h: ns3::TypeId ns3::ObjectFactory::GetTypeId() const [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_const=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_const=True)
     ## object-factory.h: void ns3::ObjectFactory::Set(std::string name, ns3::AttributeValue const & value) [member function]
-    cls.add_method('Set', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
+    cls.add_method('Set', 
+                   'void', 
+                   [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
     ## object-factory.h: void ns3::ObjectFactory::SetTypeId(ns3::TypeId tid) [member function]
-    cls.add_method('SetTypeId', 'void', [param('ns3::TypeId', 'tid')])
+    cls.add_method('SetTypeId', 
+                   'void', 
+                   [param('ns3::TypeId', 'tid')])
     ## object-factory.h: void ns3::ObjectFactory::SetTypeId(char const * tid) [member function]
-    cls.add_method('SetTypeId', 'void', [param('char *', 'tid', transfer_ownership=False, is_const=True)])
+    cls.add_method('SetTypeId', 
+                   'void', 
+                   [param('char *', 'tid', transfer_ownership=False, is_const=True)])
     ## object-factory.h: void ns3::ObjectFactory::SetTypeId(std::string tid) [member function]
-    cls.add_method('SetTypeId', 'void', [param('std::string', 'tid')])
+    cls.add_method('SetTypeId', 
+                   'void', 
+                   [param('std::string', 'tid')])
     cls.add_output_stream_operator()
     return
 
 def register_Ns3AttributeAccessor_methods(root_module, cls):
     ## attribute.h: ns3::AttributeAccessor::AttributeAccessor() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## attribute.h: bool ns3::AttributeAccessor::Set(ns3::ObjectBase * object, ns3::AttributeValue const & value) const [member function]
-    cls.add_method('Set', 'bool', [param('ns3::ObjectBase *', 'object', transfer_ownership=False), param('ns3::AttributeValue&', 'value', is_const=True)], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('Set', 
+                   'bool', 
+                   [param('ns3::ObjectBase *', 'object', transfer_ownership=False), param('ns3::AttributeValue&', 'value', is_const=True)], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     ## attribute.h: bool ns3::AttributeAccessor::Get(ns3::ObjectBase const * object, ns3::AttributeValue & attribute) const [member function]
-    cls.add_method('Get', 'bool', [param('ns3::ObjectBase *', 'object', transfer_ownership=False, is_const=True), param('ns3::AttributeValue&', 'attribute')], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('Get', 
+                   'bool', 
+                   [param('ns3::ObjectBase *', 'object', transfer_ownership=False, is_const=True), param('ns3::AttributeValue&', 'attribute')], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     ## attribute.h: bool ns3::AttributeAccessor::HasGetter() const [member function]
-    cls.add_method('HasGetter', 'bool', [], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('HasGetter', 
+                   'bool', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     ## attribute.h: bool ns3::AttributeAccessor::HasSetter() const [member function]
-    cls.add_method('HasSetter', 'bool', [], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('HasSetter', 
+                   'bool', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     return
 
 def register_Ns3ParetoVariable_methods(root_module, cls):
     ## random-variable.h: ns3::ParetoVariable::ParetoVariable() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## random-variable.h: ns3::ParetoVariable::ParetoVariable(double m) [constructor]
-    cls.add_constructor([param('double', 'm')], visibility='public')
+    cls.add_constructor([param('double', 'm')])
     ## random-variable.h: ns3::ParetoVariable::ParetoVariable(double m, double s) [constructor]
-    cls.add_constructor([param('double', 'm'), param('double', 's')], visibility='public')
+    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')], visibility='public')
+    cls.add_constructor([param('double', 'm'), param('double', 's'), param('double', 'b')])
     ## random-variable.h: static double ns3::ParetoVariable::GetSingleValue(double m, double s, double b=0) [member function]
-    cls.add_method('GetSingleValue', 'double', [param('double', 'm'), param('double', 's'), param('double', 'b', default_value='0')], is_static=True)
+    cls.add_method('GetSingleValue', 
+                   'double', 
+                   [param('double', 'm'), param('double', 's'), param('double', 'b', default_value='0')], 
+                   is_static=True)
     return
 
 def register_Ns3ConstantVariable_methods(root_module, cls):
     ## random-variable.h: ns3::ConstantVariable::ConstantVariable() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## random-variable.h: ns3::ConstantVariable::ConstantVariable(double c) [constructor]
-    cls.add_constructor([param('double', 'c')], visibility='public')
+    cls.add_constructor([param('double', 'c')])
     ## random-variable.h: void ns3::ConstantVariable::SetConstant(double c) [member function]
-    cls.add_method('SetConstant', 'void', [param('double', 'c')])
+    cls.add_method('SetConstant', 
+                   'void', 
+                   [param('double', 'c')])
+    return
+
+def register_Ns3SystemThread_methods(root_module, cls):
+    ## system-thread.h: ns3::SystemThread::SystemThread(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [constructor]
+    cls.add_constructor([param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')])
+    ## system-thread.h: void ns3::SystemThread::Ref() const [member function]
+    cls.add_method('Ref', 
+                   'void', 
+                   [], 
+                   is_const=True)
+    ## system-thread.h: void ns3::SystemThread::Unref() const [member function]
+    cls.add_method('Unref', 
+                   'void', 
+                   [], 
+                   is_const=True)
+    ## system-thread.h: void ns3::SystemThread::Start() [member function]
+    cls.add_method('Start', 
+                   'void', 
+                   [])
+    ## system-thread.h: void ns3::SystemThread::Join() [member function]
+    cls.add_method('Join', 
+                   'void', 
+                   [])
     return
 
 def register_Ns3EmpiricalVariable_methods(root_module, cls):
     ## random-variable.h: ns3::EmpiricalVariable::EmpiricalVariable() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## random-variable.h: void ns3::EmpiricalVariable::CDF(double v, double c) [member function]
-    cls.add_method('CDF', 'void', [param('double', 'v'), param('double', 'c')])
+    cls.add_method('CDF', 
+                   'void', 
+                   [param('double', 'v'), param('double', 'c')])
     return
 
 def register_Ns3EnumChecker_methods(root_module, cls):
     ## enum.h: ns3::EnumChecker::EnumChecker() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## enum.h: void ns3::EnumChecker::AddDefault(int v, std::string name) [member function]
-    cls.add_method('AddDefault', 'void', [param('int', 'v'), param('std::string', 'name')])
+    cls.add_method('AddDefault', 
+                   'void', 
+                   [param('int', 'v'), param('std::string', 'name')])
     ## enum.h: void ns3::EnumChecker::Add(int v, std::string name) [member function]
-    cls.add_method('Add', 'void', [param('int', 'v'), param('std::string', 'name')])
+    cls.add_method('Add', 
+                   'void', 
+                   [param('int', 'v'), param('std::string', 'name')])
     ## enum.h: bool ns3::EnumChecker::Check(ns3::AttributeValue const & value) const [member function]
-    cls.add_method('Check', 'bool', [param('ns3::AttributeValue&', 'value', is_const=True)], is_const=True, is_virtual=True)
+    cls.add_method('Check', 
+                   'bool', 
+                   [param('ns3::AttributeValue&', 'value', is_const=True)], 
+                   is_const=True, is_virtual=True)
     ## enum.h: std::string ns3::EnumChecker::GetValueTypeName() const [member function]
-    cls.add_method('GetValueTypeName', 'std::string', [], is_const=True, is_virtual=True)
+    cls.add_method('GetValueTypeName', 
+                   'std::string', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## enum.h: bool ns3::EnumChecker::HasUnderlyingTypeInformation() const [member function]
-    cls.add_method('HasUnderlyingTypeInformation', 'bool', [], is_const=True, is_virtual=True)
+    cls.add_method('HasUnderlyingTypeInformation', 
+                   'bool', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## enum.h: std::string ns3::EnumChecker::GetUnderlyingTypeInformation() const [member function]
-    cls.add_method('GetUnderlyingTypeInformation', 'std::string', [], is_const=True, is_virtual=True)
+    cls.add_method('GetUnderlyingTypeInformation', 
+                   'std::string', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## enum.h: ns3::Ptr<ns3::AttributeValue> ns3::EnumChecker::Create() const [member function]
-    cls.add_method('Create', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
+    cls.add_method('Create', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## enum.h: bool ns3::EnumChecker::Copy(ns3::AttributeValue const & src, ns3::AttributeValue & dst) const [member function]
-    cls.add_method('Copy', 'bool', [param('ns3::AttributeValue&', 'src', is_const=True), param('ns3::AttributeValue&', 'dst')], is_const=True, is_virtual=True)
+    cls.add_method('Copy', 
+                   'bool', 
+                   [param('ns3::AttributeValue&', 'src', is_const=True), param('ns3::AttributeValue&', 'dst')], 
+                   is_const=True, is_virtual=True)
     return
 
 def register_Ns3Empty_methods(root_module, cls):
@@ -589,33 +888,63 @@
 
 def register_Ns3ObjectBase_methods(root_module, cls):
     ## object-base.h: ns3::ObjectBase::ObjectBase() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## object-base.h: ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::ObjectBase&', 'arg0', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::ObjectBase&', 'arg0', is_const=True)])
     ## object-base.h: static ns3::TypeId ns3::ObjectBase::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## object-base.h: ns3::TypeId ns3::ObjectBase::GetInstanceTypeId() const [member function]
-    cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('GetInstanceTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     ## object-base.h: void ns3::ObjectBase::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function]
-    cls.add_method('SetAttribute', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
+    cls.add_method('SetAttribute', 
+                   'void', 
+                   [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
     ## object-base.h: bool ns3::ObjectBase::SetAttributeFailSafe(std::string name, ns3::AttributeValue const & value) [member function]
-    cls.add_method('SetAttributeFailSafe', 'bool', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
+    cls.add_method('SetAttributeFailSafe', 
+                   'bool', 
+                   [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
     ## object-base.h: void ns3::ObjectBase::GetAttribute(std::string name, ns3::AttributeValue & value) const [member function]
-    cls.add_method('GetAttribute', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value')], is_const=True)
+    cls.add_method('GetAttribute', 
+                   'void', 
+                   [param('std::string', 'name'), param('ns3::AttributeValue&', 'value')], 
+                   is_const=True)
     ## object-base.h: bool ns3::ObjectBase::GetAttributeFailSafe(std::string name, ns3::AttributeValue & attribute) const [member function]
-    cls.add_method('GetAttributeFailSafe', 'bool', [param('std::string', 'name'), param('ns3::AttributeValue&', 'attribute')], is_const=True)
+    cls.add_method('GetAttributeFailSafe', 
+                   'bool', 
+                   [param('std::string', 'name'), param('ns3::AttributeValue&', 'attribute')], 
+                   is_const=True)
     ## object-base.h: bool ns3::ObjectBase::TraceConnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function]
-    cls.add_method('TraceConnect', 'bool', [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase&', 'cb', is_const=True)])
+    cls.add_method('TraceConnect', 
+                   'bool', 
+                   [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase&', 'cb', is_const=True)])
     ## object-base.h: bool ns3::ObjectBase::TraceConnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]
-    cls.add_method('TraceConnectWithoutContext', 'bool', [param('std::string', 'name'), param('ns3::CallbackBase&', 'cb', is_const=True)])
+    cls.add_method('TraceConnectWithoutContext', 
+                   'bool', 
+                   [param('std::string', 'name'), param('ns3::CallbackBase&', 'cb', is_const=True)])
     ## object-base.h: bool ns3::ObjectBase::TraceDisconnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function]
-    cls.add_method('TraceDisconnect', 'bool', [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase&', 'cb', is_const=True)])
+    cls.add_method('TraceDisconnect', 
+                   'bool', 
+                   [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase&', 'cb', is_const=True)])
     ## object-base.h: bool ns3::ObjectBase::TraceDisconnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]
-    cls.add_method('TraceDisconnectWithoutContext', 'bool', [param('std::string', 'name'), param('ns3::CallbackBase&', 'cb', is_const=True)])
+    cls.add_method('TraceDisconnectWithoutContext', 
+                   'bool', 
+                   [param('std::string', 'name'), param('ns3::CallbackBase&', 'cb', is_const=True)])
     ## object-base.h: void ns3::ObjectBase::NotifyConstructionCompleted() [member function]
-    cls.add_method('NotifyConstructionCompleted', 'void', [], visibility='protected', is_virtual=True)
+    cls.add_method('NotifyConstructionCompleted', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
     ## object-base.h: void ns3::ObjectBase::ConstructSelf(ns3::AttributeList const & attributes) [member function]
-    cls.add_method('ConstructSelf', 'void', [param('ns3::AttributeList&', 'attributes', is_const=True)], visibility='protected')
+    cls.add_method('ConstructSelf', 
+                   'void', 
+                   [param('ns3::AttributeList&', 'attributes', is_const=True)], 
+                   visibility='protected')
     return
 
 def register_Ns3CommandLine_methods(root_module, cls):
@@ -652,308 +981,520 @@
 
 def register_Ns3RngStream_methods(root_module, cls):
     ## rng-stream.h: ns3::RngStream::RngStream() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## rng-stream.h: ns3::RngStream::RngStream(ns3::RngStream const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::RngStream&', 'arg0', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::RngStream&', 'arg0', is_const=True)])
     ## rng-stream.h: void ns3::RngStream::InitializeStream() [member function]
-    cls.add_method('InitializeStream', 'void', [])
+    cls.add_method('InitializeStream', 
+                   'void', 
+                   [])
     ## rng-stream.h: void ns3::RngStream::ResetStartStream() [member function]
-    cls.add_method('ResetStartStream', 'void', [])
+    cls.add_method('ResetStartStream', 
+                   'void', 
+                   [])
     ## rng-stream.h: void ns3::RngStream::ResetStartSubstream() [member function]
-    cls.add_method('ResetStartSubstream', 'void', [])
+    cls.add_method('ResetStartSubstream', 
+                   'void', 
+                   [])
     ## rng-stream.h: void ns3::RngStream::ResetNextSubstream() [member function]
-    cls.add_method('ResetNextSubstream', 'void', [])
+    cls.add_method('ResetNextSubstream', 
+                   'void', 
+                   [])
     ## rng-stream.h: void ns3::RngStream::ResetNthSubstream(uint32_t N) [member function]
-    cls.add_method('ResetNthSubstream', 'void', [param('uint32_t', 'N')])
+    cls.add_method('ResetNthSubstream', 
+                   'void', 
+                   [param('uint32_t', 'N')])
     ## rng-stream.h: void ns3::RngStream::SetAntithetic(bool a) [member function]
-    cls.add_method('SetAntithetic', 'void', [param('bool', 'a')])
+    cls.add_method('SetAntithetic', 
+                   'void', 
+                   [param('bool', 'a')])
     ## rng-stream.h: void ns3::RngStream::IncreasedPrecis(bool incp) [member function]
-    cls.add_method('IncreasedPrecis', 'void', [param('bool', 'incp')])
+    cls.add_method('IncreasedPrecis', 
+                   'void', 
+                   [param('bool', 'incp')])
     ## rng-stream.h: bool ns3::RngStream::SetSeeds(uint32_t const * seed) [member function]
-    cls.add_method('SetSeeds', 'bool', [param('uint32_t *', 'seed', transfer_ownership=False, is_const=True)])
+    cls.add_method('SetSeeds', 
+                   'bool', 
+                   [param('uint32_t *', 'seed', transfer_ownership=False, is_const=True)])
     ## rng-stream.h: void ns3::RngStream::AdvanceState(int32_t e, int32_t c) [member function]
-    cls.add_method('AdvanceState', 'void', [param('int32_t', 'e'), param('int32_t', 'c')])
+    cls.add_method('AdvanceState', 
+                   'void', 
+                   [param('int32_t', 'e'), param('int32_t', 'c')])
     ## rng-stream.h: void ns3::RngStream::GetState(uint32_t * seed) const [member function]
-    cls.add_method('GetState', 'void', [param('uint32_t *', 'seed')], is_const=True)
+    cls.add_method('GetState', 
+                   'void', 
+                   [param('uint32_t *', 'seed')], 
+                   is_const=True)
     ## rng-stream.h: double ns3::RngStream::RandU01() [member function]
-    cls.add_method('RandU01', 'double', [])
+    cls.add_method('RandU01', 
+                   'double', 
+                   [])
     ## rng-stream.h: int32_t ns3::RngStream::RandInt(int32_t i, int32_t j) [member function]
-    cls.add_method('RandInt', 'int32_t', [param('int32_t', 'i'), param('int32_t', 'j')])
+    cls.add_method('RandInt', 
+                   'int32_t', 
+                   [param('int32_t', 'i'), param('int32_t', 'j')])
     ## rng-stream.h: static bool ns3::RngStream::SetPackageSeed(uint32_t const * seed) [member function]
-    cls.add_method('SetPackageSeed', 'bool', [param('uint32_t *', 'seed', transfer_ownership=False, is_const=True)], is_static=True)
+    cls.add_method('SetPackageSeed', 
+                   'bool', 
+                   [param('uint32_t *', 'seed', transfer_ownership=False, is_const=True)], 
+                   is_static=True)
     ## rng-stream.h: static bool ns3::RngStream::CheckSeed(uint32_t const * seed) [member function]
-    cls.add_method('CheckSeed', 'bool', [param('uint32_t *', 'seed', transfer_ownership=False, is_const=True)], is_static=True)
+    cls.add_method('CheckSeed', 
+                   'bool', 
+                   [param('uint32_t *', 'seed', transfer_ownership=False, is_const=True)], 
+                   is_static=True)
     return
 
 def register_Ns3LogNormalVariable_methods(root_module, cls):
     ## random-variable.h: ns3::LogNormalVariable::LogNormalVariable(double mu, double sigma) [constructor]
-    cls.add_constructor([param('double', 'mu'), param('double', 'sigma')], visibility='public')
+    cls.add_constructor([param('double', 'mu'), param('double', 'sigma')])
     ## random-variable.h: static double ns3::LogNormalVariable::GetSingleValue(double mu, double sigma) [member function]
-    cls.add_method('GetSingleValue', 'double', [param('double', 'mu'), param('double', 'sigma')], is_static=True)
+    cls.add_method('GetSingleValue', 
+                   'double', 
+                   [param('double', 'mu'), param('double', 'sigma')], 
+                   is_static=True)
     return
 
 def register_Ns3IntEmpiricalVariable_methods(root_module, cls):
     ## random-variable.h: ns3::IntEmpiricalVariable::IntEmpiricalVariable() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     return
 
 def register_Ns3PointerChecker_methods(root_module, cls):
     ## pointer.h: ns3::TypeId ns3::PointerChecker::GetPointeeTypeId() const [member function]
-    cls.add_method('GetPointeeTypeId', 'ns3::TypeId', [], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('GetPointeeTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     cls.add_constructor([])
     return
 
 def register_Ns3WeibullVariable_methods(root_module, cls):
     ## random-variable.h: ns3::WeibullVariable::WeibullVariable() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(double m) [constructor]
-    cls.add_constructor([param('double', 'm')], visibility='public')
+    cls.add_constructor([param('double', 'm')])
     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(double m, double s) [constructor]
-    cls.add_constructor([param('double', 'm'), param('double', 's')], visibility='public')
+    cls.add_constructor([param('double', 'm'), param('double', 's')])
     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(double m, double s, double b) [constructor]
-    cls.add_constructor([param('double', 'm'), param('double', 's'), param('double', 'b')], visibility='public')
+    cls.add_constructor([param('double', 'm'), param('double', 's'), param('double', 'b')])
     ## random-variable.h: static double ns3::WeibullVariable::GetSingleValue(double m, double s, double b=0) [member function]
-    cls.add_method('GetSingleValue', 'double', [param('double', 'm'), param('double', 's'), param('double', 'b', default_value='0')], is_static=True)
+    cls.add_method('GetSingleValue', 
+                   'double', 
+                   [param('double', 'm'), param('double', 's'), param('double', 'b', default_value='0')], 
+                   is_static=True)
     return
 
 def register_Ns3CallbackBase_methods(root_module, cls):
     ## callback.h: ns3::CallbackBase::CallbackBase() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## callback.h: ns3::Ptr<ns3::CallbackImplBase> ns3::CallbackBase::GetImpl() const [member function]
-    cls.add_method('GetImpl', 'ns3::Ptr< ns3::CallbackImplBase >', [], is_const=True)
+    cls.add_method('GetImpl', 
+                   'ns3::Ptr< ns3::CallbackImplBase >', 
+                   [], 
+                   is_const=True)
     ## callback.h: ns3::CallbackBase::CallbackBase(ns3::Ptr<ns3::CallbackImplBase> impl) [constructor]
-    cls.add_constructor([param('ns3::Ptr< ns3::CallbackImplBase >', 'impl')], visibility='protected')
+    cls.add_constructor([param('ns3::Ptr< ns3::CallbackImplBase >', 'impl')], 
+                        visibility='protected')
     return
 
 def register_Ns3ExponentialVariable_methods(root_module, cls):
     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable(double m) [constructor]
-    cls.add_constructor([param('double', 'm')], visibility='public')
+    cls.add_constructor([param('double', 'm')])
     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable(double m, double b) [constructor]
-    cls.add_constructor([param('double', 'm'), param('double', 'b')], visibility='public')
+    cls.add_constructor([param('double', 'm'), param('double', 'b')])
     ## random-variable.h: static double ns3::ExponentialVariable::GetSingleValue(double m, double b=0) [member function]
-    cls.add_method('GetSingleValue', 'double', [param('double', 'm'), param('double', 'b', default_value='0')], is_static=True)
+    cls.add_method('GetSingleValue', 
+                   'double', 
+                   [param('double', 'm'), param('double', 'b', default_value='0')], 
+                   is_static=True)
     return
 
 def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Ns3Mac48Address_Ns3Empty_Ns3Empty_methods(root_module, cls):
     ## traced-callback.h: ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Mac48Address, ns3::empty, ns3::empty>::TracedCallback() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Mac48Address, ns3::empty, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
-    cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
+    cls.add_method('ConnectWithoutContext', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True)])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Mac48Address, ns3::empty, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
-    cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
+    cls.add_method('Connect', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Mac48Address, ns3::empty, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
-    cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
+    cls.add_method('DisconnectWithoutContext', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True)])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Mac48Address, ns3::empty, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
-    cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
+    cls.add_method('Disconnect', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
     return
 
 def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls):
     ## traced-callback.h: ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::empty, ns3::empty, ns3::empty>::TracedCallback() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::empty, ns3::empty, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
-    cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
+    cls.add_method('ConnectWithoutContext', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True)])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::empty, ns3::empty, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
-    cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
+    cls.add_method('Connect', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::empty, ns3::empty, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
-    cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
+    cls.add_method('DisconnectWithoutContext', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True)])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::empty, ns3::empty, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
-    cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
+    cls.add_method('Disconnect', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
     return
 
 def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Ns3Address_const__amp___Ns3Empty_Ns3Empty_methods(root_module, cls):
     ## traced-callback.h: ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Address const&, ns3::empty, ns3::empty>::TracedCallback() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Address const&, ns3::empty, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
-    cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
+    cls.add_method('ConnectWithoutContext', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True)])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Address const&, ns3::empty, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
-    cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
+    cls.add_method('Connect', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Address const&, ns3::empty, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
-    cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
+    cls.add_method('DisconnectWithoutContext', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True)])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Address const&, ns3::empty, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
-    cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
+    cls.add_method('Disconnect', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
     return
 
 def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Unsigned_int_Ns3Empty_Ns3Empty_methods(root_module, cls):
     ## traced-callback.h: ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, unsigned int, ns3::empty, ns3::empty>::TracedCallback() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, unsigned int, ns3::empty, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
-    cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
+    cls.add_method('ConnectWithoutContext', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True)])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, unsigned int, ns3::empty, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
-    cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
+    cls.add_method('Connect', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, unsigned int, ns3::empty, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
-    cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
+    cls.add_method('DisconnectWithoutContext', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True)])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, unsigned int, ns3::empty, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
-    cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
+    cls.add_method('Disconnect', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
     return
 
 def register_Ns3TracedCallback__Ns3Ptr__lt__ns3MobilityModel_const__gt___Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls):
     ## traced-callback.h: ns3::TracedCallback<ns3::Ptr<ns3::MobilityModel const>, ns3::empty, ns3::empty, ns3::empty>::TracedCallback() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::MobilityModel const>, ns3::empty, ns3::empty, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
-    cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
+    cls.add_method('ConnectWithoutContext', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True)])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::MobilityModel const>, ns3::empty, ns3::empty, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
-    cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
+    cls.add_method('Connect', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::MobilityModel const>, ns3::empty, ns3::empty, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
-    cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
+    cls.add_method('DisconnectWithoutContext', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True)])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::MobilityModel const>, ns3::empty, ns3::empty, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
-    cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
+    cls.add_method('Disconnect', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
     return
 
 def register_Ns3TracedCallback__Ns3TimeUnit__lt__1__gt___Ns3TimeUnit__lt__1__gt___Ns3WifiPhyState_Ns3Empty_methods(root_module, cls):
     ## traced-callback.h: ns3::TracedCallback<ns3::TimeUnit<1>, ns3::TimeUnit<1>, ns3::WifiPhy::State, ns3::empty>::TracedCallback() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## traced-callback.h: void ns3::TracedCallback<ns3::TimeUnit<1>, ns3::TimeUnit<1>, ns3::WifiPhy::State, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
-    cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
+    cls.add_method('ConnectWithoutContext', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True)])
     ## traced-callback.h: void ns3::TracedCallback<ns3::TimeUnit<1>, ns3::TimeUnit<1>, ns3::WifiPhy::State, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
-    cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
+    cls.add_method('Connect', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
     ## traced-callback.h: void ns3::TracedCallback<ns3::TimeUnit<1>, ns3::TimeUnit<1>, ns3::WifiPhy::State, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
-    cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
+    cls.add_method('DisconnectWithoutContext', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True)])
     ## traced-callback.h: void ns3::TracedCallback<ns3::TimeUnit<1>, ns3::TimeUnit<1>, ns3::WifiPhy::State, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
-    cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
+    cls.add_method('Disconnect', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
     return
 
 def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Ns3WifiMode_Ns3WifiPreamble_Unsigned_char_methods(root_module, cls):
     ## traced-callback.h: ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::WifiMode, ns3::WifiPreamble, unsigned char>::TracedCallback() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::WifiMode, ns3::WifiPreamble, unsigned char>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
-    cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
+    cls.add_method('ConnectWithoutContext', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True)])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::WifiMode, ns3::WifiPreamble, unsigned char>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
-    cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
+    cls.add_method('Connect', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::WifiMode, ns3::WifiPreamble, unsigned char>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
-    cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
+    cls.add_method('DisconnectWithoutContext', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True)])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::WifiMode, ns3::WifiPreamble, unsigned char>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
-    cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
+    cls.add_method('Disconnect', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
     return
 
 def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Double_Ns3Empty_Ns3Empty_methods(root_module, cls):
     ## traced-callback.h: ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::empty, ns3::empty>::TracedCallback() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::empty, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
-    cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
+    cls.add_method('ConnectWithoutContext', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True)])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::empty, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
-    cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
+    cls.add_method('Connect', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::empty, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
-    cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
+    cls.add_method('DisconnectWithoutContext', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True)])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::empty, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
-    cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
+    cls.add_method('Disconnect', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
     return
 
 def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Double_Ns3WifiMode_Ns3WifiPreamble_methods(root_module, cls):
     ## traced-callback.h: ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::WifiMode, ns3::WifiPreamble>::TracedCallback() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::WifiMode, ns3::WifiPreamble>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
-    cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
+    cls.add_method('ConnectWithoutContext', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True)])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::WifiMode, ns3::WifiPreamble>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
-    cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
+    cls.add_method('Connect', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::WifiMode, ns3::WifiPreamble>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
-    cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
+    cls.add_method('DisconnectWithoutContext', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True)])
     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::WifiMode, ns3::WifiPreamble>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
-    cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
+    cls.add_method('Disconnect', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
     return
 
 def register_Ns3TracedCallback__Unsigned_int_Unsigned_int_Ns3Empty_Ns3Empty_methods(root_module, cls):
     ## traced-callback.h: ns3::TracedCallback<unsigned int, unsigned int, ns3::empty, ns3::empty>::TracedCallback() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## traced-callback.h: void ns3::TracedCallback<unsigned int, unsigned int, ns3::empty, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
-    cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
+    cls.add_method('ConnectWithoutContext', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True)])
     ## traced-callback.h: void ns3::TracedCallback<unsigned int, unsigned int, ns3::empty, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
-    cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
+    cls.add_method('Connect', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
     ## traced-callback.h: void ns3::TracedCallback<unsigned int, unsigned int, ns3::empty, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
-    cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
+    cls.add_method('DisconnectWithoutContext', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True)])
     ## traced-callback.h: void ns3::TracedCallback<unsigned int, unsigned int, ns3::empty, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
-    cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
+    cls.add_method('Disconnect', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
     return
 
 def register_Ns3DeterministicVariable_methods(root_module, cls):
     ## random-variable.h: ns3::DeterministicVariable::DeterministicVariable(double * d, uint32_t c) [constructor]
-    cls.add_constructor([param('double *', 'd'), param('uint32_t', 'c')], visibility='public')
+    cls.add_constructor([param('double *', 'd'), param('uint32_t', 'c')])
     return
 
 def register_Ns3AttributeList_methods(root_module, cls):
     ## attribute-list.h: ns3::AttributeList::AttributeList() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## attribute-list.h: ns3::AttributeList::AttributeList(ns3::AttributeList const & o) [copy constructor]
-    cls.add_constructor([param('ns3::AttributeList&', 'o', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::AttributeList&', 'o', is_const=True)])
     ## attribute-list.h: void ns3::AttributeList::Set(std::string name, ns3::AttributeValue const & value) [member function]
-    cls.add_method('Set', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
+    cls.add_method('Set', 
+                   'void', 
+                   [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
     ## attribute-list.h: bool ns3::AttributeList::SetFailSafe(std::string name, ns3::AttributeValue const & value) [member function]
-    cls.add_method('SetFailSafe', 'bool', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
+    cls.add_method('SetFailSafe', 
+                   'bool', 
+                   [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
     ## attribute-list.h: void ns3::AttributeList::SetWithTid(ns3::TypeId tid, std::string name, ns3::AttributeValue const & value) [member function]
-    cls.add_method('SetWithTid', 'void', [param('ns3::TypeId', 'tid'), param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
+    cls.add_method('SetWithTid', 
+                   'void', 
+                   [param('ns3::TypeId', 'tid'), param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
     ## attribute-list.h: void ns3::AttributeList::Reset() [member function]
-    cls.add_method('Reset', 'void', [])
+    cls.add_method('Reset', 
+                   'void', 
+                   [])
     ## attribute-list.h: static ns3::AttributeList * ns3::AttributeList::GetGlobal() [member function]
-    cls.add_method('GetGlobal', 'ns3::AttributeList *', [], is_static=True)
+    cls.add_method('GetGlobal', 
+                   'ns3::AttributeList *', 
+                   [], 
+                   is_static=True)
     ## attribute-list.h: std::string ns3::AttributeList::SerializeToString() const [member function]
-    cls.add_method('SerializeToString', 'std::string', [], is_const=True)
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [], 
+                   is_const=True)
     ## attribute-list.h: bool ns3::AttributeList::DeserializeFromString(std::string value) [member function]
-    cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value')])
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value')])
     return
 
 def register_Ns3AttributeValue_methods(root_module, cls):
     ## attribute.h: ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::AttributeValue&', 'arg0', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::AttributeValue&', 'arg0', is_const=True)])
     ## attribute.h: ns3::AttributeValue::AttributeValue() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## attribute.h: ns3::Ptr<ns3::AttributeValue> ns3::AttributeValue::Copy() const [member function]
-    cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     ## attribute.h: std::string ns3::AttributeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
-    cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     ## attribute.h: bool ns3::AttributeValue::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_pure_virtual=True, is_virtual=True)
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_pure_virtual=True, is_virtual=True)
     return
 
 def register_Ns3UniformVariable_methods(root_module, cls):
     ## random-variable.h: ns3::UniformVariable::UniformVariable() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## random-variable.h: ns3::UniformVariable::UniformVariable(double s, double l) [constructor]
-    cls.add_constructor([param('double', 's'), param('double', 'l')], visibility='public')
+    cls.add_constructor([param('double', 's'), param('double', 'l')])
     ## random-variable.h: static double ns3::UniformVariable::GetSingleValue(double s, double l) [member function]
-    cls.add_method('GetSingleValue', 'double', [param('double', 's'), param('double', 'l')], is_static=True)
+    cls.add_method('GetSingleValue', 
+                   'double', 
+                   [param('double', 's'), param('double', 'l')], 
+                   is_static=True)
     return
 
 def register_Ns3Object_methods(root_module, cls):
     ## object.h: static ns3::TypeId ns3::Object::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## object.h: ns3::Object::Object() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## object.h: ns3::TypeId ns3::Object::GetInstanceTypeId() const [member function]
-    cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True)
+    cls.add_method('GetInstanceTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## object.h: ns3::Ptr<ns3::Object> ns3::Object::GetObject(ns3::TypeId tid) const [member function]
-    cls.add_method('GetObject', 'ns3::Ptr< ns3::Object >', [param('ns3::TypeId', 'tid')], is_const=True, template_parameters=['ns3::Object'], custom_template_method_name='GetObject')
+    cls.add_method('GetObject', 
+                   'ns3::Ptr< ns3::Object >', 
+                   [param('ns3::TypeId', 'tid')], 
+                   is_const=True, template_parameters=['ns3::Object'], custom_template_method_name='GetObject')
     ## object.h: void ns3::Object::Dispose() [member function]
-    cls.add_method('Dispose', 'void', [])
+    cls.add_method('Dispose', 
+                   'void', 
+                   [])
     ## object.h: void ns3::Object::AggregateObject(ns3::Ptr<ns3::Object> other) [member function]
-    cls.add_method('AggregateObject', 'void', [param('ns3::Ptr< ns3::Object >', 'other')])
+    cls.add_method('AggregateObject', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Object >', 'other')])
     ## object.h: ns3::Object::AggregateIterator ns3::Object::GetAggregateIterator() const [member function]
-    cls.add_method('GetAggregateIterator', 'ns3::Object::AggregateIterator', [], is_const=True)
+    cls.add_method('GetAggregateIterator', 
+                   'ns3::Object::AggregateIterator', 
+                   [], 
+                   is_const=True)
     ## object.h: void ns3::Object::DoDispose() [member function]
-    cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True)
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
     ## object.h: ns3::Object::Object(ns3::Object const & o) [copy constructor]
-    cls.add_constructor([param('ns3::Object&', 'o', is_const=True)], visibility='protected')
+    cls.add_constructor([param('ns3::Object&', 'o', is_const=True)], 
+                        visibility='protected')
     return
 
 def register_Ns3ObjectAggregateIterator_methods(root_module, cls):
     ## object.h: ns3::Object::AggregateIterator::AggregateIterator() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## object.h: bool ns3::Object::AggregateIterator::HasNext() const [member function]
-    cls.add_method('HasNext', 'bool', [], is_const=True)
+    cls.add_method('HasNext', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## object.h: ns3::Ptr<ns3::Object const> ns3::Object::AggregateIterator::Next() [member function]
-    cls.add_method('Next', 'ns3::Ptr< ns3::Object const >', [])
+    cls.add_method('Next', 
+                   'ns3::Ptr< ns3::Object const >', 
+                   [])
+    return
+
+def register_Ns3SystemCondition_methods(root_module, cls):
+    ## system-condition.h: ns3::SystemCondition::SystemCondition() [constructor]
+    cls.add_constructor([])
+    ## system-condition.h: void ns3::SystemCondition::SetCondition(bool condition) [member function]
+    cls.add_method('SetCondition', 
+                   'void', 
+                   [param('bool', 'condition')])
+    ## system-condition.h: bool ns3::SystemCondition::GetCondition() [member function]
+    cls.add_method('GetCondition', 
+                   'bool', 
+                   [])
+    ## system-condition.h: void ns3::SystemCondition::Signal() [member function]
+    cls.add_method('Signal', 
+                   'void', 
+                   [])
+    ## system-condition.h: void ns3::SystemCondition::Broadcast() [member function]
+    cls.add_method('Broadcast', 
+                   'void', 
+                   [])
+    ## system-condition.h: void ns3::SystemCondition::Wait() [member function]
+    cls.add_method('Wait', 
+                   'void', 
+                   [])
+    ## system-condition.h: bool ns3::SystemCondition::TimedWait(uint64_t ns) [member function]
+    cls.add_method('TimedWait', 
+                   'bool', 
+                   [param('uint64_t', 'ns')])
     return
 
 def register_Ns3SequentialVariable_methods(root_module, cls):
     ## random-variable.h: ns3::SequentialVariable::SequentialVariable(double f, double l, double i=1, uint32_t c=1) [constructor]
-    cls.add_constructor([param('double', 'f'), param('double', 'l'), param('double', 'i', default_value='1'), param('uint32_t', 'c', default_value='1')], visibility='public')
+    cls.add_constructor([param('double', 'f'), param('double', 'l'), param('double', 'i', default_value='1'), param('uint32_t', 'c', default_value='1')])
     ## random-variable.h: ns3::SequentialVariable::SequentialVariable(double f, double l, ns3::RandomVariable const & i, uint32_t c=1) [constructor]
-    cls.add_constructor([param('double', 'f'), param('double', 'l'), param('ns3::RandomVariable&', 'i', is_const=True), param('uint32_t', 'c', default_value='1')], visibility='public')
+    cls.add_constructor([param('double', 'f'), param('double', 'l'), param('ns3::RandomVariable&', 'i', is_const=True), param('uint32_t', 'c', default_value='1')])
     return
 
 def register_Ns3ObjectVectorChecker_methods(root_module, cls):
     ## object-vector.h: ns3::TypeId ns3::ObjectVectorChecker::GetItemTypeId() const [member function]
-    cls.add_method('GetItemTypeId', 'ns3::TypeId', [], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('GetItemTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     cls.add_constructor([])
     return
 
@@ -963,21 +1504,42 @@
 
 def register_Ns3ObjectVectorValue_methods(root_module, cls):
     ## object-vector.h: ns3::ObjectVectorValue::ObjectVectorValue() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## object-vector.h: __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Object>*,std::vector<ns3::Ptr<ns3::Object>, std::allocator<ns3::Ptr<ns3::Object> > > > ns3::ObjectVectorValue::Begin() const [member function]
-    cls.add_method('Begin', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Object >, std::vector< ns3::Ptr< ns3::Object >, std::allocator< ns3::Ptr< ns3::Object > > > >', [], is_const=True)
+    cls.add_method('Begin', 
+                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Object >, std::vector< ns3::Ptr< ns3::Object >, std::allocator< ns3::Ptr< ns3::Object > > > >', 
+                   [], 
+                   is_const=True)
     ## object-vector.h: __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Object>*,std::vector<ns3::Ptr<ns3::Object>, std::allocator<ns3::Ptr<ns3::Object> > > > ns3::ObjectVectorValue::End() const [member function]
-    cls.add_method('End', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Object >, std::vector< ns3::Ptr< ns3::Object >, std::allocator< ns3::Ptr< ns3::Object > > > >', [], is_const=True)
+    cls.add_method('End', 
+                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Object >, std::vector< ns3::Ptr< ns3::Object >, std::allocator< ns3::Ptr< ns3::Object > > > >', 
+                   [], 
+                   is_const=True)
     ## object-vector.h: uint32_t ns3::ObjectVectorValue::GetN() const [member function]
-    cls.add_method('GetN', 'uint32_t', [], is_const=True)
+    cls.add_method('GetN', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## object-vector.h: ns3::Ptr<ns3::Object> ns3::ObjectVectorValue::Get(uint32_t i) const [member function]
-    cls.add_method('Get', 'ns3::Ptr< ns3::Object >', [param('uint32_t', 'i')], is_const=True)
+    cls.add_method('Get', 
+                   'ns3::Ptr< ns3::Object >', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
     ## object-vector.h: ns3::Ptr<ns3::AttributeValue> ns3::ObjectVectorValue::Copy() const [member function]
-    cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## object-vector.h: std::string ns3::ObjectVectorValue::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)
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, is_virtual=True)
     ## object-vector.h: bool ns3::ObjectVectorValue::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)
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_virtual=True)
     return
 
 def register_Ns3BooleanChecker_methods(root_module, cls):
@@ -986,54 +1548,100 @@
 
 def register_Ns3UintegerValue_methods(root_module, cls):
     ## uinteger.h: ns3::UintegerValue::UintegerValue() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## uinteger.h: ns3::UintegerValue::UintegerValue(uint64_t const & value) [constructor]
-    cls.add_constructor([param('uint64_t&', 'value', is_const=True)], visibility='public')
+    cls.add_constructor([param('uint64_t&', 'value', is_const=True)])
     ## uinteger.h: void ns3::UintegerValue::Set(uint64_t const & value) [member function]
-    cls.add_method('Set', 'void', [param('uint64_t&', 'value', is_const=True)])
+    cls.add_method('Set', 
+                   'void', 
+                   [param('uint64_t&', 'value', is_const=True)])
     ## uinteger.h: uint64_t ns3::UintegerValue::Get() const [member function]
-    cls.add_method('Get', 'uint64_t', [], is_const=True)
+    cls.add_method('Get', 
+                   'uint64_t', 
+                   [], 
+                   is_const=True)
     ## uinteger.h: ns3::Ptr<ns3::AttributeValue> ns3::UintegerValue::Copy() const [member function]
-    cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## uinteger.h: std::string ns3::UintegerValue::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)
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, is_virtual=True)
     ## uinteger.h: bool ns3::UintegerValue::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)
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_virtual=True)
     return
 
 def register_Ns3ObjectVectorAccessor_methods(root_module, cls):
     ## object-vector.h: bool ns3::ObjectVectorAccessor::Set(ns3::ObjectBase * object, ns3::AttributeValue const & value) const [member function]
-    cls.add_method('Set', 'bool', [param('ns3::ObjectBase *', 'object'), param('ns3::AttributeValue&', 'value', is_const=True)], is_const=True, is_virtual=True)
+    cls.add_method('Set', 
+                   'bool', 
+                   [param('ns3::ObjectBase *', 'object'), param('ns3::AttributeValue&', 'value', is_const=True)], 
+                   is_const=True, is_virtual=True)
     ## object-vector.h: bool ns3::ObjectVectorAccessor::Get(ns3::ObjectBase const * object, ns3::AttributeValue & value) const [member function]
-    cls.add_method('Get', 'bool', [param('ns3::ObjectBase *', 'object', transfer_ownership=False, is_const=True), param('ns3::AttributeValue&', 'value')], is_const=True, is_virtual=True)
+    cls.add_method('Get', 
+                   'bool', 
+                   [param('ns3::ObjectBase *', 'object', transfer_ownership=False, is_const=True), param('ns3::AttributeValue&', 'value')], 
+                   is_const=True, is_virtual=True)
     ## object-vector.h: bool ns3::ObjectVectorAccessor::HasGetter() const [member function]
-    cls.add_method('HasGetter', 'bool', [], is_const=True, is_virtual=True)
+    cls.add_method('HasGetter', 
+                   'bool', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## object-vector.h: bool ns3::ObjectVectorAccessor::HasSetter() const [member function]
-    cls.add_method('HasSetter', 'bool', [], is_const=True, is_virtual=True)
+    cls.add_method('HasSetter', 
+                   'bool', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## object-vector.h: bool ns3::ObjectVectorAccessor::DoGetN(ns3::ObjectBase const * object, uint32_t * n) const [member function]
-    cls.add_method('DoGetN', 'bool', [param('ns3::ObjectBase *', 'object', transfer_ownership=False, is_const=True), param('uint32_t *', 'n')], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
+    cls.add_method('DoGetN', 
+                   'bool', 
+                   [param('ns3::ObjectBase *', 'object', transfer_ownership=False, is_const=True), param('uint32_t *', 'n')], 
+                   is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
     ## object-vector.h: ns3::Ptr<ns3::Object> ns3::ObjectVectorAccessor::DoGet(ns3::ObjectBase const * object, uint32_t i) const [member function]
-    cls.add_method('DoGet', 'ns3::Ptr< ns3::Object >', [param('ns3::ObjectBase *', 'object', transfer_ownership=False, is_const=True), param('uint32_t', 'i')], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
+    cls.add_method('DoGet', 
+                   'ns3::Ptr< ns3::Object >', 
+                   [param('ns3::ObjectBase *', 'object', transfer_ownership=False, is_const=True), param('uint32_t', 'i')], 
+                   is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
     cls.add_constructor([])
     return
 
 def register_Ns3PointerValue_methods(root_module, cls):
     ## pointer.h: ns3::PointerValue::PointerValue(ns3::PointerValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::PointerValue&', 'arg0', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::PointerValue&', 'arg0', is_const=True)])
     ## pointer.h: ns3::PointerValue::PointerValue() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## pointer.h: ns3::PointerValue::PointerValue(ns3::Ptr<ns3::Object> object) [constructor]
-    cls.add_constructor([param('ns3::Ptr< ns3::Object >', 'object')], visibility='public')
+    cls.add_constructor([param('ns3::Ptr< ns3::Object >', 'object')])
     ## pointer.h: void ns3::PointerValue::SetObject(ns3::Ptr<ns3::Object> object) [member function]
-    cls.add_method('SetObject', 'void', [param('ns3::Ptr< ns3::Object >', 'object')])
+    cls.add_method('SetObject', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Object >', 'object')])
     ## pointer.h: ns3::Ptr<ns3::Object> ns3::PointerValue::GetObject() const [member function]
-    cls.add_method('GetObject', 'ns3::Ptr< ns3::Object >', [], is_const=True)
+    cls.add_method('GetObject', 
+                   'ns3::Ptr< ns3::Object >', 
+                   [], 
+                   is_const=True)
     ## pointer.h: ns3::Ptr<ns3::AttributeValue> ns3::PointerValue::Copy() const [member function]
-    cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## pointer.h: std::string ns3::PointerValue::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)
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, is_virtual=True)
     ## pointer.h: bool ns3::PointerValue::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)
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_virtual=True)
     return
 
 def register_Ns3ObjectFactoryChecker_methods(root_module, cls):
@@ -1046,225 +1654,409 @@
 
 def register_Ns3DoubleValue_methods(root_module, cls):
     ## double.h: ns3::DoubleValue::DoubleValue() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## double.h: ns3::DoubleValue::DoubleValue(double const & value) [constructor]
-    cls.add_constructor([param('double&', 'value', is_const=True)], visibility='public')
+    cls.add_constructor([param('double&', 'value', is_const=True)])
     ## double.h: void ns3::DoubleValue::Set(double const & value) [member function]
-    cls.add_method('Set', 'void', [param('double&', 'value', is_const=True)])
+    cls.add_method('Set', 
+                   'void', 
+                   [param('double&', 'value', is_const=True)])
     ## double.h: double ns3::DoubleValue::Get() const [member function]
-    cls.add_method('Get', 'double', [], is_const=True)
+    cls.add_method('Get', 
+                   'double', 
+                   [], 
+                   is_const=True)
     ## double.h: ns3::Ptr<ns3::AttributeValue> ns3::DoubleValue::Copy() const [member function]
-    cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## double.h: std::string ns3::DoubleValue::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)
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, is_virtual=True)
     ## double.h: bool ns3::DoubleValue::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)
-    return
-
-def register_Ns3StringValue_methods(root_module, cls):
-    ## string.h: ns3::StringValue::StringValue() [constructor]
-    cls.add_constructor([], visibility='public')
-    ## string.h: ns3::StringValue::StringValue(std::string const & value) [constructor]
-    cls.add_constructor([param('std::string&', 'value', is_const=True)], visibility='public')
-    ## string.h: void ns3::StringValue::Set(std::string const & value) [member function]
-    cls.add_method('Set', 'void', [param('std::string&', 'value', is_const=True)])
-    ## string.h: std::string ns3::StringValue::Get() const [member function]
-    cls.add_method('Get', 'std::string', [], is_const=True)
-    ## string.h: ns3::Ptr<ns3::AttributeValue> ns3::StringValue::Copy() const [member function]
-    cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
-    ## string.h: std::string ns3::StringValue::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)
-    ## string.h: bool ns3::StringValue::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)
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_virtual=True)
     return
 
 def register_Ns3TypeIdValue_methods(root_module, cls):
     ## type-id.h: ns3::TypeIdValue::TypeIdValue() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## type-id.h: ns3::TypeIdValue::TypeIdValue(ns3::TypeId const & value) [constructor]
-    cls.add_constructor([param('ns3::TypeId&', 'value', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::TypeId&', 'value', is_const=True)])
     ## type-id.h: void ns3::TypeIdValue::Set(ns3::TypeId const & value) [member function]
-    cls.add_method('Set', 'void', [param('ns3::TypeId&', 'value', is_const=True)])
+    cls.add_method('Set', 
+                   'void', 
+                   [param('ns3::TypeId&', 'value', is_const=True)])
     ## type-id.h: ns3::TypeId ns3::TypeIdValue::Get() const [member function]
-    cls.add_method('Get', 'ns3::TypeId', [], is_const=True)
+    cls.add_method('Get', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_const=True)
     ## type-id.h: ns3::Ptr<ns3::AttributeValue> ns3::TypeIdValue::Copy() const [member function]
-    cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## type-id.h: std::string ns3::TypeIdValue::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)
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, is_virtual=True)
     ## type-id.h: bool ns3::TypeIdValue::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)
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_virtual=True)
     return
 
 def register_Ns3EnumValue_methods(root_module, cls):
     ## enum.h: ns3::EnumValue::EnumValue() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## enum.h: ns3::EnumValue::EnumValue(int v) [constructor]
-    cls.add_constructor([param('int', 'v')], visibility='public')
+    cls.add_constructor([param('int', 'v')])
     ## enum.h: void ns3::EnumValue::Set(int v) [member function]
-    cls.add_method('Set', 'void', [param('int', 'v')])
+    cls.add_method('Set', 
+                   'void', 
+                   [param('int', 'v')])
     ## enum.h: int ns3::EnumValue::Get() const [member function]
-    cls.add_method('Get', 'int', [], is_const=True)
+    cls.add_method('Get', 
+                   'int', 
+                   [], 
+                   is_const=True)
     ## enum.h: ns3::Ptr<ns3::AttributeValue> ns3::EnumValue::Copy() const [member function]
-    cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## enum.h: std::string ns3::EnumValue::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)
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, is_virtual=True)
     ## enum.h: bool ns3::EnumValue::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)
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_virtual=True)
     return
 
 def register_Ns3RandomVariableValue_methods(root_module, cls):
     ## random-variable.h: ns3::RandomVariableValue::RandomVariableValue() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## random-variable.h: ns3::RandomVariableValue::RandomVariableValue(ns3::RandomVariable const & value) [constructor]
-    cls.add_constructor([param('ns3::RandomVariable&', 'value', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::RandomVariable&', 'value', is_const=True)])
     ## random-variable.h: void ns3::RandomVariableValue::Set(ns3::RandomVariable const & value) [member function]
-    cls.add_method('Set', 'void', [param('ns3::RandomVariable&', 'value', is_const=True)])
+    cls.add_method('Set', 
+                   'void', 
+                   [param('ns3::RandomVariable&', 'value', is_const=True)])
     ## random-variable.h: ns3::RandomVariable ns3::RandomVariableValue::Get() const [member function]
-    cls.add_method('Get', 'ns3::RandomVariable', [], is_const=True)
+    cls.add_method('Get', 
+                   'ns3::RandomVariable', 
+                   [], 
+                   is_const=True)
     ## random-variable.h: ns3::Ptr<ns3::AttributeValue> ns3::RandomVariableValue::Copy() const [member function]
-    cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## random-variable.h: std::string ns3::RandomVariableValue::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)
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, is_virtual=True)
     ## random-variable.h: bool ns3::RandomVariableValue::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)
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_virtual=True)
     return
 
 def register_Ns3ObjectFactoryValue_methods(root_module, cls):
     ## object-factory.h: ns3::ObjectFactoryValue::ObjectFactoryValue() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## object-factory.h: ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactory const & value) [constructor]
-    cls.add_constructor([param('ns3::ObjectFactory&', 'value', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::ObjectFactory&', 'value', is_const=True)])
     ## object-factory.h: void ns3::ObjectFactoryValue::Set(ns3::ObjectFactory const & value) [member function]
-    cls.add_method('Set', 'void', [param('ns3::ObjectFactory&', 'value', is_const=True)])
+    cls.add_method('Set', 
+                   'void', 
+                   [param('ns3::ObjectFactory&', 'value', is_const=True)])
     ## object-factory.h: ns3::ObjectFactory ns3::ObjectFactoryValue::Get() const [member function]
-    cls.add_method('Get', 'ns3::ObjectFactory', [], is_const=True)
+    cls.add_method('Get', 
+                   'ns3::ObjectFactory', 
+                   [], 
+                   is_const=True)
     ## object-factory.h: ns3::Ptr<ns3::AttributeValue> ns3::ObjectFactoryValue::Copy() const [member function]
-    cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## object-factory.h: std::string ns3::ObjectFactoryValue::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)
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, is_virtual=True)
     ## object-factory.h: bool ns3::ObjectFactoryValue::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)
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_virtual=True)
     return
 
 def register_Ns3IntegerValue_methods(root_module, cls):
     ## integer.h: ns3::IntegerValue::IntegerValue() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## integer.h: ns3::IntegerValue::IntegerValue(int64_t const & value) [constructor]
-    cls.add_constructor([param('int64_t&', 'value', is_const=True)], visibility='public')
+    cls.add_constructor([param('int64_t&', 'value', is_const=True)])
     ## integer.h: void ns3::IntegerValue::Set(int64_t const & value) [member function]
-    cls.add_method('Set', 'void', [param('int64_t&', 'value', is_const=True)])
+    cls.add_method('Set', 
+                   'void', 
+                   [param('int64_t&', 'value', is_const=True)])
     ## integer.h: int64_t ns3::IntegerValue::Get() const [member function]
-    cls.add_method('Get', 'int64_t', [], is_const=True)
+    cls.add_method('Get', 
+                   'int64_t', 
+                   [], 
+                   is_const=True)
     ## integer.h: ns3::Ptr<ns3::AttributeValue> ns3::IntegerValue::Copy() const [member function]
-    cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## integer.h: std::string ns3::IntegerValue::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)
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, is_virtual=True)
     ## integer.h: bool ns3::IntegerValue::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)
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_virtual=True)
+    return
+
+def register_Ns3BooleanValue_methods(root_module, cls):
+    ## boolean.h: ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::BooleanValue&', 'arg0', is_const=True)])
+    ## boolean.h: ns3::BooleanValue::BooleanValue() [constructor]
+    cls.add_constructor([])
+    ## boolean.h: ns3::BooleanValue::BooleanValue(bool value) [constructor]
+    cls.add_constructor([param('bool', 'value')])
+    ## boolean.h: ns3::Ptr<ns3::AttributeValue> ns3::BooleanValue::Copy() const [member function]
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## boolean.h: bool ns3::BooleanValue::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)
+    ## boolean.h: bool ns3::BooleanValue::Get() const [member function]
+    cls.add_method('Get', 
+                   'bool', 
+                   [], 
+                   is_const=True)
+    ## boolean.h: std::string ns3::BooleanValue::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)
+    ## boolean.h: void ns3::BooleanValue::Set(bool value) [member function]
+    cls.add_method('Set', 
+                   'void', 
+                   [param('bool', 'value')])
+    cls.add_output_stream_operator()
+    return
+
+def register_Ns3StringValue_methods(root_module, cls):
+    ## string.h: ns3::StringValue::StringValue() [constructor]
+    cls.add_constructor([])
+    ## string.h: ns3::StringValue::StringValue(std::string const & value) [constructor]
+    cls.add_constructor([param('std::string&', 'value', is_const=True)])
+    ## string.h: void ns3::StringValue::Set(std::string const & value) [member function]
+    cls.add_method('Set', 
+                   'void', 
+                   [param('std::string&', 'value', is_const=True)])
+    ## string.h: std::string ns3::StringValue::Get() const [member function]
+    cls.add_method('Get', 
+                   'std::string', 
+                   [], 
+                   is_const=True)
+    ## string.h: ns3::Ptr<ns3::AttributeValue> ns3::StringValue::Copy() const [member function]
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## string.h: std::string ns3::StringValue::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)
+    ## string.h: bool ns3::StringValue::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)
     return
 
 def register_Ns3EmptyAttributeValue_methods(root_module, cls):
     ## attribute.h: ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::EmptyAttributeValue&', 'arg0', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::EmptyAttributeValue&', 'arg0', is_const=True)])
     ## attribute.h: ns3::EmptyAttributeValue::EmptyAttributeValue() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## attribute.h: ns3::Ptr<ns3::AttributeValue> ns3::EmptyAttributeValue::Copy() const [member function]
-    cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, visibility='private', is_virtual=True)
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, visibility='private', is_virtual=True)
     ## attribute.h: std::string ns3::EmptyAttributeValue::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, visibility='private', is_virtual=True)
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, visibility='private', is_virtual=True)
     ## attribute.h: bool ns3::EmptyAttributeValue::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')], visibility='private', is_virtual=True)
-    return
-
-def register_Ns3BooleanValue_methods(root_module, cls):
-    ## boolean.h: ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::BooleanValue&', 'arg0', is_const=True)], visibility='public')
-    ## boolean.h: ns3::BooleanValue::BooleanValue() [constructor]
-    cls.add_constructor([], visibility='public')
-    ## boolean.h: ns3::BooleanValue::BooleanValue(bool value) [constructor]
-    cls.add_constructor([param('bool', 'value')], visibility='public')
-    ## boolean.h: ns3::Ptr<ns3::AttributeValue> ns3::BooleanValue::Copy() const [member function]
-    cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
-    ## boolean.h: bool ns3::BooleanValue::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)
-    ## boolean.h: bool ns3::BooleanValue::Get() const [member function]
-    cls.add_method('Get', 'bool', [], is_const=True)
-    ## boolean.h: std::string ns3::BooleanValue::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)
-    ## boolean.h: void ns3::BooleanValue::Set(bool value) [member function]
-    cls.add_method('Set', 'void', [param('bool', 'value')])
-    cls.add_output_stream_operator()
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   visibility='private', is_virtual=True)
     return
 
 def register_Ns3TracedValue__Unsigned_int_methods(root_module, cls):
     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue() [constructor]
-    cls.add_constructor([], visibility='public')
+    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 >&', 'o', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::TracedValue< unsigned int >&', 'o', is_const=True)])
     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(unsigned int const & v) [constructor]
-    cls.add_constructor([param('unsigned int&', 'v', is_const=True)], visibility='public')
+    cls.add_constructor([param('unsigned int&', 'v', is_const=True)])
     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::IntegerValue const & value) [constructor]
-    cls.add_constructor([param('ns3::IntegerValue&', 'value', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::IntegerValue&', 'value', is_const=True)])
     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::UintegerValue const & value) [constructor]
-    cls.add_constructor([param('ns3::UintegerValue&', 'value', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::UintegerValue&', 'value', is_const=True)])
     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::BooleanValue const & value) [constructor]
-    cls.add_constructor([param('ns3::BooleanValue&', 'value', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::BooleanValue&', 'value', is_const=True)])
     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::EnumValue const & value) [constructor]
-    cls.add_constructor([param('ns3::EnumValue&', 'value', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::EnumValue&', 'value', is_const=True)])
     ## traced-value.h: void ns3::TracedValue<unsigned int>::ConnectWithoutContext(ns3::CallbackBase const & cb) [member function]
-    cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'cb', is_const=True)])
+    cls.add_method('ConnectWithoutContext', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'cb', is_const=True)])
     ## traced-value.h: void ns3::TracedValue<unsigned int>::Connect(ns3::CallbackBase const & cb, std::string path) [member function]
-    cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'cb', is_const=True), param('std::string', 'path')])
+    cls.add_method('Connect', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'cb', is_const=True), 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&', 'cb', is_const=True)])
+    cls.add_method('DisconnectWithoutContext', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'cb', is_const=True)])
     ## traced-value.h: void ns3::TracedValue<unsigned int>::Disconnect(ns3::CallbackBase const & cb, std::string path) [member function]
-    cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'cb', is_const=True), param('std::string', 'path')])
+    cls.add_method('Disconnect', 
+                   'void', 
+                   [param('ns3::CallbackBase&', 'cb', is_const=True), param('std::string', 'path')])
     ## traced-value.h: void ns3::TracedValue<unsigned int>::Set(unsigned int const & v) [member function]
-    cls.add_method('Set', 'void', [param('unsigned int&', 'v', is_const=True)])
+    cls.add_method('Set', 
+                   'void', 
+                   [param('unsigned int&', 'v', is_const=True)])
     ## traced-value.h: unsigned int ns3::TracedValue<unsigned int>::Get() const [member function]
-    cls.add_method('Get', 'unsigned int', [], is_const=True)
+    cls.add_method('Get', 
+                   'unsigned int', 
+                   [], 
+                   is_const=True)
     return
 
 def register_functions(root_module):
     module = root_module
     ## boolean.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeBooleanChecker() [free function]
-    module.add_function('MakeBooleanChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [])
+    module.add_function('MakeBooleanChecker', 
+                        'ns3::Ptr< ns3::AttributeChecker const >', 
+                        [])
     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
-    module.add_function('TypeNameGet', 'std::string', [], template_parameters=['double'])
+    module.add_function('TypeNameGet', 
+                        'std::string', 
+                        [], 
+                        template_parameters=['double'])
     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
-    module.add_function('TypeNameGet', 'std::string', [], template_parameters=['float'])
+    module.add_function('TypeNameGet', 
+                        'std::string', 
+                        [], 
+                        template_parameters=['float'])
     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
-    module.add_function('TypeNameGet', 'std::string', [], template_parameters=['long'])
+    module.add_function('TypeNameGet', 
+                        'std::string', 
+                        [], 
+                        template_parameters=['long'])
     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
-    module.add_function('TypeNameGet', 'std::string', [], template_parameters=['int'])
+    module.add_function('TypeNameGet', 
+                        'std::string', 
+                        [], 
+                        template_parameters=['int'])
     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
-    module.add_function('TypeNameGet', 'std::string', [], template_parameters=['short'])
+    module.add_function('TypeNameGet', 
+                        'std::string', 
+                        [], 
+                        template_parameters=['short'])
     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
-    module.add_function('TypeNameGet', 'std::string', [], template_parameters=['signed char'])
+    module.add_function('TypeNameGet', 
+                        'std::string', 
+                        [], 
+                        template_parameters=['signed char'])
     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
-    module.add_function('TypeNameGet', 'std::string', [], template_parameters=['unsigned long'])
+    module.add_function('TypeNameGet', 
+                        'std::string', 
+                        [], 
+                        template_parameters=['unsigned long'])
     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
-    module.add_function('TypeNameGet', 'std::string', [], template_parameters=['unsigned int'])
+    module.add_function('TypeNameGet', 
+                        'std::string', 
+                        [], 
+                        template_parameters=['unsigned int'])
     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
-    module.add_function('TypeNameGet', 'std::string', [], template_parameters=['unsigned short'])
+    module.add_function('TypeNameGet', 
+                        'std::string', 
+                        [], 
+                        template_parameters=['unsigned short'])
     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
-    module.add_function('TypeNameGet', 'std::string', [], template_parameters=['unsigned char'])
+    module.add_function('TypeNameGet', 
+                        'std::string', 
+                        [], 
+                        template_parameters=['unsigned char'])
     ## string.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeStringChecker() [free function]
-    module.add_function('MakeStringChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [])
+    module.add_function('MakeStringChecker', 
+                        'ns3::Ptr< ns3::AttributeChecker const >', 
+                        [])
     ## enum.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeEnumChecker(int v1, std::string n1, int v2=0, std::string n2="", int v3=0, std::string n3="", int v4=0, std::string n4="", int v5=0, std::string n5="", int v6=0, std::string n6="", int v7=0, std::string n7="", int v8=0, std::string n8="", int v9=0, std::string n9="", int v10=0, std::string n10="", int v11=0, std::string n11="", int v12=0, std::string n12="") [free function]
-    module.add_function('MakeEnumChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [param('int', 'v1'), param('std::string', 'n1'), param('int', 'v2', default_value='0'), param('std::string', 'n2', default_value='""'), param('int', 'v3', default_value='0'), param('std::string', 'n3', default_value='""'), param('int', 'v4', default_value='0'), param('std::string', 'n4', default_value='""'), param('int', 'v5', default_value='0'), param('std::string', 'n5', default_value='""'), param('int', 'v6', default_value='0'), param('std::string', 'n6', default_value='""'), param('int', 'v7', default_value='0'), param('std::string', 'n7', default_value='""'), param('int', 'v8', default_value='0'), param('std::string', 'n8', default_value='""'), param('int', 'v9', default_value='0'), param('std::string', 'n9', default_value='""'), param('int', 'v10', default_value='0'), param('std::string', 'n10', default_value='""'), param('int', 'v11', default_value='0'), param('std::string', 'n11', default_value='""'), param('int', 'v12', default_value='0'), param('std::string', 'n12', default_value='""')])
+    module.add_function('MakeEnumChecker', 
+                        'ns3::Ptr< ns3::AttributeChecker const >', 
+                        [param('int', 'v1'), param('std::string', 'n1'), param('int', 'v2', default_value='0'), param('std::string', 'n2', default_value='""'), param('int', 'v3', default_value='0'), param('std::string', 'n3', default_value='""'), param('int', 'v4', default_value='0'), param('std::string', 'n4', default_value='""'), param('int', 'v5', default_value='0'), param('std::string', 'n5', default_value='""'), param('int', 'v6', default_value='0'), param('std::string', 'n6', default_value='""'), param('int', 'v7', default_value='0'), param('std::string', 'n7', default_value='""'), param('int', 'v8', default_value='0'), param('std::string', 'n8', default_value='""'), param('int', 'v9', default_value='0'), param('std::string', 'n9', default_value='""'), param('int', 'v10', default_value='0'), param('std::string', 'n10', default_value='""'), param('int', 'v11', default_value='0'), param('std::string', 'n11', default_value='""'), param('int', 'v12', default_value='0'), param('std::string', 'n12', default_value='""')])
     ## type-id.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeTypeIdChecker() [free function]
-    module.add_function('MakeTypeIdChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [])
+    module.add_function('MakeTypeIdChecker', 
+                        'ns3::Ptr< ns3::AttributeChecker const >', 
+                        [])
     ## ptr.h: extern ns3::Ptr<ns3::PointerValue> ns3::Create() [free function]
-    module.add_function('Create', 'ns3::Ptr< ns3::PointerValue >', [], template_parameters=['ns3::PointerValue'])
+    module.add_function('Create', 
+                        'ns3::Ptr< ns3::PointerValue >', 
+                        [], 
+                        template_parameters=['ns3::PointerValue'])
     ## ptr.h: extern ns3::Ptr<ns3::ObjectVectorValue> ns3::Create() [free function]
-    module.add_function('Create', 'ns3::Ptr< ns3::ObjectVectorValue >', [], template_parameters=['ns3::ObjectVectorValue'])
+    module.add_function('Create', 
+                        'ns3::Ptr< ns3::ObjectVectorValue >', 
+                        [], 
+                        template_parameters=['ns3::ObjectVectorValue'])
     ## object-factory.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeObjectFactoryChecker() [free function]
-    module.add_function('MakeObjectFactoryChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [])
+    module.add_function('MakeObjectFactoryChecker', 
+                        'ns3::Ptr< ns3::AttributeChecker const >', 
+                        [])
     ## breakpoint.h: extern void ns3::BreakpointFallback() [free function]
-    module.add_function('BreakpointFallback', 'void', [])
+    module.add_function('BreakpointFallback', 
+                        'void', 
+                        [])
     ## random-variable.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeRandomVariableChecker() [free function]
-    module.add_function('MakeRandomVariableChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [])
+    module.add_function('MakeRandomVariableChecker', 
+                        'ns3::Ptr< ns3::AttributeChecker const >', 
+                        [])
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
@@ -1273,11 +2065,17 @@
 
 def register_functions_ns3_internal(module, root_module):
     ## uinteger.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::internal::MakeUintegerChecker(uint64_t min, uint64_t max, std::string name) [free function]
-    module.add_function('MakeUintegerChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [param('uint64_t', 'min'), param('uint64_t', 'max'), param('std::string', 'name')])
+    module.add_function('MakeUintegerChecker', 
+                        'ns3::Ptr< ns3::AttributeChecker const >', 
+                        [param('uint64_t', 'min'), param('uint64_t', 'max'), param('std::string', 'name')])
     ## integer.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::internal::MakeIntegerChecker(int64_t min, int64_t max, std::string name) [free function]
-    module.add_function('MakeIntegerChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [param('int64_t', 'min'), param('int64_t', 'max'), param('std::string', 'name')])
+    module.add_function('MakeIntegerChecker', 
+                        'ns3::Ptr< ns3::AttributeChecker const >', 
+                        [param('int64_t', 'min'), param('int64_t', 'max'), param('std::string', 'name')])
     ## double.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::internal::MakeDoubleChecker(double min, double max, std::string name) [free function]
-    module.add_function('MakeDoubleChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [param('double', 'min'), param('double', 'max'), param('std::string', 'name')])
+    module.add_function('MakeDoubleChecker', 
+                        'ns3::Ptr< ns3::AttributeChecker const >', 
+                        [param('double', 'min'), param('double', 'max'), param('std::string', 'name')])
     return
 
 def register_functions_ns3_TimeStepPrecision(module, root_module):
@@ -1285,31 +2083,57 @@
 
 def register_functions_ns3_Config(module, root_module):
     ## config.h: extern bool ns3::Config::SetDefaultFailSafe(std::string name, ns3::AttributeValue const & value) [free function]
-    module.add_function('SetDefaultFailSafe', 'bool', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
+    module.add_function('SetDefaultFailSafe', 
+                        'bool', 
+                        [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
     ## config.h: extern void ns3::Config::DisconnectWithoutContext(std::string path, ns3::CallbackBase const & cb) [free function]
-    module.add_function('DisconnectWithoutContext', 'void', [param('std::string', 'path'), param('ns3::CallbackBase&', 'cb', is_const=True)])
+    module.add_function('DisconnectWithoutContext', 
+                        'void', 
+                        [param('std::string', 'path'), param('ns3::CallbackBase&', 'cb', is_const=True)])
     ## config.h: extern void ns3::Config::SetDefault(std::string name, ns3::AttributeValue const & value) [free function]
-    module.add_function('SetDefault', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
+    module.add_function('SetDefault', 
+                        'void', 
+                        [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
     ## config.h: extern void ns3::Config::Connect(std::string path, ns3::CallbackBase const & cb) [free function]
-    module.add_function('Connect', 'void', [param('std::string', 'path'), param('ns3::CallbackBase&', 'cb', is_const=True)])
+    module.add_function('Connect', 
+                        'void', 
+                        [param('std::string', 'path'), param('ns3::CallbackBase&', 'cb', is_const=True)])
     ## config.h: extern ns3::Ptr<ns3::Object> ns3::Config::GetRootNamespaceObject(uint32_t i) [free function]
-    module.add_function('GetRootNamespaceObject', 'ns3::Ptr< ns3::Object >', [param('uint32_t', 'i')])
+    module.add_function('GetRootNamespaceObject', 
+                        'ns3::Ptr< ns3::Object >', 
+                        [param('uint32_t', 'i')])
     ## config.h: extern void ns3::Config::ConnectWithoutContext(std::string path, ns3::CallbackBase const & cb) [free function]
-    module.add_function('ConnectWithoutContext', 'void', [param('std::string', 'path'), param('ns3::CallbackBase&', 'cb', is_const=True)])
+    module.add_function('ConnectWithoutContext', 
+                        'void', 
+                        [param('std::string', 'path'), param('ns3::CallbackBase&', 'cb', is_const=True)])
     ## config.h: extern void ns3::Config::UnregisterRootNamespaceObject(ns3::Ptr<ns3::Object> obj) [free function]
-    module.add_function('UnregisterRootNamespaceObject', 'void', [param('ns3::Ptr< ns3::Object >', 'obj')])
+    module.add_function('UnregisterRootNamespaceObject', 
+                        'void', 
+                        [param('ns3::Ptr< ns3::Object >', 'obj')])
     ## config.h: extern bool ns3::Config::SetGlobalFailSafe(std::string name, ns3::AttributeValue const & value) [free function]
-    module.add_function('SetGlobalFailSafe', 'bool', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
+    module.add_function('SetGlobalFailSafe', 
+                        'bool', 
+                        [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
     ## config.h: extern uint32_t ns3::Config::GetRootNamespaceObjectN() [free function]
-    module.add_function('GetRootNamespaceObjectN', 'uint32_t', [])
+    module.add_function('GetRootNamespaceObjectN', 
+                        'uint32_t', 
+                        [])
     ## config.h: extern void ns3::Config::Set(std::string path, ns3::AttributeValue const & value) [free function]
-    module.add_function('Set', 'void', [param('std::string', 'path'), param('ns3::AttributeValue&', 'value', is_const=True)])
+    module.add_function('Set', 
+                        'void', 
+                        [param('std::string', 'path'), param('ns3::AttributeValue&', 'value', is_const=True)])
     ## config.h: extern void ns3::Config::SetGlobal(std::string name, ns3::AttributeValue const & value) [free function]
-    module.add_function('SetGlobal', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
+    module.add_function('SetGlobal', 
+                        'void', 
+                        [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
     ## config.h: extern void ns3::Config::RegisterRootNamespaceObject(ns3::Ptr<ns3::Object> obj) [free function]
-    module.add_function('RegisterRootNamespaceObject', 'void', [param('ns3::Ptr< ns3::Object >', 'obj')])
+    module.add_function('RegisterRootNamespaceObject', 
+                        'void', 
+                        [param('ns3::Ptr< ns3::Object >', 'obj')])
     ## config.h: extern void ns3::Config::Disconnect(std::string path, ns3::CallbackBase const & cb) [free function]
-    module.add_function('Disconnect', 'void', [param('std::string', 'path'), param('ns3::CallbackBase&', 'cb', is_const=True)])
+    module.add_function('Disconnect', 
+                        'void', 
+                        [param('std::string', 'path'), param('ns3::CallbackBase&', 'cb', is_const=True)])
     return
 
 def register_functions_ns3_olsr(module, root_module):
--- a/bindings/python/ns3_module_csma.py	Fri Jul 18 21:59:43 2008 -0700
+++ b/bindings/python/ns3_module_csma.py	Mon Jul 21 15:53:03 2008 -0700
@@ -1,4 +1,4 @@
-from pybindgen import Module, FileCodeSink, write_preamble, param, retval
+from pybindgen import Module, FileCodeSink, param, retval, cppclass
 
 def register_types(module):
     root_module = module.get_root()
@@ -10,9 +10,9 @@
     ## backoff.h: ns3::Backoff [class]
     module.add_class('Backoff')
     ## csma-channel.h: ns3::CsmaChannel [class]
-    module.add_class('CsmaChannel', allow_subclassing=True, parent=root_module['ns3::Channel'])
+    module.add_class('CsmaChannel', parent=root_module['ns3::Channel'])
     ## csma-net-device.h: ns3::CsmaNetDevice [class]
-    module.add_class('CsmaNetDevice', allow_subclassing=True, parent=root_module['ns3::NetDevice'])
+    module.add_class('CsmaNetDevice', parent=root_module['ns3::NetDevice'])
     ## csma-net-device.h: ns3::CsmaNetDevice::CsmaEncapsulationMode [enumeration]
     module.add_enum('CsmaEncapsulationMode', ['ETHERNET_V1', 'IP_ARP', 'RAW', 'LLC'], outer_class=root_module['ns3::CsmaNetDevice'])
     
@@ -69,11 +69,13 @@
     ## csma-channel.h: ns3::CsmaDeviceRec::active [variable]
     cls.add_instance_attribute('active', 'bool', is_const=False)
     ## csma-channel.h: ns3::CsmaDeviceRec::CsmaDeviceRec() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## csma-channel.h: ns3::CsmaDeviceRec::CsmaDeviceRec(ns3::Ptr<ns3::CsmaNetDevice> device) [constructor]
-    cls.add_constructor([param('ns3::Ptr< ns3::CsmaNetDevice >', 'device')], visibility='public')
+    cls.add_constructor([param('ns3::Ptr< ns3::CsmaNetDevice >', 'device')])
     ## csma-channel.h: bool ns3::CsmaDeviceRec::IsActive() [member function]
-    cls.add_method('IsActive', 'bool', [])
+    cls.add_method('IsActive', 
+                   'bool', 
+                   [])
     return
 
 def register_Ns3Backoff_methods(root_module, cls):
@@ -88,139 +90,306 @@
     ## backoff.h: ns3::Backoff::m_slotTime [variable]
     cls.add_instance_attribute('m_slotTime', 'ns3::Time', is_const=False)
     ## backoff.h: ns3::Backoff::Backoff() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## backoff.h: ns3::Backoff::Backoff(ns3::Time slotTime, uint32_t minSlots, uint32_t maxSlots, uint32_t ceiling, uint32_t maxRetries) [constructor]
-    cls.add_constructor([param('ns3::Time', 'slotTime'), param('uint32_t', 'minSlots'), param('uint32_t', 'maxSlots'), param('uint32_t', 'ceiling'), param('uint32_t', 'maxRetries')], visibility='public')
+    cls.add_constructor([param('ns3::Time', 'slotTime'), param('uint32_t', 'minSlots'), param('uint32_t', 'maxSlots'), param('uint32_t', 'ceiling'), param('uint32_t', 'maxRetries')])
     ## backoff.h: ns3::Time ns3::Backoff::GetBackoffTime() [member function]
-    cls.add_method('GetBackoffTime', 'ns3::Time', [])
+    cls.add_method('GetBackoffTime', 
+                   'ns3::Time', 
+                   [])
     ## backoff.h: void ns3::Backoff::ResetBackoffTime() [member function]
-    cls.add_method('ResetBackoffTime', 'void', [])
+    cls.add_method('ResetBackoffTime', 
+                   'void', 
+                   [])
     ## backoff.h: bool ns3::Backoff::MaxRetriesReached() [member function]
-    cls.add_method('MaxRetriesReached', 'bool', [])
+    cls.add_method('MaxRetriesReached', 
+                   'bool', 
+                   [])
     ## backoff.h: void ns3::Backoff::IncrNumRetries() [member function]
-    cls.add_method('IncrNumRetries', 'void', [])
+    cls.add_method('IncrNumRetries', 
+                   'void', 
+                   [])
     return
 
 def register_Ns3CsmaChannel_methods(root_module, cls):
     ## csma-channel.h: static ns3::TypeId ns3::CsmaChannel::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## csma-channel.h: ns3::CsmaChannel::CsmaChannel() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## csma-channel.h: int32_t ns3::CsmaChannel::Attach(ns3::Ptr<ns3::CsmaNetDevice> device) [member function]
-    cls.add_method('Attach', 'int32_t', [param('ns3::Ptr< ns3::CsmaNetDevice >', 'device')])
+    cls.add_method('Attach', 
+                   'int32_t', 
+                   [param('ns3::Ptr< ns3::CsmaNetDevice >', 'device')])
     ## csma-channel.h: bool ns3::CsmaChannel::Detach(ns3::Ptr<ns3::CsmaNetDevice> device) [member function]
-    cls.add_method('Detach', 'bool', [param('ns3::Ptr< ns3::CsmaNetDevice >', 'device')])
+    cls.add_method('Detach', 
+                   'bool', 
+                   [param('ns3::Ptr< ns3::CsmaNetDevice >', 'device')])
     ## csma-channel.h: bool ns3::CsmaChannel::Detach(uint32_t deviceId) [member function]
-    cls.add_method('Detach', 'bool', [param('uint32_t', 'deviceId')])
+    cls.add_method('Detach', 
+                   'bool', 
+                   [param('uint32_t', 'deviceId')])
     ## csma-channel.h: bool ns3::CsmaChannel::Reattach(uint32_t deviceId) [member function]
-    cls.add_method('Reattach', 'bool', [param('uint32_t', 'deviceId')])
+    cls.add_method('Reattach', 
+                   'bool', 
+                   [param('uint32_t', 'deviceId')])
     ## csma-channel.h: bool ns3::CsmaChannel::Reattach(ns3::Ptr<ns3::CsmaNetDevice> device) [member function]
-    cls.add_method('Reattach', 'bool', [param('ns3::Ptr< ns3::CsmaNetDevice >', 'device')])
+    cls.add_method('Reattach', 
+                   'bool', 
+                   [param('ns3::Ptr< ns3::CsmaNetDevice >', 'device')])
     ## csma-channel.h: bool ns3::CsmaChannel::TransmitStart(ns3::Ptr<ns3::Packet> p, uint32_t srcId) [member function]
-    cls.add_method('TransmitStart', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'srcId')])
+    cls.add_method('TransmitStart', 
+                   'bool', 
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'srcId')])
     ## csma-channel.h: bool ns3::CsmaChannel::TransmitEnd() [member function]
-    cls.add_method('TransmitEnd', 'bool', [])
+    cls.add_method('TransmitEnd', 
+                   'bool', 
+                   [])
     ## csma-channel.h: void ns3::CsmaChannel::PropagationCompleteEvent() [member function]
-    cls.add_method('PropagationCompleteEvent', 'void', [])
+    cls.add_method('PropagationCompleteEvent', 
+                   'void', 
+                   [])
     ## csma-channel.h: int32_t ns3::CsmaChannel::GetDeviceNum(ns3::Ptr<ns3::CsmaNetDevice> device) [member function]
-    cls.add_method('GetDeviceNum', 'int32_t', [param('ns3::Ptr< ns3::CsmaNetDevice >', 'device')])
+    cls.add_method('GetDeviceNum', 
+                   'int32_t', 
+                   [param('ns3::Ptr< ns3::CsmaNetDevice >', 'device')])
     ## csma-channel.h: ns3::WireState ns3::CsmaChannel::GetState() [member function]
-    cls.add_method('GetState', 'ns3::WireState', [])
+    cls.add_method('GetState', 
+                   'ns3::WireState', 
+                   [])
     ## csma-channel.h: bool ns3::CsmaChannel::IsBusy() [member function]
-    cls.add_method('IsBusy', 'bool', [])
+    cls.add_method('IsBusy', 
+                   'bool', 
+                   [])
     ## csma-channel.h: bool ns3::CsmaChannel::IsActive(uint32_t deviceId) [member function]
-    cls.add_method('IsActive', 'bool', [param('uint32_t', 'deviceId')])
+    cls.add_method('IsActive', 
+                   'bool', 
+                   [param('uint32_t', 'deviceId')])
     ## csma-channel.h: uint32_t ns3::CsmaChannel::GetNumActDevices() [member function]
-    cls.add_method('GetNumActDevices', 'uint32_t', [])
+    cls.add_method('GetNumActDevices', 
+                   'uint32_t', 
+                   [])
     ## csma-channel.h: uint32_t ns3::CsmaChannel::GetNDevices() const [member function]
-    cls.add_method('GetNDevices', 'uint32_t', [], is_const=True, is_virtual=True)
+    cls.add_method('GetNDevices', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## csma-channel.h: ns3::Ptr<ns3::NetDevice> ns3::CsmaChannel::GetDevice(uint32_t i) const [member function]
-    cls.add_method('GetDevice', 'ns3::Ptr< ns3::NetDevice >', [param('uint32_t', 'i')], is_const=True, is_virtual=True)
+    cls.add_method('GetDevice', 
+                   'ns3::Ptr< ns3::NetDevice >', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True, is_virtual=True)
     ## csma-channel.h: ns3::Ptr<ns3::CsmaNetDevice> ns3::CsmaChannel::GetCsmaDevice(uint32_t i) const [member function]
-    cls.add_method('GetCsmaDevice', 'ns3::Ptr< ns3::CsmaNetDevice >', [param('uint32_t', 'i')], is_const=True)
+    cls.add_method('GetCsmaDevice', 
+                   'ns3::Ptr< ns3::CsmaNetDevice >', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
     ## csma-channel.h: ns3::DataRate ns3::CsmaChannel::GetDataRate() [member function]
-    cls.add_method('GetDataRate', 'ns3::DataRate', [], is_virtual=True)
+    cls.add_method('GetDataRate', 
+                   'ns3::DataRate', 
+                   [], 
+                   is_virtual=True)
     ## csma-channel.h: ns3::Time ns3::CsmaChannel::GetDelay() [member function]
-    cls.add_method('GetDelay', 'ns3::Time', [], is_virtual=True)
+    cls.add_method('GetDelay', 
+                   'ns3::Time', 
+                   [], 
+                   is_virtual=True)
     return
 
 def register_Ns3CsmaNetDevice_methods(root_module, cls):
     ## csma-net-device.h: static ns3::TypeId ns3::CsmaNetDevice::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## csma-net-device.h: ns3::CsmaNetDevice::CsmaNetDevice() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## csma-net-device.h: void ns3::CsmaNetDevice::SetInterframeGap(ns3::Time t) [member function]
-    cls.add_method('SetInterframeGap', 'void', [param('ns3::Time', 't')])
+    cls.add_method('SetInterframeGap', 
+                   'void', 
+                   [param('ns3::Time', 't')])
     ## csma-net-device.h: void ns3::CsmaNetDevice::SetBackoffParams(ns3::Time slotTime, uint32_t minSlots, uint32_t maxSlots, uint32_t maxRetries, uint32_t ceiling) [member function]
-    cls.add_method('SetBackoffParams', 'void', [param('ns3::Time', 'slotTime'), param('uint32_t', 'minSlots'), param('uint32_t', 'maxSlots'), param('uint32_t', 'maxRetries'), param('uint32_t', 'ceiling')])
+    cls.add_method('SetBackoffParams', 
+                   'void', 
+                   [param('ns3::Time', 'slotTime'), param('uint32_t', 'minSlots'), param('uint32_t', 'maxSlots'), param('uint32_t', 'maxRetries'), param('uint32_t', 'ceiling')])
     ## csma-net-device.h: bool ns3::CsmaNetDevice::Attach(ns3::Ptr<ns3::CsmaChannel> ch) [member function]
-    cls.add_method('Attach', 'bool', [param('ns3::Ptr< ns3::CsmaChannel >', 'ch')])
+    cls.add_method('Attach', 
+                   'bool', 
+                   [param('ns3::Ptr< ns3::CsmaChannel >', 'ch')])
     ## csma-net-device.h: void ns3::CsmaNetDevice::SetQueue(ns3::Ptr<ns3::Queue> queue) [member function]
-    cls.add_method('SetQueue', 'void', [param('ns3::Ptr< ns3::Queue >', 'queue')])
+    cls.add_method('SetQueue', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Queue >', 'queue')])
     ## csma-net-device.h: void ns3::CsmaNetDevice::SetReceiveErrorModel(ns3::Ptr<ns3::ErrorModel> em) [member function]
-    cls.add_method('SetReceiveErrorModel', 'void', [param('ns3::Ptr< ns3::ErrorModel >', 'em')])
-    ## csma-net-device.h: void ns3::CsmaNetDevice::Receive(ns3::Ptr<ns3::Packet> p) [member function]
-    cls.add_method('Receive', 'void', [param('ns3::Ptr< ns3::Packet >', 'p')])
+    cls.add_method('SetReceiveErrorModel', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::ErrorModel >', 'em')])
+    ## csma-net-device.h: void ns3::CsmaNetDevice::Receive(ns3::Ptr<ns3::Packet> p, ns3::Ptr<ns3::CsmaNetDevice> sender) [member function]
+    cls.add_method('Receive', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ptr< ns3::CsmaNetDevice >', 'sender')])
     ## csma-net-device.h: bool ns3::CsmaNetDevice::IsSendEnabled() [member function]
-    cls.add_method('IsSendEnabled', 'bool', [])
+    cls.add_method('IsSendEnabled', 
+                   'bool', 
+                   [])
     ## csma-net-device.h: void ns3::CsmaNetDevice::SetSendEnable(bool enable) [member function]
-    cls.add_method('SetSendEnable', 'void', [param('bool', 'enable')])
+    cls.add_method('SetSendEnable', 
+                   'void', 
+                   [param('bool', 'enable')])
     ## csma-net-device.h: bool ns3::CsmaNetDevice::IsReceiveEnabled() [member function]
-    cls.add_method('IsReceiveEnabled', 'bool', [])
+    cls.add_method('IsReceiveEnabled', 
+                   'bool', 
+                   [])
     ## csma-net-device.h: void ns3::CsmaNetDevice::SetReceiveEnable(bool enable) [member function]
-    cls.add_method('SetReceiveEnable', 'void', [param('bool', 'enable')])
+    cls.add_method('SetReceiveEnable', 
+                   'void', 
+                   [param('bool', 'enable')])
     ## csma-net-device.h: void ns3::CsmaNetDevice::SetAddress(ns3::Mac48Address addr) [member function]
-    cls.add_method('SetAddress', 'void', [param('ns3::Mac48Address', 'addr')])
+    cls.add_method('SetAddress', 
+                   'void', 
+                   [param('ns3::Mac48Address', 'addr')])
     ## csma-net-device.h: void ns3::CsmaNetDevice::SetName(std::string const name) [member function]
-    cls.add_method('SetName', 'void', [param('std::string', 'name', is_const=True)], is_virtual=True)
+    cls.add_method('SetName', 
+                   'void', 
+                   [param('std::string', 'name', is_const=True)], 
+                   is_virtual=True)
     ## csma-net-device.h: std::string ns3::CsmaNetDevice::GetName() const [member function]
-    cls.add_method('GetName', 'std::string', [], is_const=True, is_virtual=True)
+    cls.add_method('GetName', 
+                   'std::string', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## csma-net-device.h: void ns3::CsmaNetDevice::SetIfIndex(uint32_t const index) [member function]
-    cls.add_method('SetIfIndex', 'void', [param('uint32_t', 'index', is_const=True)], is_virtual=True)
+    cls.add_method('SetIfIndex', 
+                   'void', 
+                   [param('uint32_t', 'index', is_const=True)], 
+                   is_virtual=True)
     ## csma-net-device.h: uint32_t ns3::CsmaNetDevice::GetIfIndex() const [member function]
-    cls.add_method('GetIfIndex', 'uint32_t', [], is_const=True, is_virtual=True)
+    cls.add_method('GetIfIndex', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## csma-net-device.h: ns3::Ptr<ns3::Channel> ns3::CsmaNetDevice::GetChannel() const [member function]
-    cls.add_method('GetChannel', 'ns3::Ptr< ns3::Channel >', [], is_const=True, is_virtual=True)
+    cls.add_method('GetChannel', 
+                   'ns3::Ptr< ns3::Channel >', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## csma-net-device.h: ns3::Address ns3::CsmaNetDevice::GetAddress() const [member function]
-    cls.add_method('GetAddress', 'ns3::Address', [], is_const=True, is_virtual=True)
+    cls.add_method('GetAddress', 
+                   'ns3::Address', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## csma-net-device.h: bool ns3::CsmaNetDevice::SetMtu(uint16_t const mtu) [member function]
-    cls.add_method('SetMtu', 'bool', [param('uint16_t', 'mtu', is_const=True)], is_virtual=True)
+    cls.add_method('SetMtu', 
+                   'bool', 
+                   [param('uint16_t', 'mtu', is_const=True)], 
+                   is_virtual=True)
     ## csma-net-device.h: uint16_t ns3::CsmaNetDevice::GetMtu() const [member function]
-    cls.add_method('GetMtu', 'uint16_t', [], is_const=True, is_virtual=True)
+    cls.add_method('GetMtu', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## csma-net-device.h: bool ns3::CsmaNetDevice::IsLinkUp() const [member function]
-    cls.add_method('IsLinkUp', 'bool', [], is_const=True, is_virtual=True)
+    cls.add_method('IsLinkUp', 
+                   'bool', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## csma-net-device.h: void ns3::CsmaNetDevice::SetLinkChangeCallback(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function]
-    cls.add_method('SetLinkChangeCallback', 'void', [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')], is_virtual=True)
+    cls.add_method('SetLinkChangeCallback', 
+                   'void', 
+                   [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')], 
+                   is_virtual=True)
     ## csma-net-device.h: bool ns3::CsmaNetDevice::IsBroadcast() const [member function]
-    cls.add_method('IsBroadcast', 'bool', [], is_const=True, is_virtual=True)
+    cls.add_method('IsBroadcast', 
+                   'bool', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## csma-net-device.h: ns3::Address ns3::CsmaNetDevice::GetBroadcast() const [member function]
-    cls.add_method('GetBroadcast', 'ns3::Address', [], is_const=True, is_virtual=True)
+    cls.add_method('GetBroadcast', 
+                   'ns3::Address', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## csma-net-device.h: bool ns3::CsmaNetDevice::IsMulticast() const [member function]
-    cls.add_method('IsMulticast', 'bool', [], is_const=True, is_virtual=True)
+    cls.add_method('IsMulticast', 
+                   'bool', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## csma-net-device.h: ns3::Address ns3::CsmaNetDevice::GetMulticast() const [member function]
-    cls.add_method('GetMulticast', 'ns3::Address', [], is_const=True, is_virtual=True)
+    cls.add_method('GetMulticast', 
+                   'ns3::Address', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## csma-net-device.h: ns3::Address ns3::CsmaNetDevice::MakeMulticastAddress(ns3::Ipv4Address multicastGroup) const [member function]
-    cls.add_method('MakeMulticastAddress', 'ns3::Address', [param('ns3::Ipv4Address', 'multicastGroup')], is_const=True, is_virtual=True)
+    cls.add_method('MakeMulticastAddress', 
+                   'ns3::Address', 
+                   [param('ns3::Ipv4Address', 'multicastGroup')], 
+                   is_const=True, is_virtual=True)
     ## csma-net-device.h: bool ns3::CsmaNetDevice::IsPointToPoint() const [member function]
-    cls.add_method('IsPointToPoint', 'bool', [], is_const=True, is_virtual=True)
+    cls.add_method('IsPointToPoint', 
+                   'bool', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## csma-net-device.h: bool ns3::CsmaNetDevice::Send(ns3::Ptr<ns3::Packet> packet, ns3::Address const & dest, uint16_t protocolNumber) [member function]
-    cls.add_method('Send', 'bool', [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address&', 'dest', is_const=True), param('uint16_t', 'protocolNumber')], is_virtual=True)
+    cls.add_method('Send', 
+                   'bool', 
+                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address&', 'dest', is_const=True), param('uint16_t', 'protocolNumber')], 
+                   is_virtual=True)
+    ## csma-net-device.h: bool ns3::CsmaNetDevice::SendFrom(ns3::Ptr<ns3::Packet> packet, ns3::Address const & source, ns3::Address const & dest, uint16_t protocolNumber) [member function]
+    cls.add_method('SendFrom', 
+                   'bool', 
+                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address&', 'source', is_const=True), param('ns3::Address&', 'dest', is_const=True), param('uint16_t', 'protocolNumber')], 
+                   is_virtual=True)
     ## csma-net-device.h: ns3::Ptr<ns3::Node> ns3::CsmaNetDevice::GetNode() const [member function]
-    cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', [], is_const=True, is_virtual=True)
+    cls.add_method('GetNode', 
+                   'ns3::Ptr< ns3::Node >', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## csma-net-device.h: void ns3::CsmaNetDevice::SetNode(ns3::Ptr<ns3::Node> node) [member function]
-    cls.add_method('SetNode', 'void', [param('ns3::Ptr< ns3::Node >', 'node')], is_virtual=True)
+    cls.add_method('SetNode', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Node >', 'node')], 
+                   is_virtual=True)
     ## csma-net-device.h: bool ns3::CsmaNetDevice::NeedsArp() const [member function]
-    cls.add_method('NeedsArp', 'bool', [], is_const=True, is_virtual=True)
+    cls.add_method('NeedsArp', 
+                   'bool', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## csma-net-device.h: void ns3::CsmaNetDevice::SetReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> cb) [member function]
-    cls.add_method('SetReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], is_virtual=True)
+    cls.add_method('SetReceiveCallback', 
+                   'void', 
+                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], 
+                   is_virtual=True)
+    ## csma-net-device.h: void ns3::CsmaNetDevice::SetPromiscReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType> cb) [member function]
+    cls.add_method('SetPromiscReceiveCallback', 
+                   'void', 
+                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'cb')], 
+                   is_virtual=True)
+    ## csma-net-device.h: bool ns3::CsmaNetDevice::SupportsPromiscuous() const [member function]
+    cls.add_method('SupportsPromiscuous', 
+                   'bool', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## csma-net-device.h: void ns3::CsmaNetDevice::DoDispose() [member function]
-    cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True)
+    cls.add_method('DoDispose', 
+                   '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 dest, uint16_t protocolNumber) [member function]
-    cls.add_method('AddHeader', 'void', [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Mac48Address', 'dest'), param('uint16_t', 'protocolNumber')], visibility='protected')
+    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', 
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Mac48Address', 'source'), param('ns3::Mac48Address', 'dest'), param('uint16_t', 'protocolNumber')], 
+                   visibility='protected')
     ## csma-net-device.h: bool ns3::CsmaNetDevice::ProcessHeader(ns3::Ptr<ns3::Packet> p, uint16_t & param) [member function]
-    cls.add_method('ProcessHeader', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint16_t&', 'param')], visibility='protected')
+    cls.add_method('ProcessHeader', 
+                   'bool', 
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint16_t&', 'param')], 
+                   visibility='protected')
     return
 
 def register_functions(root_module):
--- a/bindings/python/ns3_module_global_routing.py	Fri Jul 18 21:59:43 2008 -0700
+++ b/bindings/python/ns3_module_global_routing.py	Mon Jul 21 15:53:03 2008 -0700
@@ -1,4 +1,4 @@
-from pybindgen import Module, FileCodeSink, write_preamble, param, retval
+from pybindgen import Module, FileCodeSink, param, retval, cppclass
 
 def register_types(module):
     root_module = module.get_root()
@@ -16,7 +16,7 @@
     ## global-router-interface.h: ns3::GlobalRoutingLinkRecord::LinkType [enumeration]
     module.add_enum('LinkType', ['Unknown', 'PointToPoint', 'TransitNetwork', 'StubNetwork', 'VirtualLink'], outer_class=root_module['ns3::GlobalRoutingLinkRecord'])
     ## global-router-interface.h: ns3::GlobalRouter [class]
-    module.add_class('GlobalRouter', allow_subclassing=True, is_singleton=True, parent=root_module['ns3::Object'])
+    module.add_class('GlobalRouter', is_singleton=True, parent=root_module['ns3::Object'])
     
     ## Register a nested module for the namespace internal
     
@@ -67,99 +67,193 @@
 
 def register_Ns3GlobalRouteManager_methods(root_module, cls):
     ## global-route-manager.h: static void ns3::GlobalRouteManager::PopulateRoutingTables() [member function]
-    cls.add_method('PopulateRoutingTables', 'void', [], is_static=True)
+    cls.add_method('PopulateRoutingTables', 
+                   'void', 
+                   [], 
+                   is_static=True)
     ## global-route-manager.h: static uint32_t ns3::GlobalRouteManager::AllocateRouterId() [member function]
-    cls.add_method('AllocateRouterId', 'uint32_t', [], is_static=True)
+    cls.add_method('AllocateRouterId', 
+                   'uint32_t', 
+                   [], 
+                   is_static=True)
     return
 
 def register_Ns3GlobalRoutingLSA_methods(root_module, cls):
     ## global-router-interface.h: ns3::GlobalRoutingLSA::GlobalRoutingLSA() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## global-router-interface.h: ns3::GlobalRoutingLSA::GlobalRoutingLSA(ns3::GlobalRoutingLSA::SPFStatus status, ns3::Ipv4Address linkStateId, ns3::Ipv4Address advertisingRtr) [constructor]
-    cls.add_constructor([param('ns3::GlobalRoutingLSA::SPFStatus', 'status'), param('ns3::Ipv4Address', 'linkStateId'), param('ns3::Ipv4Address', 'advertisingRtr')], visibility='public')
+    cls.add_constructor([param('ns3::GlobalRoutingLSA::SPFStatus', 'status'), param('ns3::Ipv4Address', 'linkStateId'), param('ns3::Ipv4Address', 'advertisingRtr')])
     ## global-router-interface.h: ns3::GlobalRoutingLSA::GlobalRoutingLSA(ns3::GlobalRoutingLSA & lsa) [constructor]
-    cls.add_constructor([param('ns3::GlobalRoutingLSA&', 'lsa')], visibility='public')
+    cls.add_constructor([param('ns3::GlobalRoutingLSA&', 'lsa')])
     ## global-router-interface.h: uint32_t ns3::GlobalRoutingLSA::AddAttachedRouter(ns3::Ipv4Address addr) [member function]
-    cls.add_method('AddAttachedRouter', 'uint32_t', [param('ns3::Ipv4Address', 'addr')])
+    cls.add_method('AddAttachedRouter', 
+                   'uint32_t', 
+                   [param('ns3::Ipv4Address', 'addr')])
     ## global-router-interface.h: uint32_t ns3::GlobalRoutingLSA::AddLinkRecord(ns3::GlobalRoutingLinkRecord * lr) [member function]
-    cls.add_method('AddLinkRecord', 'uint32_t', [param('ns3::GlobalRoutingLinkRecord *', 'lr')])
+    cls.add_method('AddLinkRecord', 
+                   'uint32_t', 
+                   [param('ns3::GlobalRoutingLinkRecord *', 'lr')])
     ## global-router-interface.h: void ns3::GlobalRoutingLSA::ClearLinkRecords() [member function]
-    cls.add_method('ClearLinkRecords', 'void', [])
+    cls.add_method('ClearLinkRecords', 
+                   'void', 
+                   [])
     ## global-router-interface.h: void ns3::GlobalRoutingLSA::CopyLinkRecords(ns3::GlobalRoutingLSA const & lsa) [member function]
-    cls.add_method('CopyLinkRecords', 'void', [param('ns3::GlobalRoutingLSA&', 'lsa', is_const=True)])
+    cls.add_method('CopyLinkRecords', 
+                   'void', 
+                   [param('ns3::GlobalRoutingLSA&', 'lsa', is_const=True)])
     ## global-router-interface.h: ns3::Ipv4Address ns3::GlobalRoutingLSA::GetAdvertisingRouter() const [member function]
-    cls.add_method('GetAdvertisingRouter', 'ns3::Ipv4Address', [], is_const=True)
+    cls.add_method('GetAdvertisingRouter', 
+                   'ns3::Ipv4Address', 
+                   [], 
+                   is_const=True)
     ## global-router-interface.h: ns3::Ipv4Address ns3::GlobalRoutingLSA::GetAttachedRouter(uint32_t n) const [member function]
-    cls.add_method('GetAttachedRouter', 'ns3::Ipv4Address', [param('uint32_t', 'n')], is_const=True)
+    cls.add_method('GetAttachedRouter', 
+                   'ns3::Ipv4Address', 
+                   [param('uint32_t', 'n')], 
+                   is_const=True)
     ## global-router-interface.h: ns3::GlobalRoutingLSA::LSType ns3::GlobalRoutingLSA::GetLSType() const [member function]
-    cls.add_method('GetLSType', 'ns3::GlobalRoutingLSA::LSType', [], is_const=True)
+    cls.add_method('GetLSType', 
+                   'ns3::GlobalRoutingLSA::LSType', 
+                   [], 
+                   is_const=True)
     ## global-router-interface.h: ns3::GlobalRoutingLinkRecord * ns3::GlobalRoutingLSA::GetLinkRecord(uint32_t n) const [member function]
-    cls.add_method('GetLinkRecord', 'ns3::GlobalRoutingLinkRecord *', [param('uint32_t', 'n')], is_const=True)
+    cls.add_method('GetLinkRecord', 
+                   'ns3::GlobalRoutingLinkRecord *', 
+                   [param('uint32_t', 'n')], 
+                   is_const=True)
     ## global-router-interface.h: ns3::Ipv4Address ns3::GlobalRoutingLSA::GetLinkStateId() const [member function]
-    cls.add_method('GetLinkStateId', 'ns3::Ipv4Address', [], is_const=True)
+    cls.add_method('GetLinkStateId', 
+                   'ns3::Ipv4Address', 
+                   [], 
+                   is_const=True)
     ## global-router-interface.h: uint32_t ns3::GlobalRoutingLSA::GetNAttachedRouters() const [member function]
-    cls.add_method('GetNAttachedRouters', 'uint32_t', [], is_const=True)
+    cls.add_method('GetNAttachedRouters', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## global-router-interface.h: uint32_t ns3::GlobalRoutingLSA::GetNLinkRecords() const [member function]
-    cls.add_method('GetNLinkRecords', 'uint32_t', [], is_const=True)
+    cls.add_method('GetNLinkRecords', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## global-router-interface.h: ns3::Ipv4Mask ns3::GlobalRoutingLSA::GetNetworkLSANetworkMask() const [member function]
-    cls.add_method('GetNetworkLSANetworkMask', 'ns3::Ipv4Mask', [], is_const=True)
+    cls.add_method('GetNetworkLSANetworkMask', 
+                   'ns3::Ipv4Mask', 
+                   [], 
+                   is_const=True)
     ## global-router-interface.h: ns3::GlobalRoutingLSA::SPFStatus ns3::GlobalRoutingLSA::GetStatus() const [member function]
-    cls.add_method('GetStatus', 'ns3::GlobalRoutingLSA::SPFStatus', [], is_const=True)
+    cls.add_method('GetStatus', 
+                   'ns3::GlobalRoutingLSA::SPFStatus', 
+                   [], 
+                   is_const=True)
     ## global-router-interface.h: bool ns3::GlobalRoutingLSA::IsEmpty() const [member function]
-    cls.add_method('IsEmpty', 'bool', [], is_const=True)
+    cls.add_method('IsEmpty', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## global-router-interface.h: void ns3::GlobalRoutingLSA::Print(std::ostream & os) const [member function]
-    cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True)
+    cls.add_method('Print', 
+                   'void', 
+                   [param('std::ostream&', 'os')], 
+                   is_const=True)
     ## global-router-interface.h: void ns3::GlobalRoutingLSA::SetAdvertisingRouter(ns3::Ipv4Address rtr) [member function]
-    cls.add_method('SetAdvertisingRouter', 'void', [param('ns3::Ipv4Address', 'rtr')])
+    cls.add_method('SetAdvertisingRouter', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'rtr')])
     ## global-router-interface.h: void ns3::GlobalRoutingLSA::SetLSType(ns3::GlobalRoutingLSA::LSType typ) [member function]
-    cls.add_method('SetLSType', 'void', [param('ns3::GlobalRoutingLSA::LSType', 'typ')])
+    cls.add_method('SetLSType', 
+                   'void', 
+                   [param('ns3::GlobalRoutingLSA::LSType', 'typ')])
     ## global-router-interface.h: void ns3::GlobalRoutingLSA::SetLinkStateId(ns3::Ipv4Address addr) [member function]
-    cls.add_method('SetLinkStateId', 'void', [param('ns3::Ipv4Address', 'addr')])
+    cls.add_method('SetLinkStateId', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'addr')])
     ## global-router-interface.h: void ns3::GlobalRoutingLSA::SetNetworkLSANetworkMask(ns3::Ipv4Mask mask) [member function]
-    cls.add_method('SetNetworkLSANetworkMask', 'void', [param('ns3::Ipv4Mask', 'mask')])
+    cls.add_method('SetNetworkLSANetworkMask', 
+                   'void', 
+                   [param('ns3::Ipv4Mask', 'mask')])
     ## global-router-interface.h: void ns3::GlobalRoutingLSA::SetStatus(ns3::GlobalRoutingLSA::SPFStatus status) [member function]
-    cls.add_method('SetStatus', 'void', [param('ns3::GlobalRoutingLSA::SPFStatus', 'status')])
+    cls.add_method('SetStatus', 
+                   'void', 
+                   [param('ns3::GlobalRoutingLSA::SPFStatus', 'status')])
     cls.add_output_stream_operator()
     return
 
 def register_Ns3GlobalRoutingLinkRecord_methods(root_module, cls):
     ## global-router-interface.h: ns3::GlobalRoutingLinkRecord::GlobalRoutingLinkRecord() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## global-router-interface.h: ns3::GlobalRoutingLinkRecord::GlobalRoutingLinkRecord(ns3::GlobalRoutingLinkRecord::LinkType linkType, ns3::Ipv4Address linkId, ns3::Ipv4Address linkData, uint16_t metric) [constructor]
-    cls.add_constructor([param('ns3::GlobalRoutingLinkRecord::LinkType', 'linkType'), param('ns3::Ipv4Address', 'linkId'), param('ns3::Ipv4Address', 'linkData'), param('uint16_t', 'metric')], visibility='public')
+    cls.add_constructor([param('ns3::GlobalRoutingLinkRecord::LinkType', 'linkType'), param('ns3::Ipv4Address', 'linkId'), param('ns3::Ipv4Address', 'linkData'), param('uint16_t', 'metric')])
     ## global-router-interface.h: ns3::Ipv4Address ns3::GlobalRoutingLinkRecord::GetLinkId() const [member function]
-    cls.add_method('GetLinkId', 'ns3::Ipv4Address', [], is_const=True)
+    cls.add_method('GetLinkId', 
+                   'ns3::Ipv4Address', 
+                   [], 
+                   is_const=True)
     ## global-router-interface.h: void ns3::GlobalRoutingLinkRecord::SetLinkId(ns3::Ipv4Address addr) [member function]
-    cls.add_method('SetLinkId', 'void', [param('ns3::Ipv4Address', 'addr')])
+    cls.add_method('SetLinkId', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'addr')])
     ## global-router-interface.h: ns3::Ipv4Address ns3::GlobalRoutingLinkRecord::GetLinkData() const [member function]
-    cls.add_method('GetLinkData', 'ns3::Ipv4Address', [], is_const=True)
+    cls.add_method('GetLinkData', 
+                   'ns3::Ipv4Address', 
+                   [], 
+                   is_const=True)
     ## global-router-interface.h: void ns3::GlobalRoutingLinkRecord::SetLinkData(ns3::Ipv4Address addr) [member function]
-    cls.add_method('SetLinkData', 'void', [param('ns3::Ipv4Address', 'addr')])
+    cls.add_method('SetLinkData', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'addr')])
     ## global-router-interface.h: ns3::GlobalRoutingLinkRecord::LinkType ns3::GlobalRoutingLinkRecord::GetLinkType() const [member function]
-    cls.add_method('GetLinkType', 'ns3::GlobalRoutingLinkRecord::LinkType', [], is_const=True)
+    cls.add_method('GetLinkType', 
+                   'ns3::GlobalRoutingLinkRecord::LinkType', 
+                   [], 
+                   is_const=True)
     ## global-router-interface.h: void ns3::GlobalRoutingLinkRecord::SetLinkType(ns3::GlobalRoutingLinkRecord::LinkType linkType) [member function]
-    cls.add_method('SetLinkType', 'void', [param('ns3::GlobalRoutingLinkRecord::LinkType', 'linkType')])
+    cls.add_method('SetLinkType', 
+                   'void', 
+                   [param('ns3::GlobalRoutingLinkRecord::LinkType', 'linkType')])
     ## global-router-interface.h: uint16_t ns3::GlobalRoutingLinkRecord::GetMetric() const [member function]
-    cls.add_method('GetMetric', 'uint16_t', [], is_const=True)
+    cls.add_method('GetMetric', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
     ## global-router-interface.h: void ns3::GlobalRoutingLinkRecord::SetMetric(uint16_t metric) [member function]
-    cls.add_method('SetMetric', 'void', [param('uint16_t', 'metric')])
+    cls.add_method('SetMetric', 
+                   'void', 
+                   [param('uint16_t', 'metric')])
     return
 
 def register_Ns3GlobalRouter_methods(root_module, cls):
     ## global-router-interface.h: static ns3::TypeId ns3::GlobalRouter::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## global-router-interface.h: ns3::GlobalRouter::GlobalRouter() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## global-router-interface.h: ns3::Ipv4Address ns3::GlobalRouter::GetRouterId() const [member function]
-    cls.add_method('GetRouterId', 'ns3::Ipv4Address', [], is_const=True)
+    cls.add_method('GetRouterId', 
+                   'ns3::Ipv4Address', 
+                   [], 
+                   is_const=True)
     ## global-router-interface.h: uint32_t ns3::GlobalRouter::DiscoverLSAs() [member function]
-    cls.add_method('DiscoverLSAs', 'uint32_t', [])
+    cls.add_method('DiscoverLSAs', 
+                   'uint32_t', 
+                   [])
     ## global-router-interface.h: uint32_t ns3::GlobalRouter::GetNumLSAs() const [member function]
-    cls.add_method('GetNumLSAs', 'uint32_t', [], is_const=True)
+    cls.add_method('GetNumLSAs', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## global-router-interface.h: bool ns3::GlobalRouter::GetLSA(uint32_t n, ns3::GlobalRoutingLSA & lsa) const [member function]
-    cls.add_method('GetLSA', 'bool', [param('uint32_t', 'n'), param('ns3::GlobalRoutingLSA&', 'lsa')], is_const=True)
+    cls.add_method('GetLSA', 
+                   'bool', 
+                   [param('uint32_t', 'n'), param('ns3::GlobalRoutingLSA&', 'lsa')], 
+                   is_const=True)
     ## global-router-interface.h: void ns3::GlobalRouter::DoDispose() [member function]
-    cls.add_method('DoDispose', 'void', [], visibility='private', is_virtual=True)
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
     return
 
 def register_functions(root_module):
--- a/bindings/python/ns3_module_helper.py	Fri Jul 18 21:59:43 2008 -0700
+++ b/bindings/python/ns3_module_helper.py	Mon Jul 21 15:53:03 2008 -0700
@@ -1,4 +1,4 @@
-from pybindgen import Module, FileCodeSink, write_preamble, param, retval
+from pybindgen import Module, FileCodeSink, param, retval, cppclass
 
 def register_types(module):
     root_module = module.get_root()
@@ -103,296 +103,544 @@
 
 def register_Ns3MobilityHelper_methods(root_module, cls):
     ## mobility-helper.h: ns3::MobilityHelper::MobilityHelper() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## mobility-helper.h: void ns3::MobilityHelper::SetPositionAllocator(ns3::Ptr<ns3::PositionAllocator> allocator) [member function]
-    cls.add_method('SetPositionAllocator', 'void', [param('ns3::Ptr< ns3::PositionAllocator >', 'allocator')])
+    cls.add_method('SetPositionAllocator', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::PositionAllocator >', 'allocator')])
     ## mobility-helper.h: void ns3::MobilityHelper::SetPositionAllocator(std::string type, std::string n1="", ns3::AttributeValue const & v1=ns3::EmptyAttributeValue(), std::string n2="", ns3::AttributeValue const & v2=ns3::EmptyAttributeValue(), std::string n3="", ns3::AttributeValue const & v3=ns3::EmptyAttributeValue(), std::string n4="", ns3::AttributeValue const & v4=ns3::EmptyAttributeValue(), std::string n5="", ns3::AttributeValue const & v5=ns3::EmptyAttributeValue(), std::string n6="", ns3::AttributeValue const & v6=ns3::EmptyAttributeValue(), std::string n7="", ns3::AttributeValue const & v7=ns3::EmptyAttributeValue(), std::string n8="", ns3::AttributeValue const & v8=ns3::EmptyAttributeValue(), std::string n9="", ns3::AttributeValue const & v9=ns3::EmptyAttributeValue()) [member function]
-    cls.add_method('SetPositionAllocator', 'void', [param('std::string', 'type'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue&', 'v1', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue&', 'v2', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue&', 'v3', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue&', 'v4', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue&', 'v5', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue&', 'v6', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue&', 'v7', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n8', default_value='""'), param('ns3::AttributeValue&', 'v8', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n9', default_value='""'), param('ns3::AttributeValue&', 'v9', default_value='ns3::EmptyAttributeValue()', is_const=True)])
+    cls.add_method('SetPositionAllocator', 
+                   'void', 
+                   [param('std::string', 'type'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue&', 'v1', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue&', 'v2', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue&', 'v3', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue&', 'v4', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue&', 'v5', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue&', 'v6', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue&', 'v7', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n8', default_value='""'), param('ns3::AttributeValue&', 'v8', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n9', default_value='""'), param('ns3::AttributeValue&', 'v9', default_value='ns3::EmptyAttributeValue()', is_const=True)])
     ## mobility-helper.h: void ns3::MobilityHelper::SetMobilityModel(std::string type, std::string n1="", ns3::AttributeValue const & v1=ns3::EmptyAttributeValue(), std::string n2="", ns3::AttributeValue const & v2=ns3::EmptyAttributeValue(), std::string n3="", ns3::AttributeValue const & v3=ns3::EmptyAttributeValue(), std::string n4="", ns3::AttributeValue const & v4=ns3::EmptyAttributeValue(), std::string n5="", ns3::AttributeValue const & v5=ns3::EmptyAttributeValue(), std::string n6="", ns3::AttributeValue const & v6=ns3::EmptyAttributeValue(), std::string n7="", ns3::AttributeValue const & v7=ns3::EmptyAttributeValue(), std::string n8="", ns3::AttributeValue const & v8=ns3::EmptyAttributeValue(), std::string n9="", ns3::AttributeValue const & v9=ns3::EmptyAttributeValue()) [member function]
-    cls.add_method('SetMobilityModel', 'void', [param('std::string', 'type'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue&', 'v1', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue&', 'v2', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue&', 'v3', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue&', 'v4', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue&', 'v5', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue&', 'v6', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue&', 'v7', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n8', default_value='""'), param('ns3::AttributeValue&', 'v8', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n9', default_value='""'), param('ns3::AttributeValue&', 'v9', default_value='ns3::EmptyAttributeValue()', is_const=True)])
+    cls.add_method('SetMobilityModel', 
+                   'void', 
+                   [param('std::string', 'type'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue&', 'v1', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue&', 'v2', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue&', 'v3', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue&', 'v4', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue&', 'v5', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue&', 'v6', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue&', 'v7', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n8', default_value='""'), param('ns3::AttributeValue&', 'v8', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n9', default_value='""'), param('ns3::AttributeValue&', 'v9', default_value='ns3::EmptyAttributeValue()', is_const=True)])
     ## mobility-helper.h: void ns3::MobilityHelper::PushReferenceMobilityModel(ns3::Ptr<ns3::Object> reference) [member function]
-    cls.add_method('PushReferenceMobilityModel', 'void', [param('ns3::Ptr< ns3::Object >', 'reference')])
+    cls.add_method('PushReferenceMobilityModel', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Object >', 'reference')])
     ## mobility-helper.h: void ns3::MobilityHelper::PopReferenceMobilityModel() [member function]
-    cls.add_method('PopReferenceMobilityModel', 'void', [])
+    cls.add_method('PopReferenceMobilityModel', 
+                   'void', 
+                   [])
     ## mobility-helper.h: std::string ns3::MobilityHelper::GetMobilityModelType() const [member function]
-    cls.add_method('GetMobilityModelType', 'std::string', [], is_const=True)
+    cls.add_method('GetMobilityModelType', 
+                   'std::string', 
+                   [], 
+                   is_const=True)
     ## mobility-helper.h: void ns3::MobilityHelper::Install(ns3::NodeContainer container) [member function]
-    cls.add_method('Install', 'void', [param('ns3::NodeContainer', 'container')])
+    cls.add_method('Install', 
+                   'void', 
+                   [param('ns3::NodeContainer', 'container')])
     ## mobility-helper.h: void ns3::MobilityHelper::InstallAll() [member function]
-    cls.add_method('InstallAll', 'void', [])
+    cls.add_method('InstallAll', 
+                   'void', 
+                   [])
     return
 
 def register_Ns3InternetStackHelper_methods(root_module, cls):
     ## internet-stack-helper.h: void ns3::InternetStackHelper::Install(ns3::NodeContainer c) [member function]
-    cls.add_method('Install', 'void', [param('ns3::NodeContainer', 'c')])
+    cls.add_method('Install', 
+                   'void', 
+                   [param('ns3::NodeContainer', 'c')])
     ## internet-stack-helper.h: static void ns3::InternetStackHelper::EnablePcapAll(std::string filename) [member function]
-    cls.add_method('EnablePcapAll', 'void', [param('std::string', 'filename')], is_static=True)
+    cls.add_method('EnablePcapAll', 
+                   'void', 
+                   [param('std::string', 'filename')], 
+                   is_static=True)
     cls.add_constructor([])
     return
 
 def register_Ns3NodeContainer_methods(root_module, cls):
     ## node-container.h: ns3::NodeContainer::NodeContainer() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## node-container.h: ns3::NodeContainer::NodeContainer(ns3::Ptr<ns3::Node> node) [constructor]
-    cls.add_constructor([param('ns3::Ptr< ns3::Node >', 'node')], visibility='public')
+    cls.add_constructor([param('ns3::Ptr< ns3::Node >', 'node')])
     ## node-container.h: ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & a, ns3::NodeContainer const & b) [constructor]
-    cls.add_constructor([param('ns3::NodeContainer&', 'a', is_const=True), param('ns3::NodeContainer&', 'b', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::NodeContainer&', 'a', is_const=True), param('ns3::NodeContainer&', 'b', is_const=True)])
     ## node-container.h: ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & a, ns3::NodeContainer const & b, ns3::NodeContainer const & c) [constructor]
-    cls.add_constructor([param('ns3::NodeContainer&', 'a', is_const=True), param('ns3::NodeContainer&', 'b', is_const=True), param('ns3::NodeContainer&', 'c', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::NodeContainer&', 'a', is_const=True), param('ns3::NodeContainer&', 'b', is_const=True), param('ns3::NodeContainer&', 'c', is_const=True)])
     ## node-container.h: ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & a, ns3::NodeContainer const & b, ns3::NodeContainer const & c, ns3::NodeContainer const & d) [constructor]
-    cls.add_constructor([param('ns3::NodeContainer&', 'a', is_const=True), param('ns3::NodeContainer&', 'b', is_const=True), param('ns3::NodeContainer&', 'c', is_const=True), param('ns3::NodeContainer&', 'd', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::NodeContainer&', 'a', is_const=True), param('ns3::NodeContainer&', 'b', is_const=True), param('ns3::NodeContainer&', 'c', is_const=True), param('ns3::NodeContainer&', 'd', is_const=True)])
     ## node-container.h: __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Node>*,std::vector<ns3::Ptr<ns3::Node>, std::allocator<ns3::Ptr<ns3::Node> > > > ns3::NodeContainer::Begin() const [member function]
-    cls.add_method('Begin', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node >, std::allocator< ns3::Ptr< ns3::Node > > > >', [], is_const=True)
+    cls.add_method('Begin', 
+                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node >, std::allocator< ns3::Ptr< ns3::Node > > > >', 
+                   [], 
+                   is_const=True)
     ## node-container.h: __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Node>*,std::vector<ns3::Ptr<ns3::Node>, std::allocator<ns3::Ptr<ns3::Node> > > > ns3::NodeContainer::End() const [member function]
-    cls.add_method('End', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node >, std::allocator< ns3::Ptr< ns3::Node > > > >', [], is_const=True)
+    cls.add_method('End', 
+                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node >, std::allocator< ns3::Ptr< ns3::Node > > > >', 
+                   [], 
+                   is_const=True)
     ## node-container.h: uint32_t ns3::NodeContainer::GetN() const [member function]
-    cls.add_method('GetN', 'uint32_t', [], is_const=True)
+    cls.add_method('GetN', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## node-container.h: ns3::Ptr<ns3::Node> ns3::NodeContainer::Get(uint32_t i) const [member function]
-    cls.add_method('Get', 'ns3::Ptr< ns3::Node >', [param('uint32_t', 'i')], is_const=True)
+    cls.add_method('Get', 
+                   'ns3::Ptr< ns3::Node >', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
     ## node-container.h: void ns3::NodeContainer::Create(uint32_t n) [member function]
-    cls.add_method('Create', 'void', [param('uint32_t', 'n')])
+    cls.add_method('Create', 
+                   'void', 
+                   [param('uint32_t', 'n')])
     ## node-container.h: void ns3::NodeContainer::Add(ns3::NodeContainer other) [member function]
-    cls.add_method('Add', 'void', [param('ns3::NodeContainer', 'other')])
+    cls.add_method('Add', 
+                   'void', 
+                   [param('ns3::NodeContainer', 'other')])
     ## node-container.h: void ns3::NodeContainer::Add(ns3::Ptr<ns3::Node> node) [member function]
-    cls.add_method('Add', 'void', [param('ns3::Ptr< ns3::Node >', 'node')])
+    cls.add_method('Add', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Node >', 'node')])
     ## node-container.h: static ns3::NodeContainer ns3::NodeContainer::GetGlobal() [member function]
-    cls.add_method('GetGlobal', 'ns3::NodeContainer', [], is_static=True)
+    cls.add_method('GetGlobal', 
+                   'ns3::NodeContainer', 
+                   [], 
+                   is_static=True)
     return
 
 def register_Ns3PointToPointHelper_methods(root_module, cls):
     ## point-to-point-helper.h: ns3::PointToPointHelper::PointToPointHelper() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## point-to-point-helper.h: void ns3::PointToPointHelper::SetQueue(std::string type, std::string n1="", ns3::AttributeValue const & v1=ns3::EmptyAttributeValue(), std::string n2="", ns3::AttributeValue const & v2=ns3::EmptyAttributeValue(), std::string n3="", ns3::AttributeValue const & v3=ns3::EmptyAttributeValue(), std::string n4="", ns3::AttributeValue const & v4=ns3::EmptyAttributeValue()) [member function]
-    cls.add_method('SetQueue', 'void', [param('std::string', 'type'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue&', 'v1', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue&', 'v2', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue&', 'v3', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue&', 'v4', default_value='ns3::EmptyAttributeValue()', is_const=True)])
+    cls.add_method('SetQueue', 
+                   'void', 
+                   [param('std::string', 'type'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue&', 'v1', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue&', 'v2', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue&', 'v3', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue&', 'v4', default_value='ns3::EmptyAttributeValue()', is_const=True)])
     ## point-to-point-helper.h: void ns3::PointToPointHelper::SetDeviceAttribute(std::string name, ns3::AttributeValue const & value) [member function]
-    cls.add_method('SetDeviceAttribute', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
+    cls.add_method('SetDeviceAttribute', 
+                   'void', 
+                   [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
     ## point-to-point-helper.h: void ns3::PointToPointHelper::SetChannelAttribute(std::string name, ns3::AttributeValue const & value) [member function]
-    cls.add_method('SetChannelAttribute', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
+    cls.add_method('SetChannelAttribute', 
+                   'void', 
+                   [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
     ## point-to-point-helper.h: void ns3::PointToPointHelper::SetDeviceParameter(std::string name, ns3::AttributeValue const & value) [member function]
-    cls.add_method('SetDeviceParameter', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
+    cls.add_method('SetDeviceParameter', 
+                   'void', 
+                   [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)], 
+                   deprecated=True)
     ## point-to-point-helper.h: void ns3::PointToPointHelper::SetChannelParameter(std::string name, ns3::AttributeValue const & value) [member function]
-    cls.add_method('SetChannelParameter', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
+    cls.add_method('SetChannelParameter', 
+                   'void', 
+                   [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)], 
+                   deprecated=True)
     ## point-to-point-helper.h: static void ns3::PointToPointHelper::EnablePcap(std::string filename, uint32_t nodeid, uint32_t deviceid) [member function]
-    cls.add_method('EnablePcap', 'void', [param('std::string', 'filename'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')], is_static=True)
+    cls.add_method('EnablePcap', 
+                   'void', 
+                   [param('std::string', 'filename'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')], 
+                   is_static=True)
     ## point-to-point-helper.h: static void ns3::PointToPointHelper::EnablePcap(std::string filename, ns3::NetDeviceContainer d) [member function]
-    cls.add_method('EnablePcap', 'void', [param('std::string', 'filename'), param('ns3::NetDeviceContainer', 'd')], is_static=True)
+    cls.add_method('EnablePcap', 
+                   'void', 
+                   [param('std::string', 'filename'), param('ns3::NetDeviceContainer', 'd')], 
+                   is_static=True)
     ## point-to-point-helper.h: static void ns3::PointToPointHelper::EnablePcap(std::string filename, ns3::NodeContainer n) [member function]
-    cls.add_method('EnablePcap', 'void', [param('std::string', 'filename'), param('ns3::NodeContainer', 'n')], is_static=True)
+    cls.add_method('EnablePcap', 
+                   'void', 
+                   [param('std::string', 'filename'), param('ns3::NodeContainer', 'n')], 
+                   is_static=True)
     ## point-to-point-helper.h: static void ns3::PointToPointHelper::EnablePcapAll(std::string filename) [member function]
-    cls.add_method('EnablePcapAll', 'void', [param('std::string', 'filename')], is_static=True)
+    cls.add_method('EnablePcapAll', 
+                   'void', 
+                   [param('std::string', 'filename')], 
+                   is_static=True)
     ## point-to-point-helper.h: static void ns3::PointToPointHelper::EnableAscii(std::ostream & os, uint32_t nodeid, uint32_t deviceid) [member function]
-    cls.add_method('EnableAscii', 'void', [param('std::ostream&', 'os'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')], is_static=True)
+    cls.add_method('EnableAscii', 
+                   'void', 
+                   [param('std::ostream&', 'os'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')], 
+                   is_static=True)
     ## point-to-point-helper.h: static void ns3::PointToPointHelper::EnableAscii(std::ostream & os, ns3::NetDeviceContainer d) [member function]
-    cls.add_method('EnableAscii', 'void', [param('std::ostream&', 'os'), param('ns3::NetDeviceContainer', 'd')], is_static=True)
+    cls.add_method('EnableAscii', 
+                   'void', 
+                   [param('std::ostream&', 'os'), param('ns3::NetDeviceContainer', 'd')], 
+                   is_static=True)
     ## point-to-point-helper.h: static void ns3::PointToPointHelper::EnableAscii(std::ostream & os, ns3::NodeContainer n) [member function]
-    cls.add_method('EnableAscii', 'void', [param('std::ostream&', 'os'), param('ns3::NodeContainer', 'n')], is_static=True)
+    cls.add_method('EnableAscii', 
+                   'void', 
+                   [param('std::ostream&', 'os'), param('ns3::NodeContainer', 'n')], 
+                   is_static=True)
     ## point-to-point-helper.h: static void ns3::PointToPointHelper::EnableAsciiAll(std::ostream & os) [member function]
-    cls.add_method('EnableAsciiAll', 'void', [param('std::ostream&', 'os')], is_static=True)
+    cls.add_method('EnableAsciiAll', 
+                   'void', 
+                   [param('std::ostream&', 'os')], 
+                   is_static=True)
     ## point-to-point-helper.h: ns3::NetDeviceContainer ns3::PointToPointHelper::Install(ns3::NodeContainer c) [member function]
-    cls.add_method('Install', 'ns3::NetDeviceContainer', [param('ns3::NodeContainer', 'c')])
+    cls.add_method('Install', 
+                   'ns3::NetDeviceContainer', 
+                   [param('ns3::NodeContainer', 'c')])
     ## point-to-point-helper.h: ns3::NetDeviceContainer ns3::PointToPointHelper::Install(ns3::Ptr<ns3::Node> a, ns3::Ptr<ns3::Node> b) [member function]
-    cls.add_method('Install', 'ns3::NetDeviceContainer', [param('ns3::Ptr< ns3::Node >', 'a'), param('ns3::Ptr< ns3::Node >', 'b')])
+    cls.add_method('Install', 
+                   'ns3::NetDeviceContainer', 
+                   [param('ns3::Ptr< ns3::Node >', 'a'), param('ns3::Ptr< ns3::Node >', 'b')])
     return
 
 def register_Ns3NetDeviceContainer_methods(root_module, cls):
     ## net-device-container.h: __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::NetDevice>*,std::vector<ns3::Ptr<ns3::NetDevice>, std::allocator<ns3::Ptr<ns3::NetDevice> > > > ns3::NetDeviceContainer::Begin() const [member function]
-    cls.add_method('Begin', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::NetDevice >, std::vector< ns3::Ptr< ns3::NetDevice >, std::allocator< ns3::Ptr< ns3::NetDevice > > > >', [], is_const=True)
+    cls.add_method('Begin', 
+                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::NetDevice >, std::vector< ns3::Ptr< ns3::NetDevice >, std::allocator< ns3::Ptr< ns3::NetDevice > > > >', 
+                   [], 
+                   is_const=True)
     ## net-device-container.h: __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::NetDevice>*,std::vector<ns3::Ptr<ns3::NetDevice>, std::allocator<ns3::Ptr<ns3::NetDevice> > > > ns3::NetDeviceContainer::End() const [member function]
-    cls.add_method('End', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::NetDevice >, std::vector< ns3::Ptr< ns3::NetDevice >, std::allocator< ns3::Ptr< ns3::NetDevice > > > >', [], is_const=True)
+    cls.add_method('End', 
+                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::NetDevice >, std::vector< ns3::Ptr< ns3::NetDevice >, std::allocator< ns3::Ptr< ns3::NetDevice > > > >', 
+                   [], 
+                   is_const=True)
     ## net-device-container.h: uint32_t ns3::NetDeviceContainer::GetN() const [member function]
-    cls.add_method('GetN', 'uint32_t', [], is_const=True)
+    cls.add_method('GetN', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## net-device-container.h: ns3::Ptr<ns3::NetDevice> ns3::NetDeviceContainer::Get(uint32_t i) const [member function]
-    cls.add_method('Get', 'ns3::Ptr< ns3::NetDevice >', [param('uint32_t', 'i')], is_const=True)
+    cls.add_method('Get', 
+                   'ns3::Ptr< ns3::NetDevice >', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
     ## net-device-container.h: void ns3::NetDeviceContainer::Add(ns3::NetDeviceContainer other) [member function]
-    cls.add_method('Add', 'void', [param('ns3::NetDeviceContainer', 'other')])
+    cls.add_method('Add', 
+                   'void', 
+                   [param('ns3::NetDeviceContainer', 'other')])
     ## net-device-container.h: void ns3::NetDeviceContainer::Add(ns3::Ptr<ns3::NetDevice> device) [member function]
-    cls.add_method('Add', 'void', [param('ns3::Ptr< ns3::NetDevice >', 'device')])
+    cls.add_method('Add', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::NetDevice >', 'device')])
     cls.add_constructor([])
     return
 
 def register_Ns3CsmaHelper_methods(root_module, cls):
     ## csma-helper.h: ns3::CsmaHelper::CsmaHelper() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## csma-helper.h: void ns3::CsmaHelper::SetQueue(std::string type, std::string n1="", ns3::AttributeValue const & v1=ns3::EmptyAttributeValue(), std::string n2="", ns3::AttributeValue const & v2=ns3::EmptyAttributeValue(), std::string n3="", ns3::AttributeValue const & v3=ns3::EmptyAttributeValue(), std::string n4="", ns3::AttributeValue const & v4=ns3::EmptyAttributeValue()) [member function]
-    cls.add_method('SetQueue', 'void', [param('std::string', 'type'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue&', 'v1', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue&', 'v2', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue&', 'v3', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue&', 'v4', default_value='ns3::EmptyAttributeValue()', is_const=True)])
+    cls.add_method('SetQueue', 
+                   'void', 
+                   [param('std::string', 'type'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue&', 'v1', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue&', 'v2', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue&', 'v3', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue&', 'v4', default_value='ns3::EmptyAttributeValue()', is_const=True)])
     ## csma-helper.h: void ns3::CsmaHelper::SetDeviceAttribute(std::string n1, ns3::AttributeValue const & v1) [member function]
-    cls.add_method('SetDeviceAttribute', 'void', [param('std::string', 'n1'), param('ns3::AttributeValue&', 'v1', is_const=True)])
+    cls.add_method('SetDeviceAttribute', 
+                   'void', 
+                   [param('std::string', 'n1'), param('ns3::AttributeValue&', 'v1', is_const=True)])
     ## csma-helper.h: void ns3::CsmaHelper::SetChannelAttribute(std::string n1, ns3::AttributeValue const & v1) [member function]
-    cls.add_method('SetChannelAttribute', 'void', [param('std::string', 'n1'), param('ns3::AttributeValue&', 'v1', is_const=True)])
+    cls.add_method('SetChannelAttribute', 
+                   'void', 
+                   [param('std::string', 'n1'), param('ns3::AttributeValue&', 'v1', is_const=True)])
     ## csma-helper.h: void ns3::CsmaHelper::SetDeviceParameter(std::string n1, ns3::AttributeValue const & v1) [member function]
-    cls.add_method('SetDeviceParameter', 'void', [param('std::string', 'n1'), param('ns3::AttributeValue&', 'v1', is_const=True)])
+    cls.add_method('SetDeviceParameter', 
+                   'void', 
+                   [param('std::string', 'n1'), param('ns3::AttributeValue&', 'v1', is_const=True)], 
+                   deprecated=True)
     ## csma-helper.h: void ns3::CsmaHelper::SetChannelParameter(std::string n1, ns3::AttributeValue const & v1) [member function]
-    cls.add_method('SetChannelParameter', 'void', [param('std::string', 'n1'), param('ns3::AttributeValue&', 'v1', is_const=True)])
+    cls.add_method('SetChannelParameter', 
+                   'void', 
+                   [param('std::string', 'n1'), param('ns3::AttributeValue&', 'v1', is_const=True)], 
+                   deprecated=True)
     ## csma-helper.h: static void ns3::CsmaHelper::EnablePcap(std::string filename, uint32_t nodeid, uint32_t deviceid) [member function]
-    cls.add_method('EnablePcap', 'void', [param('std::string', 'filename'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')], is_static=True)
+    cls.add_method('EnablePcap', 
+                   'void', 
+                   [param('std::string', 'filename'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')], 
+                   is_static=True)
     ## csma-helper.h: static void ns3::CsmaHelper::EnablePcap(std::string filename, ns3::NetDeviceContainer d) [member function]
-    cls.add_method('EnablePcap', 'void', [param('std::string', 'filename'), param('ns3::NetDeviceContainer', 'd')], is_static=True)
+    cls.add_method('EnablePcap', 
+                   'void', 
+                   [param('std::string', 'filename'), param('ns3::NetDeviceContainer', 'd')], 
+                   is_static=True)
     ## csma-helper.h: static void ns3::CsmaHelper::EnablePcap(std::string filename, ns3::NodeContainer n) [member function]
-    cls.add_method('EnablePcap', 'void', [param('std::string', 'filename'), param('ns3::NodeContainer', 'n')], is_static=True)
+    cls.add_method('EnablePcap', 
+                   'void', 
+                   [param('std::string', 'filename'), param('ns3::NodeContainer', 'n')], 
+                   is_static=True)
     ## csma-helper.h: static void ns3::CsmaHelper::EnablePcapAll(std::string filename) [member function]
-    cls.add_method('EnablePcapAll', 'void', [param('std::string', 'filename')], is_static=True)
+    cls.add_method('EnablePcapAll', 
+                   'void', 
+                   [param('std::string', 'filename')], 
+                   is_static=True)
     ## csma-helper.h: static void ns3::CsmaHelper::EnableAscii(std::ostream & os, uint32_t nodeid, uint32_t deviceid) [member function]
-    cls.add_method('EnableAscii', 'void', [param('std::ostream&', 'os'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')], is_static=True)
+    cls.add_method('EnableAscii', 
+                   'void', 
+                   [param('std::ostream&', 'os'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')], 
+                   is_static=True)
     ## csma-helper.h: static void ns3::CsmaHelper::EnableAscii(std::ostream & os, ns3::NetDeviceContainer d) [member function]
-    cls.add_method('EnableAscii', 'void', [param('std::ostream&', 'os'), param('ns3::NetDeviceContainer', 'd')], is_static=True)
+    cls.add_method('EnableAscii', 
+                   'void', 
+                   [param('std::ostream&', 'os'), param('ns3::NetDeviceContainer', 'd')], 
+                   is_static=True)
     ## csma-helper.h: static void ns3::CsmaHelper::EnableAscii(std::ostream & os, ns3::NodeContainer n) [member function]
-    cls.add_method('EnableAscii', 'void', [param('std::ostream&', 'os'), param('ns3::NodeContainer', 'n')], is_static=True)
+    cls.add_method('EnableAscii', 
+                   'void', 
+                   [param('std::ostream&', 'os'), param('ns3::NodeContainer', 'n')], 
+                   is_static=True)
     ## csma-helper.h: static void ns3::CsmaHelper::EnableAsciiAll(std::ostream & os) [member function]
-    cls.add_method('EnableAsciiAll', 'void', [param('std::ostream&', 'os')], is_static=True)
+    cls.add_method('EnableAsciiAll', 
+                   'void', 
+                   [param('std::ostream&', 'os')], 
+                   is_static=True)
     ## csma-helper.h: ns3::NetDeviceContainer ns3::CsmaHelper::Install(ns3::NodeContainer const & c) [member function]
-    cls.add_method('Install', 'ns3::NetDeviceContainer', [param('ns3::NodeContainer&', 'c', is_const=True)])
+    cls.add_method('Install', 
+                   'ns3::NetDeviceContainer', 
+                   [param('ns3::NodeContainer&', 'c', is_const=True)])
     ## csma-helper.h: ns3::NetDeviceContainer ns3::CsmaHelper::Install(ns3::NodeContainer const & c, ns3::Ptr<ns3::CsmaChannel> channel) [member function]
-    cls.add_method('Install', 'ns3::NetDeviceContainer', [param('ns3::NodeContainer&', 'c', is_const=True), param('ns3::Ptr< ns3::CsmaChannel >', 'channel')])
+    cls.add_method('Install', 
+                   'ns3::NetDeviceContainer', 
+                   [param('ns3::NodeContainer&', 'c', is_const=True), param('ns3::Ptr< ns3::CsmaChannel >', 'channel')])
     return
 
 def register_Ns3UdpEchoServerHelper_methods(root_module, cls):
     ## udp-echo-helper.h: ns3::UdpEchoServerHelper::UdpEchoServerHelper(uint16_t port) [constructor]
-    cls.add_constructor([param('uint16_t', 'port')], visibility='public')
+    cls.add_constructor([param('uint16_t', 'port')])
     ## udp-echo-helper.h: void ns3::UdpEchoServerHelper::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function]
-    cls.add_method('SetAttribute', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
+    cls.add_method('SetAttribute', 
+                   'void', 
+                   [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
     ## udp-echo-helper.h: ns3::ApplicationContainer ns3::UdpEchoServerHelper::Install(ns3::NodeContainer c) [member function]
-    cls.add_method('Install', 'ns3::ApplicationContainer', [param('ns3::NodeContainer', 'c')])
+    cls.add_method('Install', 
+                   'ns3::ApplicationContainer', 
+                   [param('ns3::NodeContainer', 'c')])
     return
 
 def register_Ns3OlsrHelper_methods(root_module, cls):
     ## olsr-helper.h: ns3::OlsrHelper::OlsrHelper() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## olsr-helper.h: void ns3::OlsrHelper::SetAgent(std::string tid, std::string n0="", ns3::AttributeValue const & v0=ns3::EmptyAttributeValue(), std::string n1="", ns3::AttributeValue const & v1=ns3::EmptyAttributeValue(), std::string n2="", ns3::AttributeValue const & v2=ns3::EmptyAttributeValue(), std::string n3="", ns3::AttributeValue const & v3=ns3::EmptyAttributeValue(), std::string n4="", ns3::AttributeValue const & v4=ns3::EmptyAttributeValue(), std::string n5="", ns3::AttributeValue const & v5=ns3::EmptyAttributeValue(), std::string n6="", ns3::AttributeValue const & v6=ns3::EmptyAttributeValue(), std::string n7="", ns3::AttributeValue const & v7=ns3::EmptyAttributeValue()) [member function]
-    cls.add_method('SetAgent', 'void', [param('std::string', 'tid'), param('std::string', 'n0', default_value='""'), param('ns3::AttributeValue&', 'v0', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue&', 'v1', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue&', 'v2', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue&', 'v3', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue&', 'v4', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue&', 'v5', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue&', 'v6', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue&', 'v7', default_value='ns3::EmptyAttributeValue()', is_const=True)])
+    cls.add_method('SetAgent', 
+                   'void', 
+                   [param('std::string', 'tid'), param('std::string', 'n0', default_value='""'), param('ns3::AttributeValue&', 'v0', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue&', 'v1', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue&', 'v2', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue&', 'v3', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue&', 'v4', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue&', 'v5', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue&', 'v6', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue&', 'v7', default_value='ns3::EmptyAttributeValue()', is_const=True)])
     ## olsr-helper.h: void ns3::OlsrHelper::Install(ns3::NodeContainer container) [member function]
-    cls.add_method('Install', 'void', [param('ns3::NodeContainer', 'container')])
+    cls.add_method('Install', 
+                   'void', 
+                   [param('ns3::NodeContainer', 'container')])
     ## olsr-helper.h: void ns3::OlsrHelper::Install(ns3::Ptr<ns3::Node> node) [member function]
-    cls.add_method('Install', 'void', [param('ns3::Ptr< ns3::Node >', 'node')])
+    cls.add_method('Install', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Node >', 'node')])
     ## olsr-helper.h: void ns3::OlsrHelper::InstallAll() [member function]
-    cls.add_method('InstallAll', 'void', [])
+    cls.add_method('InstallAll', 
+                   'void', 
+                   [])
     return
 
 def register_Ns3PacketSocketHelper_methods(root_module, cls):
     ## packet-socket-helper.h: void ns3::PacketSocketHelper::Install(ns3::NodeContainer c) [member function]
-    cls.add_method('Install', 'void', [param('ns3::NodeContainer', 'c')])
+    cls.add_method('Install', 
+                   'void', 
+                   [param('ns3::NodeContainer', 'c')])
     cls.add_constructor([])
     return
 
 def register_Ns3OnOffHelper_methods(root_module, cls):
     ## on-off-helper.h: ns3::OnOffHelper::OnOffHelper(std::string protocol, ns3::Address address) [constructor]
-    cls.add_constructor([param('std::string', 'protocol'), param('ns3::Address', 'address')], visibility='public')
+    cls.add_constructor([param('std::string', 'protocol'), param('ns3::Address', 'address')])
     ## on-off-helper.h: void ns3::OnOffHelper::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function]
-    cls.add_method('SetAttribute', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
+    cls.add_method('SetAttribute', 
+                   'void', 
+                   [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
     ## on-off-helper.h: ns3::ApplicationContainer ns3::OnOffHelper::Install(ns3::NodeContainer c) [member function]
-    cls.add_method('Install', 'ns3::ApplicationContainer', [param('ns3::NodeContainer', 'c')])
+    cls.add_method('Install', 
+                   'ns3::ApplicationContainer', 
+                   [param('ns3::NodeContainer', 'c')])
     return
 
 def register_Ns3UdpEchoClientHelper_methods(root_module, cls):
     ## udp-echo-helper.h: ns3::UdpEchoClientHelper::UdpEchoClientHelper(ns3::Ipv4Address ip, uint16_t port) [constructor]
-    cls.add_constructor([param('ns3::Ipv4Address', 'ip'), param('uint16_t', 'port')], visibility='public')
+    cls.add_constructor([param('ns3::Ipv4Address', 'ip'), param('uint16_t', 'port')])
     ## udp-echo-helper.h: void ns3::UdpEchoClientHelper::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function]
-    cls.add_method('SetAttribute', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
+    cls.add_method('SetAttribute', 
+                   'void', 
+                   [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
     ## udp-echo-helper.h: ns3::ApplicationContainer ns3::UdpEchoClientHelper::Install(ns3::NodeContainer c) [member function]
-    cls.add_method('Install', 'ns3::ApplicationContainer', [param('ns3::NodeContainer', 'c')])
+    cls.add_method('Install', 
+                   'ns3::ApplicationContainer', 
+                   [param('ns3::NodeContainer', 'c')])
     return
 
 def register_Ns3StaticMulticastRouteHelper_methods(root_module, cls):
     ## static-multicast-route-helper.h: ns3::StaticMulticastRouteHelper::StaticMulticastRouteHelper() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## static-multicast-route-helper.h: void ns3::StaticMulticastRouteHelper::AddMulticastRoute(ns3::Ptr<ns3::Node> arg0, ns3::Ipv4Address source, ns3::Ipv4Address group, ns3::Ptr<ns3::NetDevice> input, ns3::NetDeviceContainer output) [member function]
-    cls.add_method('AddMulticastRoute', 'void', [param('ns3::Ptr< ns3::Node >', 'arg0'), param('ns3::Ipv4Address', 'source'), param('ns3::Ipv4Address', 'group'), param('ns3::Ptr< ns3::NetDevice >', 'input'), param('ns3::NetDeviceContainer', 'output')])
+    cls.add_method('AddMulticastRoute', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Node >', 'arg0'), param('ns3::Ipv4Address', 'source'), param('ns3::Ipv4Address', 'group'), param('ns3::Ptr< ns3::NetDevice >', 'input'), param('ns3::NetDeviceContainer', 'output')])
     ## static-multicast-route-helper.h: void ns3::StaticMulticastRouteHelper::SetDefaultMulticastRoute(ns3::Ptr<ns3::Node> n, ns3::Ptr<ns3::NetDevice> nd) [member function]
-    cls.add_method('SetDefaultMulticastRoute', 'void', [param('ns3::Ptr< ns3::Node >', 'n'), param('ns3::Ptr< ns3::NetDevice >', 'nd')])
+    cls.add_method('SetDefaultMulticastRoute', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Node >', 'n'), param('ns3::Ptr< ns3::NetDevice >', 'nd')])
     ## static-multicast-route-helper.h: void ns3::StaticMulticastRouteHelper::JoinMulticastGroup(ns3::Ptr<ns3::Node> n, ns3::Ipv4Address source, ns3::Ipv4Address group) [member function]
-    cls.add_method('JoinMulticastGroup', 'void', [param('ns3::Ptr< ns3::Node >', 'n'), param('ns3::Ipv4Address', 'source'), param('ns3::Ipv4Address', 'group')])
+    cls.add_method('JoinMulticastGroup', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Node >', 'n'), param('ns3::Ipv4Address', 'source'), param('ns3::Ipv4Address', 'group')])
     return
 
 def register_Ns3Ipv4InterfaceContainer_methods(root_module, cls):
     ## ipv4-interface-container.h: ns3::Ipv4InterfaceContainer::Ipv4InterfaceContainer() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## ipv4-interface-container.h: uint32_t ns3::Ipv4InterfaceContainer::GetN() const [member function]
-    cls.add_method('GetN', 'uint32_t', [], is_const=True)
+    cls.add_method('GetN', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## ipv4-interface-container.h: ns3::Ipv4Address ns3::Ipv4InterfaceContainer::GetAddress(uint32_t i) const [member function]
-    cls.add_method('GetAddress', 'ns3::Ipv4Address', [param('uint32_t', 'i')], is_const=True)
+    cls.add_method('GetAddress', 
+                   'ns3::Ipv4Address', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
     ## ipv4-interface-container.h: void ns3::Ipv4InterfaceContainer::SetMetric(uint32_t i, uint16_t metric) [member function]
-    cls.add_method('SetMetric', 'void', [param('uint32_t', 'i'), param('uint16_t', 'metric')])
+    cls.add_method('SetMetric', 
+                   'void', 
+                   [param('uint32_t', 'i'), param('uint16_t', 'metric')])
     ## ipv4-interface-container.h: void ns3::Ipv4InterfaceContainer::Add(ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface) [member function]
-    cls.add_method('Add', 'void', [param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')])
+    cls.add_method('Add', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')])
     return
 
 def register_Ns3ApplicationContainer_methods(root_module, cls):
     ## application-container.h: __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Application>*,std::vector<ns3::Ptr<ns3::Application>, std::allocator<ns3::Ptr<ns3::Application> > > > ns3::ApplicationContainer::Begin() const [member function]
-    cls.add_method('Begin', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Application >, std::vector< ns3::Ptr< ns3::Application >, std::allocator< ns3::Ptr< ns3::Application > > > >', [], is_const=True)
+    cls.add_method('Begin', 
+                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Application >, std::vector< ns3::Ptr< ns3::Application >, std::allocator< ns3::Ptr< ns3::Application > > > >', 
+                   [], 
+                   is_const=True)
     ## application-container.h: __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Application>*,std::vector<ns3::Ptr<ns3::Application>, std::allocator<ns3::Ptr<ns3::Application> > > > ns3::ApplicationContainer::End() const [member function]
-    cls.add_method('End', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Application >, std::vector< ns3::Ptr< ns3::Application >, std::allocator< ns3::Ptr< ns3::Application > > > >', [], is_const=True)
+    cls.add_method('End', 
+                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Application >, std::vector< ns3::Ptr< ns3::Application >, std::allocator< ns3::Ptr< ns3::Application > > > >', 
+                   [], 
+                   is_const=True)
     ## application-container.h: uint32_t ns3::ApplicationContainer::GetN() const [member function]
-    cls.add_method('GetN', 'uint32_t', [], is_const=True)
+    cls.add_method('GetN', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## application-container.h: ns3::Ptr<ns3::Application> ns3::ApplicationContainer::Get(uint32_t i) const [member function]
-    cls.add_method('Get', 'ns3::Ptr< ns3::Application >', [param('uint32_t', 'i')], is_const=True)
+    cls.add_method('Get', 
+                   'ns3::Ptr< ns3::Application >', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
     ## application-container.h: void ns3::ApplicationContainer::Add(ns3::ApplicationContainer other) [member function]
-    cls.add_method('Add', 'void', [param('ns3::ApplicationContainer', 'other')])
+    cls.add_method('Add', 
+                   'void', 
+                   [param('ns3::ApplicationContainer', 'other')])
     ## application-container.h: void ns3::ApplicationContainer::Add(ns3::Ptr<ns3::Application> application) [member function]
-    cls.add_method('Add', 'void', [param('ns3::Ptr< ns3::Application >', 'application')])
+    cls.add_method('Add', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Application >', 'application')])
     ## application-container.h: void ns3::ApplicationContainer::Start(ns3::Time start) [member function]
-    cls.add_method('Start', 'void', [param('ns3::Time', 'start')])
+    cls.add_method('Start', 
+                   'void', 
+                   [param('ns3::Time', 'start')])
     ## application-container.h: void ns3::ApplicationContainer::Stop(ns3::Time stop) [member function]
-    cls.add_method('Stop', 'void', [param('ns3::Time', 'stop')])
+    cls.add_method('Stop', 
+                   'void', 
+                   [param('ns3::Time', 'stop')])
     cls.add_constructor([])
     return
 
 def register_Ns3WifiHelper_methods(root_module, cls):
     ## wifi-helper.h: ns3::WifiHelper::WifiHelper() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## wifi-helper.h: void ns3::WifiHelper::SetRemoteStationManager(std::string type, std::string n0="", ns3::AttributeValue const & v0=ns3::EmptyAttributeValue(), std::string n1="", ns3::AttributeValue const & v1=ns3::EmptyAttributeValue(), std::string n2="", ns3::AttributeValue const & v2=ns3::EmptyAttributeValue(), std::string n3="", ns3::AttributeValue const & v3=ns3::EmptyAttributeValue(), std::string n4="", ns3::AttributeValue const & v4=ns3::EmptyAttributeValue(), std::string n5="", ns3::AttributeValue const & v5=ns3::EmptyAttributeValue(), std::string n6="", ns3::AttributeValue const & v6=ns3::EmptyAttributeValue(), std::string n7="", ns3::AttributeValue const & v7=ns3::EmptyAttributeValue()) [member function]
-    cls.add_method('SetRemoteStationManager', 'void', [param('std::string', 'type'), param('std::string', 'n0', default_value='""'), param('ns3::AttributeValue&', 'v0', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue&', 'v1', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue&', 'v2', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue&', 'v3', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue&', 'v4', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue&', 'v5', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue&', 'v6', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue&', 'v7', default_value='ns3::EmptyAttributeValue()', is_const=True)])
+    cls.add_method('SetRemoteStationManager', 
+                   'void', 
+                   [param('std::string', 'type'), param('std::string', 'n0', default_value='""'), param('ns3::AttributeValue&', 'v0', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue&', 'v1', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue&', 'v2', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue&', 'v3', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue&', 'v4', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue&', 'v5', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue&', 'v6', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue&', 'v7', default_value='ns3::EmptyAttributeValue()', is_const=True)])
     ## wifi-helper.h: void ns3::WifiHelper::SetMac(std::string type, std::string n0="", ns3::AttributeValue const & v0=ns3::EmptyAttributeValue(), std::string n1="", ns3::AttributeValue const & v1=ns3::EmptyAttributeValue(), std::string n2="", ns3::AttributeValue const & v2=ns3::EmptyAttributeValue(), std::string n3="", ns3::AttributeValue const & v3=ns3::EmptyAttributeValue(), std::string n4="", ns3::AttributeValue const & v4=ns3::EmptyAttributeValue(), std::string n5="", ns3::AttributeValue const & v5=ns3::EmptyAttributeValue(), std::string n6="", ns3::AttributeValue const & v6=ns3::EmptyAttributeValue(), std::string n7="", ns3::AttributeValue const & v7=ns3::EmptyAttributeValue()) [member function]
-    cls.add_method('SetMac', 'void', [param('std::string', 'type'), param('std::string', 'n0', default_value='""'), param('ns3::AttributeValue&', 'v0', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue&', 'v1', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue&', 'v2', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue&', 'v3', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue&', 'v4', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue&', 'v5', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue&', 'v6', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue&', 'v7', default_value='ns3::EmptyAttributeValue()', is_const=True)])
+    cls.add_method('SetMac', 
+                   'void', 
+                   [param('std::string', 'type'), param('std::string', 'n0', default_value='""'), param('ns3::AttributeValue&', 'v0', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue&', 'v1', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue&', 'v2', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue&', 'v3', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue&', 'v4', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue&', 'v5', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue&', 'v6', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue&', 'v7', default_value='ns3::EmptyAttributeValue()', is_const=True)])
     ## wifi-helper.h: void ns3::WifiHelper::SetPhy(std::string phyType, std::string n0="", ns3::AttributeValue const & v0=ns3::EmptyAttributeValue(), std::string n1="", ns3::AttributeValue const & v1=ns3::EmptyAttributeValue(), std::string n2="", ns3::AttributeValue const & v2=ns3::EmptyAttributeValue(), std::string n3="", ns3::AttributeValue const & v3=ns3::EmptyAttributeValue(), std::string n4="", ns3::AttributeValue const & v4=ns3::EmptyAttributeValue(), std::string n5="", ns3::AttributeValue const & v5=ns3::EmptyAttributeValue(), std::string n6="", ns3::AttributeValue const & v6=ns3::EmptyAttributeValue(), std::string n7="", ns3::AttributeValue const & v7=ns3::EmptyAttributeValue()) [member function]
-    cls.add_method('SetPhy', 'void', [param('std::string', 'phyType'), param('std::string', 'n0', default_value='""'), param('ns3::AttributeValue&', 'v0', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue&', 'v1', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue&', 'v2', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue&', 'v3', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue&', 'v4', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue&', 'v5', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue&', 'v6', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue&', 'v7', default_value='ns3::EmptyAttributeValue()', is_const=True)])
+    cls.add_method('SetPhy', 
+                   'void', 
+                   [param('std::string', 'phyType'), param('std::string', 'n0', default_value='""'), param('ns3::AttributeValue&', 'v0', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue&', 'v1', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue&', 'v2', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue&', 'v3', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue&', 'v4', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue&', 'v5', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue&', 'v6', default_value='ns3::EmptyAttributeValue()', is_const=True), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue&', 'v7', default_value='ns3::EmptyAttributeValue()', is_const=True)])
     ## wifi-helper.h: static void ns3::WifiHelper::EnablePcap(std::string filename, uint32_t nodeid, uint32_t deviceid) [member function]
-    cls.add_method('EnablePcap', 'void', [param('std::string', 'filename'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')], is_static=True)
+    cls.add_method('EnablePcap', 
+                   'void', 
+                   [param('std::string', 'filename'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')], 
+                   is_static=True)
     ## wifi-helper.h: static void ns3::WifiHelper::EnablePcap(std::string filename, ns3::NetDeviceContainer d) [member function]
-    cls.add_method('EnablePcap', 'void', [param('std::string', 'filename'), param('ns3::NetDeviceContainer', 'd')], is_static=True)
+    cls.add_method('EnablePcap', 
+                   'void', 
+                   [param('std::string', 'filename'), param('ns3::NetDeviceContainer', 'd')], 
+                   is_static=True)
     ## wifi-helper.h: static void ns3::WifiHelper::EnablePcap(std::string filename, ns3::NodeContainer n) [member function]
-    cls.add_method('EnablePcap', 'void', [param('std::string', 'filename'), param('ns3::NodeContainer', 'n')], is_static=True)
+    cls.add_method('EnablePcap', 
+                   'void', 
+                   [param('std::string', 'filename'), param('ns3::NodeContainer', 'n')], 
+                   is_static=True)
     ## wifi-helper.h: static void ns3::WifiHelper::EnablePcapAll(std::string filename) [member function]
-    cls.add_method('EnablePcapAll', 'void', [param('std::string', 'filename')], is_static=True)
+    cls.add_method('EnablePcapAll', 
+                   'void', 
+                   [param('std::string', 'filename')], 
+                   is_static=True)
     ## wifi-helper.h: static void ns3::WifiHelper::EnableAscii(std::ostream & os, uint32_t nodeid, uint32_t deviceid) [member function]
-    cls.add_method('EnableAscii', 'void', [param('std::ostream&', 'os'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')], is_static=True)
+    cls.add_method('EnableAscii', 
+                   'void', 
+                   [param('std::ostream&', 'os'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')], 
+                   is_static=True)
     ## wifi-helper.h: static void ns3::WifiHelper::EnableAscii(std::ostream & os, ns3::NetDeviceContainer d) [member function]
-    cls.add_method('EnableAscii', 'void', [param('std::ostream&', 'os'), param('ns3::NetDeviceContainer', 'd')], is_static=True)
+    cls.add_method('EnableAscii', 
+                   'void', 
+                   [param('std::ostream&', 'os'), param('ns3::NetDeviceContainer', 'd')], 
+                   is_static=True)
     ## wifi-helper.h: static void ns3::WifiHelper::EnableAscii(std::ostream & os, ns3::NodeContainer n) [member function]
-    cls.add_method('EnableAscii', 'void', [param('std::ostream&', 'os'), param('ns3::NodeContainer', 'n')], is_static=True)
+    cls.add_method('EnableAscii', 
+                   'void', 
+                   [param('std::ostream&', 'os'), param('ns3::NodeContainer', 'n')], 
+                   is_static=True)
     ## wifi-helper.h: static void ns3::WifiHelper::EnableAsciiAll(std::ostream & os) [member function]
-    cls.add_method('EnableAsciiAll', 'void', [param('std::ostream&', 'os')], is_static=True)
+    cls.add_method('EnableAsciiAll', 
+                   'void', 
+                   [param('std::ostream&', 'os')], 
+                   is_static=True)
     ## wifi-helper.h: ns3::NetDeviceContainer ns3::WifiHelper::Install(ns3::NodeContainer c) const [member function]
-    cls.add_method('Install', 'ns3::NetDeviceContainer', [param('ns3::NodeContainer', 'c')], is_const=True)
+    cls.add_method('Install', 
+                   'ns3::NetDeviceContainer', 
+                   [param('ns3::NodeContainer', 'c')], 
+                   is_const=True)
     ## wifi-helper.h: ns3::NetDeviceContainer ns3::WifiHelper::Install(ns3::NodeContainer c, ns3::Ptr<ns3::WifiChannel> channel) const [member function]
-    cls.add_method('Install', 'ns3::NetDeviceContainer', [param('ns3::NodeContainer', 'c'), param('ns3::Ptr< ns3::WifiChannel >', 'channel')], is_const=True)
+    cls.add_method('Install', 
+                   'ns3::NetDeviceContainer', 
+                   [param('ns3::NodeContainer', 'c'), param('ns3::Ptr< ns3::WifiChannel >', 'channel')], 
+                   is_const=True)
     return
 
 def register_Ns3Ipv4AddressHelper_methods(root_module, cls):
     ## ipv4-address-helper.h: ns3::Ipv4AddressHelper::Ipv4AddressHelper() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## ipv4-address-helper.h: void ns3::Ipv4AddressHelper::SetBase(ns3::Ipv4Address network, ns3::Ipv4Mask mask, ns3::Ipv4Address base="0.0.0.1") [member function]
-    cls.add_method('SetBase', 'void', [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'mask'), param('ns3::Ipv4Address', 'base', default_value='"0.0.0.1"')])
+    cls.add_method('SetBase', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'mask'), param('ns3::Ipv4Address', 'base', default_value='"0.0.0.1"')])
     ## ipv4-address-helper.h: ns3::Ipv4Address ns3::Ipv4AddressHelper::NewNetwork() [member function]
-    cls.add_method('NewNetwork', 'ns3::Ipv4Address', [])
+    cls.add_method('NewNetwork', 
+                   'ns3::Ipv4Address', 
+                   [])
     ## ipv4-address-helper.h: ns3::Ipv4Address ns3::Ipv4AddressHelper::NewAddress() [member function]
-    cls.add_method('NewAddress', 'ns3::Ipv4Address', [])
+    cls.add_method('NewAddress', 
+                   'ns3::Ipv4Address', 
+                   [])
     ## ipv4-address-helper.h: ns3::Ipv4InterfaceContainer ns3::Ipv4AddressHelper::Assign(ns3::NetDeviceContainer const & c) [member function]
-    cls.add_method('Assign', 'ns3::Ipv4InterfaceContainer', [param('ns3::NetDeviceContainer&', 'c', is_const=True)])
+    cls.add_method('Assign', 
+                   'ns3::Ipv4InterfaceContainer', 
+                   [param('ns3::NetDeviceContainer&', 'c', is_const=True)])
     return
 
 def register_Ns3PacketSinkHelper_methods(root_module, cls):
     ## packet-sink-helper.h: ns3::PacketSinkHelper::PacketSinkHelper(std::string protocol, ns3::Address address) [constructor]
-    cls.add_constructor([param('std::string', 'protocol'), param('ns3::Address', 'address')], visibility='public')
+    cls.add_constructor([param('std::string', 'protocol'), param('ns3::Address', 'address')])
     ## packet-sink-helper.h: void ns3::PacketSinkHelper::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function]
-    cls.add_method('SetAttribute', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
+    cls.add_method('SetAttribute', 
+                   'void', 
+                   [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
     ## packet-sink-helper.h: ns3::ApplicationContainer ns3::PacketSinkHelper::Install(ns3::NodeContainer c) [member function]
-    cls.add_method('Install', 'ns3::ApplicationContainer', [param('ns3::NodeContainer', 'c')])
+    cls.add_method('Install', 
+                   'ns3::ApplicationContainer', 
+                   [param('ns3::NodeContainer', 'c')])
     return
 
 def register_Ns3Ns2MobilityHelper_methods(root_module, cls):
     ## ns2-mobility-helper.h: ns3::Ns2MobilityHelper::Ns2MobilityHelper(std::string filename) [constructor]
-    cls.add_constructor([param('std::string', 'filename')], visibility='public')
+    cls.add_constructor([param('std::string', 'filename')])
     ## ns2-mobility-helper.h: void ns3::Ns2MobilityHelper::Install() const [member function]
-    cls.add_method('Install', 'void', [], is_const=True)
+    cls.add_method('Install', 
+                   'void', 
+                   [], 
+                   is_const=True)
     return
 
 def register_functions(root_module):
--- a/bindings/python/ns3_module_internet_stack.py	Fri Jul 18 21:59:43 2008 -0700
+++ b/bindings/python/ns3_module_internet_stack.py	Mon Jul 21 15:53:03 2008 -0700
@@ -1,20 +1,20 @@
-from pybindgen import Module, FileCodeSink, write_preamble, param, retval
+from pybindgen import Module, FileCodeSink, param, retval, cppclass
 
 def register_types(module):
     root_module = module.get_root()
     
     ## ipv4-interface.h: ns3::Ipv4Interface [class]
-    module.add_class('Ipv4Interface', allow_subclassing=True, parent=root_module['ns3::Object'])
+    module.add_class('Ipv4Interface', parent=root_module['ns3::Object'])
     ## udp-header.h: ns3::UdpHeader [class]
-    module.add_class('UdpHeader', allow_subclassing=True, parent=root_module['ns3::Header'])
+    module.add_class('UdpHeader', parent=root_module['ns3::Header'])
     ## tcp-header.h: ns3::TcpHeader [class]
-    module.add_class('TcpHeader', allow_subclassing=True, parent=root_module['ns3::Header'])
+    module.add_class('TcpHeader', parent=root_module['ns3::Header'])
     ## tcp-header.h: ns3::TcpHeader::Flags_t [enumeration]
     module.add_enum('Flags_t', ['NONE', 'FIN', 'SYN', 'RST', 'PSH', 'ACK', 'URG'], outer_class=root_module['ns3::TcpHeader'])
     ## ipv4-static-routing.h: ns3::Ipv4StaticRouting [class]
-    module.add_class('Ipv4StaticRouting', allow_subclassing=True, parent=root_module['ns3::Ipv4RoutingProtocol'])
+    module.add_class('Ipv4StaticRouting', parent=root_module['ns3::Ipv4RoutingProtocol'])
     ## ipv4-l3-protocol.h: ns3::Ipv4L3Protocol [class]
-    module.add_class('Ipv4L3Protocol', allow_subclassing=True, parent=root_module['ns3::Object'])
+    module.add_class('Ipv4L3Protocol', parent=root_module['ns3::Object'])
     
     ## Register a nested module for the namespace internal
     
@@ -66,267 +66,557 @@
 
 def register_Ns3Ipv4Interface_methods(root_module, cls):
     ## ipv4-interface.h: static ns3::TypeId ns3::Ipv4Interface::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## ipv4-interface.h: ns3::Ipv4Interface::Ipv4Interface() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## ipv4-interface.h: ns3::Ptr<ns3::NetDevice> ns3::Ipv4Interface::GetDevice() const [member function]
-    cls.add_method('GetDevice', 'ns3::Ptr< ns3::NetDevice >', [], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('GetDevice', 
+                   'ns3::Ptr< ns3::NetDevice >', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     ## ipv4-interface.h: void ns3::Ipv4Interface::SetAddress(ns3::Ipv4Address a) [member function]
-    cls.add_method('SetAddress', 'void', [param('ns3::Ipv4Address', 'a')])
+    cls.add_method('SetAddress', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'a')])
     ## ipv4-interface.h: void ns3::Ipv4Interface::SetNetworkMask(ns3::Ipv4Mask mask) [member function]
-    cls.add_method('SetNetworkMask', 'void', [param('ns3::Ipv4Mask', 'mask')])
+    cls.add_method('SetNetworkMask', 
+                   'void', 
+                   [param('ns3::Ipv4Mask', 'mask')])
     ## ipv4-interface.h: ns3::Ipv4Address ns3::Ipv4Interface::GetBroadcast() const [member function]
-    cls.add_method('GetBroadcast', 'ns3::Ipv4Address', [], is_const=True)
+    cls.add_method('GetBroadcast', 
+                   'ns3::Ipv4Address', 
+                   [], 
+                   is_const=True)
     ## ipv4-interface.h: ns3::Ipv4Mask ns3::Ipv4Interface::GetNetworkMask() const [member function]
-    cls.add_method('GetNetworkMask', 'ns3::Ipv4Mask', [], is_const=True)
+    cls.add_method('GetNetworkMask', 
+                   'ns3::Ipv4Mask', 
+                   [], 
+                   is_const=True)
     ## ipv4-interface.h: void ns3::Ipv4Interface::SetMetric(uint16_t metric) [member function]
-    cls.add_method('SetMetric', 'void', [param('uint16_t', 'metric')])
+    cls.add_method('SetMetric', 
+                   'void', 
+                   [param('uint16_t', 'metric')])
     ## ipv4-interface.h: uint16_t ns3::Ipv4Interface::GetMetric() const [member function]
-    cls.add_method('GetMetric', 'uint16_t', [], is_const=True)
+    cls.add_method('GetMetric', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
     ## ipv4-interface.h: ns3::Ipv4Address ns3::Ipv4Interface::GetAddress() const [member function]
-    cls.add_method('GetAddress', 'ns3::Ipv4Address', [], is_const=True)
+    cls.add_method('GetAddress', 
+                   'ns3::Ipv4Address', 
+                   [], 
+                   is_const=True)
     ## ipv4-interface.h: uint16_t ns3::Ipv4Interface::GetMtu() const [member function]
-    cls.add_method('GetMtu', 'uint16_t', [], is_const=True)
+    cls.add_method('GetMtu', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
     ## ipv4-interface.h: bool ns3::Ipv4Interface::IsUp() const [member function]
-    cls.add_method('IsUp', 'bool', [], is_const=True)
+    cls.add_method('IsUp', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## ipv4-interface.h: bool ns3::Ipv4Interface::IsDown() const [member function]
-    cls.add_method('IsDown', 'bool', [], is_const=True)
+    cls.add_method('IsDown', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## ipv4-interface.h: void ns3::Ipv4Interface::SetUp() [member function]
-    cls.add_method('SetUp', 'void', [])
+    cls.add_method('SetUp', 
+                   'void', 
+                   [])
     ## ipv4-interface.h: void ns3::Ipv4Interface::SetDown() [member function]
-    cls.add_method('SetDown', 'void', [])
+    cls.add_method('SetDown', 
+                   'void', 
+                   [])
     ## ipv4-interface.h: void ns3::Ipv4Interface::Send(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Address dest) [member function]
-    cls.add_method('Send', 'void', [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Address', 'dest')])
+    cls.add_method('Send', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Address', 'dest')])
     ## ipv4-interface.h: void ns3::Ipv4Interface::DoDispose() [member function]
-    cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True)
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
     ## ipv4-interface.h: void ns3::Ipv4Interface::SendTo(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Address dest) [member function]
-    cls.add_method('SendTo', 'void', [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Address', 'dest')], is_pure_virtual=True, visibility='private', is_virtual=True)
+    cls.add_method('SendTo', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Address', 'dest')], 
+                   is_pure_virtual=True, visibility='private', is_virtual=True)
     return
 
 def register_Ns3UdpHeader_methods(root_module, cls):
     ## udp-header.h: ns3::UdpHeader::UdpHeader() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## udp-header.h: void ns3::UdpHeader::EnableChecksums() [member function]
-    cls.add_method('EnableChecksums', 'void', [])
+    cls.add_method('EnableChecksums', 
+                   'void', 
+                   [])
     ## udp-header.h: void ns3::UdpHeader::SetDestinationPort(uint16_t port) [member function]
-    cls.add_method('SetDestinationPort', 'void', [param('uint16_t', 'port')])
+    cls.add_method('SetDestinationPort', 
+                   'void', 
+                   [param('uint16_t', 'port')])
     ## udp-header.h: void ns3::UdpHeader::SetSourcePort(uint16_t port) [member function]
-    cls.add_method('SetSourcePort', 'void', [param('uint16_t', 'port')])
+    cls.add_method('SetSourcePort', 
+                   'void', 
+                   [param('uint16_t', 'port')])
     ## udp-header.h: uint16_t ns3::UdpHeader::GetSourcePort() const [member function]
-    cls.add_method('GetSourcePort', 'uint16_t', [], is_const=True)
+    cls.add_method('GetSourcePort', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
     ## udp-header.h: uint16_t ns3::UdpHeader::GetDestinationPort() const [member function]
-    cls.add_method('GetDestinationPort', 'uint16_t', [], is_const=True)
+    cls.add_method('GetDestinationPort', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
     ## udp-header.h: void ns3::UdpHeader::InitializeChecksum(ns3::Ipv4Address source, ns3::Ipv4Address destination, uint8_t protocol) [member function]
-    cls.add_method('InitializeChecksum', 'void', [param('ns3::Ipv4Address', 'source'), param('ns3::Ipv4Address', 'destination'), param('uint8_t', 'protocol')])
+    cls.add_method('InitializeChecksum', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'source'), param('ns3::Ipv4Address', 'destination'), param('uint8_t', 'protocol')])
     ## udp-header.h: static ns3::TypeId ns3::UdpHeader::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## udp-header.h: ns3::TypeId ns3::UdpHeader::GetInstanceTypeId() const [member function]
-    cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True)
+    cls.add_method('GetInstanceTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## udp-header.h: void ns3::UdpHeader::Print(std::ostream & os) const [member function]
-    cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True, is_virtual=True)
+    cls.add_method('Print', 
+                   'void', 
+                   [param('std::ostream&', 'os')], 
+                   is_const=True, is_virtual=True)
     ## udp-header.h: uint32_t ns3::UdpHeader::GetSerializedSize() const [member function]
-    cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True, is_virtual=True)
+    cls.add_method('GetSerializedSize', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## udp-header.h: void ns3::UdpHeader::Serialize(ns3::Buffer::Iterator start) const [member function]
-    cls.add_method('Serialize', 'void', [param('ns3::Buffer::Iterator', 'start')], is_const=True, is_virtual=True)
+    cls.add_method('Serialize', 
+                   'void', 
+                   [param('ns3::Buffer::Iterator', 'start')], 
+                   is_const=True, is_virtual=True)
     ## udp-header.h: uint32_t ns3::UdpHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
-    cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'start')], is_virtual=True)
+    cls.add_method('Deserialize', 
+                   'uint32_t', 
+                   [param('ns3::Buffer::Iterator', 'start')], 
+                   is_virtual=True)
     ## udp-header.h: bool ns3::UdpHeader::IsChecksumOk() const [member function]
-    cls.add_method('IsChecksumOk', 'bool', [], is_const=True)
+    cls.add_method('IsChecksumOk', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     return
 
 def register_Ns3TcpHeader_methods(root_module, cls):
     ## tcp-header.h: ns3::TcpHeader::TcpHeader() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## tcp-header.h: void ns3::TcpHeader::EnableChecksums() [member function]
-    cls.add_method('EnableChecksums', 'void', [])
+    cls.add_method('EnableChecksums', 
+                   'void', 
+                   [])
     ## tcp-header.h: void ns3::TcpHeader::SetSourcePort(uint16_t port) [member function]
-    cls.add_method('SetSourcePort', 'void', [param('uint16_t', 'port')])
+    cls.add_method('SetSourcePort', 
+                   'void', 
+                   [param('uint16_t', 'port')])
     ## tcp-header.h: void ns3::TcpHeader::SetDestinationPort(uint16_t port) [member function]
-    cls.add_method('SetDestinationPort', 'void', [param('uint16_t', 'port')])
+    cls.add_method('SetDestinationPort', 
+                   'void', 
+                   [param('uint16_t', 'port')])
     ## tcp-header.h: void ns3::TcpHeader::SetSequenceNumber(SequenceNumber sequenceNumber) [member function]
-    cls.add_method('SetSequenceNumber', 'void', [param('SequenceNumber', 'sequenceNumber')])
+    cls.add_method('SetSequenceNumber', 
+                   'void', 
+                   [param('SequenceNumber', 'sequenceNumber')])
     ## tcp-header.h: void ns3::TcpHeader::SetAckNumber(SequenceNumber ackNumber) [member function]
-    cls.add_method('SetAckNumber', 'void', [param('SequenceNumber', 'ackNumber')])
+    cls.add_method('SetAckNumber', 
+                   'void', 
+                   [param('SequenceNumber', 'ackNumber')])
     ## tcp-header.h: void ns3::TcpHeader::SetLength(uint8_t length) [member function]
-    cls.add_method('SetLength', 'void', [param('uint8_t', 'length')])
+    cls.add_method('SetLength', 
+                   'void', 
+                   [param('uint8_t', 'length')])
     ## tcp-header.h: void ns3::TcpHeader::SetFlags(uint8_t flags) [member function]
-    cls.add_method('SetFlags', 'void', [param('uint8_t', 'flags')])
+    cls.add_method('SetFlags', 
+                   'void', 
+                   [param('uint8_t', 'flags')])
     ## tcp-header.h: void ns3::TcpHeader::SetWindowSize(uint16_t windowSize) [member function]
-    cls.add_method('SetWindowSize', 'void', [param('uint16_t', 'windowSize')])
+    cls.add_method('SetWindowSize', 
+                   'void', 
+                   [param('uint16_t', 'windowSize')])
     ## tcp-header.h: void ns3::TcpHeader::SetUrgentPointer(uint16_t urgentPointer) [member function]
-    cls.add_method('SetUrgentPointer', 'void', [param('uint16_t', 'urgentPointer')])
+    cls.add_method('SetUrgentPointer', 
+                   'void', 
+                   [param('uint16_t', 'urgentPointer')])
     ## tcp-header.h: uint16_t ns3::TcpHeader::GetSourcePort() const [member function]
-    cls.add_method('GetSourcePort', 'uint16_t', [], is_const=True)
+    cls.add_method('GetSourcePort', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
     ## tcp-header.h: uint16_t ns3::TcpHeader::GetDestinationPort() const [member function]
-    cls.add_method('GetDestinationPort', 'uint16_t', [], is_const=True)
+    cls.add_method('GetDestinationPort', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
     ## tcp-header.h: SequenceNumber ns3::TcpHeader::GetSequenceNumber() const [member function]
-    cls.add_method('GetSequenceNumber', 'SequenceNumber', [], is_const=True)
+    cls.add_method('GetSequenceNumber', 
+                   'SequenceNumber', 
+                   [], 
+                   is_const=True)
     ## tcp-header.h: SequenceNumber ns3::TcpHeader::GetAckNumber() const [member function]
-    cls.add_method('GetAckNumber', 'SequenceNumber', [], is_const=True)
+    cls.add_method('GetAckNumber', 
+                   'SequenceNumber', 
+                   [], 
+                   is_const=True)
     ## tcp-header.h: uint8_t ns3::TcpHeader::GetLength() const [member function]
-    cls.add_method('GetLength', 'uint8_t', [], is_const=True)
+    cls.add_method('GetLength', 
+                   'uint8_t', 
+                   [], 
+                   is_const=True)
     ## tcp-header.h: uint8_t ns3::TcpHeader::GetFlags() const [member function]
-    cls.add_method('GetFlags', 'uint8_t', [], is_const=True)
+    cls.add_method('GetFlags', 
+                   'uint8_t', 
+                   [], 
+                   is_const=True)
     ## tcp-header.h: uint16_t ns3::TcpHeader::GetWindowSize() const [member function]
-    cls.add_method('GetWindowSize', 'uint16_t', [], is_const=True)
+    cls.add_method('GetWindowSize', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
     ## tcp-header.h: uint16_t ns3::TcpHeader::GetUrgentPointer() const [member function]
-    cls.add_method('GetUrgentPointer', 'uint16_t', [], is_const=True)
+    cls.add_method('GetUrgentPointer', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
     ## tcp-header.h: void ns3::TcpHeader::InitializeChecksum(ns3::Ipv4Address source, ns3::Ipv4Address destination, uint8_t protocol) [member function]
-    cls.add_method('InitializeChecksum', 'void', [param('ns3::Ipv4Address', 'source'), param('ns3::Ipv4Address', 'destination'), param('uint8_t', 'protocol')])
+    cls.add_method('InitializeChecksum', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'source'), param('ns3::Ipv4Address', 'destination'), param('uint8_t', 'protocol')])
     ## tcp-header.h: static ns3::TypeId ns3::TcpHeader::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## tcp-header.h: ns3::TypeId ns3::TcpHeader::GetInstanceTypeId() const [member function]
-    cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True)
+    cls.add_method('GetInstanceTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## tcp-header.h: void ns3::TcpHeader::Print(std::ostream & os) const [member function]
-    cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True, is_virtual=True)
+    cls.add_method('Print', 
+                   'void', 
+                   [param('std::ostream&', 'os')], 
+                   is_const=True, is_virtual=True)
     ## tcp-header.h: uint32_t ns3::TcpHeader::GetSerializedSize() const [member function]
-    cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True, is_virtual=True)
+    cls.add_method('GetSerializedSize', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## tcp-header.h: void ns3::TcpHeader::Serialize(ns3::Buffer::Iterator start) const [member function]
-    cls.add_method('Serialize', 'void', [param('ns3::Buffer::Iterator', 'start')], is_const=True, is_virtual=True)
+    cls.add_method('Serialize', 
+                   'void', 
+                   [param('ns3::Buffer::Iterator', 'start')], 
+                   is_const=True, is_virtual=True)
     ## tcp-header.h: uint32_t ns3::TcpHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
-    cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'start')], is_virtual=True)
+    cls.add_method('Deserialize', 
+                   'uint32_t', 
+                   [param('ns3::Buffer::Iterator', 'start')], 
+                   is_virtual=True)
     ## tcp-header.h: bool ns3::TcpHeader::IsChecksumOk() const [member function]
-    cls.add_method('IsChecksumOk', 'bool', [], is_const=True)
+    cls.add_method('IsChecksumOk', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     return
 
 def register_Ns3Ipv4StaticRouting_methods(root_module, cls):
     ## ipv4-static-routing.h: ns3::Ipv4StaticRouting::Ipv4StaticRouting() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## ipv4-static-routing.h: bool ns3::Ipv4StaticRouting::RequestRoute(uint32_t ifIndex, ns3::Ipv4Header const & ipHeader, ns3::Ptr<ns3::Packet> packet, ns3::Callback<void,bool,const ns3::Ipv4Route&,ns3::Ptr<ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty> routeReply) [member function]
-    cls.add_method('RequestRoute', 'bool', [param('uint32_t', 'ifIndex'), param('ns3::Ipv4Header&', 'ipHeader', is_const=True), param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Callback< void, bool, const ns3::Ipv4Route&, ns3::Ptr< ns3::Packet >, const ns3::Ipv4Header&, ns3::empty, ns3::empty >', 'routeReply')], is_virtual=True)
+    cls.add_method('RequestRoute', 
+                   'bool', 
+                   [param('uint32_t', 'ifIndex'), param('ns3::Ipv4Header&', 'ipHeader', is_const=True), param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Callback< void, bool, const ns3::Ipv4Route&, ns3::Ptr< ns3::Packet >, const ns3::Ipv4Header&, ns3::empty, ns3::empty >', 'routeReply')], 
+                   is_virtual=True)
     ## ipv4-static-routing.h: bool ns3::Ipv4StaticRouting::RequestIfIndex(ns3::Ipv4Address destination, uint32_t & ifIndex) [member function]
-    cls.add_method('RequestIfIndex', 'bool', [param('ns3::Ipv4Address', 'destination'), param('uint32_t&', 'ifIndex')], is_virtual=True)
+    cls.add_method('RequestIfIndex', 
+                   'bool', 
+                   [param('ns3::Ipv4Address', 'destination'), param('uint32_t&', 'ifIndex')], 
+                   is_virtual=True)
     ## ipv4-static-routing.h: void ns3::Ipv4StaticRouting::AddHostRouteTo(ns3::Ipv4Address dest, ns3::Ipv4Address nextHop, uint32_t interface) [member function]
-    cls.add_method('AddHostRouteTo', 'void', [param('ns3::Ipv4Address', 'dest'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')])
+    cls.add_method('AddHostRouteTo', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'dest'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')])
     ## ipv4-static-routing.h: void ns3::Ipv4StaticRouting::AddHostRouteTo(ns3::Ipv4Address dest, uint32_t interface) [member function]
-    cls.add_method('AddHostRouteTo', 'void', [param('ns3::Ipv4Address', 'dest'), param('uint32_t', 'interface')])
+    cls.add_method('AddHostRouteTo', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'dest'), param('uint32_t', 'interface')])
     ## ipv4-static-routing.h: void ns3::Ipv4StaticRouting::AddNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, ns3::Ipv4Address nextHop, uint32_t interface) [member function]
-    cls.add_method('AddNetworkRouteTo', 'void', [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')])
+    cls.add_method('AddNetworkRouteTo', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')])
     ## ipv4-static-routing.h: void ns3::Ipv4StaticRouting::AddNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, uint32_t interface) [member function]
-    cls.add_method('AddNetworkRouteTo', 'void', [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('uint32_t', 'interface')])
+    cls.add_method('AddNetworkRouteTo', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('uint32_t', 'interface')])
     ## ipv4-static-routing.h: void ns3::Ipv4StaticRouting::SetDefaultRoute(ns3::Ipv4Address nextHop, uint32_t interface) [member function]
-    cls.add_method('SetDefaultRoute', 'void', [param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')])
+    cls.add_method('SetDefaultRoute', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')])
     ## ipv4-static-routing.h: uint32_t ns3::Ipv4StaticRouting::GetNRoutes() [member function]
-    cls.add_method('GetNRoutes', 'uint32_t', [])
+    cls.add_method('GetNRoutes', 
+                   'uint32_t', 
+                   [])
     ## ipv4-static-routing.h: ns3::Ipv4Route * ns3::Ipv4StaticRouting::GetDefaultRoute() [member function]
-    cls.add_method('GetDefaultRoute', 'ns3::Ipv4Route *', [])
+    cls.add_method('GetDefaultRoute', 
+                   'ns3::Ipv4Route *', 
+                   [])
     ## ipv4-static-routing.h: ns3::Ipv4Route * ns3::Ipv4StaticRouting::GetRoute(uint32_t i) [member function]
-    cls.add_method('GetRoute', 'ns3::Ipv4Route *', [param('uint32_t', 'i')])
+    cls.add_method('GetRoute', 
+                   'ns3::Ipv4Route *', 
+                   [param('uint32_t', 'i')])
     ## ipv4-static-routing.h: void ns3::Ipv4StaticRouting::RemoveRoute(uint32_t i) [member function]
-    cls.add_method('RemoveRoute', 'void', [param('uint32_t', 'i')])
+    cls.add_method('RemoveRoute', 
+                   'void', 
+                   [param('uint32_t', 'i')])
     ## ipv4-static-routing.h: void ns3::Ipv4StaticRouting::AddMulticastRoute(ns3::Ipv4Address origin, ns3::Ipv4Address group, uint32_t inputInterface, std::vector<unsigned int, std::allocator<unsigned int> > outputInterfaces) [member function]
-    cls.add_method('AddMulticastRoute', 'void', [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int, std::allocator< unsigned int > >', 'outputInterfaces')])
+    cls.add_method('AddMulticastRoute', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int, std::allocator< unsigned int > >', 'outputInterfaces')])
     ## ipv4-static-routing.h: void ns3::Ipv4StaticRouting::SetDefaultMulticastRoute(uint32_t outputInterface) [member function]
-    cls.add_method('SetDefaultMulticastRoute', 'void', [param('uint32_t', 'outputInterface')])
+    cls.add_method('SetDefaultMulticastRoute', 
+                   'void', 
+                   [param('uint32_t', 'outputInterface')])
     ## ipv4-static-routing.h: uint32_t ns3::Ipv4StaticRouting::GetNMulticastRoutes() const [member function]
-    cls.add_method('GetNMulticastRoutes', 'uint32_t', [], is_const=True)
+    cls.add_method('GetNMulticastRoutes', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## ipv4-static-routing.h: ns3::Ipv4MulticastRoute * ns3::Ipv4StaticRouting::GetMulticastRoute(uint32_t i) const [member function]
-    cls.add_method('GetMulticastRoute', 'ns3::Ipv4MulticastRoute *', [param('uint32_t', 'i')], is_const=True)
+    cls.add_method('GetMulticastRoute', 
+                   'ns3::Ipv4MulticastRoute *', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
     ## ipv4-static-routing.h: ns3::Ipv4MulticastRoute * ns3::Ipv4StaticRouting::GetDefaultMulticastRoute() const [member function]
-    cls.add_method('GetDefaultMulticastRoute', 'ns3::Ipv4MulticastRoute *', [], is_const=True)
+    cls.add_method('GetDefaultMulticastRoute', 
+                   'ns3::Ipv4MulticastRoute *', 
+                   [], 
+                   is_const=True)
     ## ipv4-static-routing.h: bool ns3::Ipv4StaticRouting::RemoveMulticastRoute(ns3::Ipv4Address origin, ns3::Ipv4Address group, uint32_t inputInterface) [member function]
-    cls.add_method('RemoveMulticastRoute', 'bool', [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface')])
+    cls.add_method('RemoveMulticastRoute', 
+                   'bool', 
+                   [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface')])
     ## ipv4-static-routing.h: void ns3::Ipv4StaticRouting::RemoveMulticastRoute(uint32_t index) [member function]
-    cls.add_method('RemoveMulticastRoute', 'void', [param('uint32_t', 'index')])
+    cls.add_method('RemoveMulticastRoute', 
+                   'void', 
+                   [param('uint32_t', 'index')])
     ## ipv4-static-routing.h: void ns3::Ipv4StaticRouting::DoDispose() [member function]
-    cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True)
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
     return
 
 def register_Ns3Ipv4L3Protocol_methods(root_module, cls):
     ## ipv4-l3-protocol.h: ns3::Ipv4L3Protocol::PROT_NUMBER [variable]
     cls.add_static_attribute('PROT_NUMBER', retval('uint16_t', is_const=True), is_const=True)
     ## ipv4-l3-protocol.h: static ns3::TypeId ns3::Ipv4L3Protocol::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## ipv4-l3-protocol.h: ns3::Ipv4L3Protocol::Ipv4L3Protocol() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::SetNode(ns3::Ptr<ns3::Node> node) [member function]
-    cls.add_method('SetNode', 'void', [param('ns3::Ptr< ns3::Node >', 'node')])
+    cls.add_method('SetNode', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Node >', 'node')])
     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::SetDefaultTtl(uint8_t ttl) [member function]
-    cls.add_method('SetDefaultTtl', 'void', [param('uint8_t', 'ttl')])
+    cls.add_method('SetDefaultTtl', 
+                   'void', 
+                   [param('uint8_t', 'ttl')])
     ## ipv4-l3-protocol.h: ns3::Ptr<ns3::Ipv4Interface> ns3::Ipv4L3Protocol::FindInterfaceForDevice(ns3::Ptr<const ns3::NetDevice> device) [member function]
-    cls.add_method('FindInterfaceForDevice', 'ns3::Ptr< ns3::Ipv4Interface >', [param('ns3::Ptr< const ns3::NetDevice >', 'device')])
-    ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::Receive(ns3::Ptr<ns3::NetDevice> device, ns3::Ptr<ns3::Packet> p, uint16_t protocol, ns3::Address const & from) [member function]
-    cls.add_method('Receive', 'void', [param('ns3::Ptr< ns3::NetDevice >', 'device'), param('ns3::Ptr< ns3::Packet >', 'p'), param('uint16_t', 'protocol'), param('ns3::Address&', 'from', is_const=True)])
+    cls.add_method('FindInterfaceForDevice', 
+                   'ns3::Ptr< ns3::Ipv4Interface >', 
+                   [param('ns3::Ptr< const ns3::NetDevice >', 'device')])
+    ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::Receive(ns3::Ptr<ns3::NetDevice> device, ns3::Ptr<ns3::Packet> p, uint16_t protocol, ns3::Address const & from, ns3::Address const & to, ns3::NetDevice::PacketType packetType) [member function]
+    cls.add_method('Receive', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::NetDevice >', 'device'), param('ns3::Ptr< ns3::Packet >', 'p'), param('uint16_t', 'protocol'), param('ns3::Address&', 'from', is_const=True), param('ns3::Address&', 'to', is_const=True), param('ns3::NetDevice::PacketType', 'packetType')])
     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::Send(ns3::Ptr<ns3::Packet> packet, ns3::Ipv4Address source, ns3::Ipv4Address destination, uint8_t protocol) [member function]
-    cls.add_method('Send', 'void', [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Ipv4Address', 'source'), param('ns3::Ipv4Address', 'destination'), param('uint8_t', 'protocol')])
+    cls.add_method('Send', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Ipv4Address', 'source'), param('ns3::Ipv4Address', 'destination'), param('uint8_t', 'protocol')])
     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::AddHostRouteTo(ns3::Ipv4Address dest, ns3::Ipv4Address nextHop, uint32_t interface) [member function]
-    cls.add_method('AddHostRouteTo', 'void', [param('ns3::Ipv4Address', 'dest'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')])
+    cls.add_method('AddHostRouteTo', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'dest'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')])
     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::AddHostRouteTo(ns3::Ipv4Address dest, uint32_t interface) [member function]
-    cls.add_method('AddHostRouteTo', 'void', [param('ns3::Ipv4Address', 'dest'), param('uint32_t', 'interface')])
+    cls.add_method('AddHostRouteTo', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'dest'), param('uint32_t', 'interface')])
     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::AddNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, ns3::Ipv4Address nextHop, uint32_t interface) [member function]
-    cls.add_method('AddNetworkRouteTo', 'void', [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')])
+    cls.add_method('AddNetworkRouteTo', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')])
     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::AddNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, uint32_t interface) [member function]
-    cls.add_method('AddNetworkRouteTo', 'void', [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('uint32_t', 'interface')])
+    cls.add_method('AddNetworkRouteTo', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('uint32_t', 'interface')])
     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::SetDefaultRoute(ns3::Ipv4Address nextHop, uint32_t interface) [member function]
-    cls.add_method('SetDefaultRoute', 'void', [param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')])
+    cls.add_method('SetDefaultRoute', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')])
     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::Lookup(ns3::Ipv4Header const & ipHeader, ns3::Ptr<ns3::Packet> packet, ns3::Callback<void,bool,const ns3::Ipv4Route&,ns3::Ptr<ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty> routeReply) [member function]
-    cls.add_method('Lookup', 'void', [param('ns3::Ipv4Header&', 'ipHeader', is_const=True), param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Callback< void, bool, const ns3::Ipv4Route&, ns3::Ptr< ns3::Packet >, const ns3::Ipv4Header&, ns3::empty, ns3::empty >', 'routeReply')])
+    cls.add_method('Lookup', 
+                   'void', 
+                   [param('ns3::Ipv4Header&', 'ipHeader', is_const=True), param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Callback< void, bool, const ns3::Ipv4Route&, ns3::Ptr< ns3::Packet >, const ns3::Ipv4Header&, ns3::empty, ns3::empty >', 'routeReply')])
     ## ipv4-l3-protocol.h: uint32_t ns3::Ipv4L3Protocol::GetNRoutes() [member function]
-    cls.add_method('GetNRoutes', 'uint32_t', [])
+    cls.add_method('GetNRoutes', 
+                   'uint32_t', 
+                   [])
     ## ipv4-l3-protocol.h: ns3::Ipv4Route * ns3::Ipv4L3Protocol::GetRoute(uint32_t i) [member function]
-    cls.add_method('GetRoute', 'ns3::Ipv4Route *', [param('uint32_t', 'i')])
+    cls.add_method('GetRoute', 
+                   'ns3::Ipv4Route *', 
+                   [param('uint32_t', 'i')])
     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::RemoveRoute(uint32_t i) [member function]
-    cls.add_method('RemoveRoute', 'void', [param('uint32_t', 'i')])
+    cls.add_method('RemoveRoute', 
+                   'void', 
+                   [param('uint32_t', 'i')])
     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::AddMulticastRoute(ns3::Ipv4Address origin, ns3::Ipv4Address group, uint32_t inputInterface, std::vector<unsigned int, std::allocator<unsigned int> > outputInterfaces) [member function]
-    cls.add_method('AddMulticastRoute', 'void', [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int, std::allocator< unsigned int > >', 'outputInterfaces')])
+    cls.add_method('AddMulticastRoute', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int, std::allocator< unsigned int > >', 'outputInterfaces')])
     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::SetDefaultMulticastRoute(uint32_t onputInterface) [member function]
-    cls.add_method('SetDefaultMulticastRoute', 'void', [param('uint32_t', 'onputInterface')])
+    cls.add_method('SetDefaultMulticastRoute', 
+                   'void', 
+                   [param('uint32_t', 'onputInterface')])
     ## ipv4-l3-protocol.h: uint32_t ns3::Ipv4L3Protocol::GetNMulticastRoutes() const [member function]
-    cls.add_method('GetNMulticastRoutes', 'uint32_t', [], is_const=True)
+    cls.add_method('GetNMulticastRoutes', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## ipv4-l3-protocol.h: ns3::Ipv4MulticastRoute * ns3::Ipv4L3Protocol::GetMulticastRoute(uint32_t i) const [member function]
-    cls.add_method('GetMulticastRoute', 'ns3::Ipv4MulticastRoute *', [param('uint32_t', 'i')], is_const=True)
+    cls.add_method('GetMulticastRoute', 
+                   'ns3::Ipv4MulticastRoute *', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::RemoveMulticastRoute(ns3::Ipv4Address origin, ns3::Ipv4Address group, uint32_t inputInterface) [member function]
-    cls.add_method('RemoveMulticastRoute', 'void', [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface')])
+    cls.add_method('RemoveMulticastRoute', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface')])
     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::RemoveMulticastRoute(uint32_t i) [member function]
-    cls.add_method('RemoveMulticastRoute', 'void', [param('uint32_t', 'i')])
+    cls.add_method('RemoveMulticastRoute', 
+                   'void', 
+                   [param('uint32_t', 'i')])
     ## ipv4-l3-protocol.h: uint32_t ns3::Ipv4L3Protocol::AddInterface(ns3::Ptr<ns3::NetDevice> device) [member function]
-    cls.add_method('AddInterface', 'uint32_t', [param('ns3::Ptr< ns3::NetDevice >', 'device')])
+    cls.add_method('AddInterface', 
+                   'uint32_t', 
+                   [param('ns3::Ptr< ns3::NetDevice >', 'device')])
     ## ipv4-l3-protocol.h: ns3::Ptr<ns3::Ipv4Interface> ns3::Ipv4L3Protocol::GetInterface(uint32_t i) const [member function]
-    cls.add_method('GetInterface', 'ns3::Ptr< ns3::Ipv4Interface >', [param('uint32_t', 'i')], is_const=True)
+    cls.add_method('GetInterface', 
+                   'ns3::Ptr< ns3::Ipv4Interface >', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
     ## ipv4-l3-protocol.h: uint32_t ns3::Ipv4L3Protocol::GetNInterfaces() const [member function]
-    cls.add_method('GetNInterfaces', 'uint32_t', [], is_const=True)
+    cls.add_method('GetNInterfaces', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## ipv4-l3-protocol.h: uint32_t ns3::Ipv4L3Protocol::FindInterfaceForAddr(ns3::Ipv4Address addr) const [member function]
-    cls.add_method('FindInterfaceForAddr', 'uint32_t', [param('ns3::Ipv4Address', 'addr')], is_const=True)
+    cls.add_method('FindInterfaceForAddr', 
+                   'uint32_t', 
+                   [param('ns3::Ipv4Address', 'addr')], 
+                   is_const=True)
     ## ipv4-l3-protocol.h: uint32_t ns3::Ipv4L3Protocol::FindInterfaceForAddr(ns3::Ipv4Address addr, ns3::Ipv4Mask mask) const [member function]
-    cls.add_method('FindInterfaceForAddr', 'uint32_t', [param('ns3::Ipv4Address', 'addr'), param('ns3::Ipv4Mask', 'mask')], is_const=True)
+    cls.add_method('FindInterfaceForAddr', 
+                   'uint32_t', 
+                   [param('ns3::Ipv4Address', 'addr'), param('ns3::Ipv4Mask', 'mask')], 
+                   is_const=True)
     ## ipv4-l3-protocol.h: int32_t ns3::Ipv4L3Protocol::FindInterfaceIndexForDevice(ns3::Ptr<ns3::NetDevice> device) const [member function]
-    cls.add_method('FindInterfaceIndexForDevice', 'int32_t', [param('ns3::Ptr< ns3::NetDevice >', 'device')], is_const=True)
+    cls.add_method('FindInterfaceIndexForDevice', 
+                   'int32_t', 
+                   [param('ns3::Ptr< ns3::NetDevice >', 'device')], 
+                   is_const=True)
     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::JoinMulticastGroup(ns3::Ipv4Address origin, ns3::Ipv4Address group) [member function]
-    cls.add_method('JoinMulticastGroup', 'void', [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group')])
+    cls.add_method('JoinMulticastGroup', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group')])
     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::LeaveMulticastGroup(ns3::Ipv4Address origin, ns3::Ipv4Address group) [member function]
-    cls.add_method('LeaveMulticastGroup', 'void', [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group')])
+    cls.add_method('LeaveMulticastGroup', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group')])
     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::SetAddress(uint32_t i, ns3::Ipv4Address address) [member function]
-    cls.add_method('SetAddress', 'void', [param('uint32_t', 'i'), param('ns3::Ipv4Address', 'address')])
+    cls.add_method('SetAddress', 
+                   'void', 
+                   [param('uint32_t', 'i'), param('ns3::Ipv4Address', 'address')])
     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::SetNetworkMask(uint32_t i, ns3::Ipv4Mask mask) [member function]
-    cls.add_method('SetNetworkMask', 'void', [param('uint32_t', 'i'), param('ns3::Ipv4Mask', 'mask')])
+    cls.add_method('SetNetworkMask', 
+                   'void', 
+                   [param('uint32_t', 'i'), param('ns3::Ipv4Mask', 'mask')])
     ## ipv4-l3-protocol.h: ns3::Ipv4Mask ns3::Ipv4L3Protocol::GetNetworkMask(uint32_t t) const [member function]
-    cls.add_method('GetNetworkMask', 'ns3::Ipv4Mask', [param('uint32_t', 't')], is_const=True)
+    cls.add_method('GetNetworkMask', 
+                   'ns3::Ipv4Mask', 
+                   [param('uint32_t', 't')], 
+                   is_const=True)
     ## ipv4-l3-protocol.h: ns3::Ipv4Address ns3::Ipv4L3Protocol::GetAddress(uint32_t i) const [member function]
-    cls.add_method('GetAddress', 'ns3::Ipv4Address', [param('uint32_t', 'i')], is_const=True)
+    cls.add_method('GetAddress', 
+                   'ns3::Ipv4Address', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::SetMetric(uint32_t i, uint16_t metric) [member function]
-    cls.add_method('SetMetric', 'void', [param('uint32_t', 'i'), param('uint16_t', 'metric')])
+    cls.add_method('SetMetric', 
+                   'void', 
+                   [param('uint32_t', 'i'), param('uint16_t', 'metric')])
     ## ipv4-l3-protocol.h: uint16_t ns3::Ipv4L3Protocol::GetMetric(uint32_t i) const [member function]
-    cls.add_method('GetMetric', 'uint16_t', [param('uint32_t', 'i')], is_const=True)
+    cls.add_method('GetMetric', 
+                   'uint16_t', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
     ## ipv4-l3-protocol.h: bool ns3::Ipv4L3Protocol::GetIfIndexForDestination(ns3::Ipv4Address destination, uint32_t & ifIndex) const [member function]
-    cls.add_method('GetIfIndexForDestination', 'bool', [param('ns3::Ipv4Address', 'destination'), param('uint32_t&', 'ifIndex')], is_const=True)
+    cls.add_method('GetIfIndexForDestination', 
+                   'bool', 
+                   [param('ns3::Ipv4Address', 'destination'), param('uint32_t&', 'ifIndex')], 
+                   is_const=True)
     ## ipv4-l3-protocol.h: uint16_t ns3::Ipv4L3Protocol::GetMtu(uint32_t i) const [member function]
-    cls.add_method('GetMtu', 'uint16_t', [param('uint32_t', 'i')], is_const=True)
+    cls.add_method('GetMtu', 
+                   'uint16_t', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
     ## ipv4-l3-protocol.h: bool ns3::Ipv4L3Protocol::IsUp(uint32_t i) const [member function]
-    cls.add_method('IsUp', 'bool', [param('uint32_t', 'i')], is_const=True)
+    cls.add_method('IsUp', 
+                   'bool', 
+                   [param('uint32_t', 'i')], 
+                   is_const=True)
     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::SetUp(uint32_t i) [member function]
-    cls.add_method('SetUp', 'void', [param('uint32_t', 'i')])
+    cls.add_method('SetUp', 
+                   'void', 
+                   [param('uint32_t', 'i')])
     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::SetDown(uint32_t i) [member function]
-    cls.add_method('SetDown', 'void', [param('uint32_t', 'i')])
+    cls.add_method('SetDown', 
+                   'void', 
+                   [param('uint32_t', 'i')])
     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::AddRoutingProtocol(ns3::Ptr<ns3::Ipv4RoutingProtocol> routingProtocol, int priority) [member function]
-    cls.add_method('AddRoutingProtocol', 'void', [param('ns3::Ptr< ns3::Ipv4RoutingProtocol >', 'routingProtocol'), param('int', 'priority')])
+    cls.add_method('AddRoutingProtocol', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Ipv4RoutingProtocol >', 'routingProtocol'), param('int', 'priority')])
     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::DoDispose() [member function]
-    cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True)
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
     return
 
 def register_functions(root_module):
     module = root_module
     ## internet-stack.h: extern void ns3::AddInternetStack(ns3::Ptr<ns3::Node> node) [free function]
-    module.add_function('AddInternetStack', 'void', [param('ns3::Ptr< ns3::Node >', 'node')])
+    module.add_function('AddInternetStack', 
+                        'void', 
+                        [param('ns3::Ptr< ns3::Node >', 'node')])
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
--- a/bindings/python/ns3_module_mobility.py	Fri Jul 18 21:59:43 2008 -0700
+++ b/bindings/python/ns3_module_mobility.py	Mon Jul 21 15:53:03 2008 -0700
@@ -1,4 +1,4 @@
-from pybindgen import Module, FileCodeSink, write_preamble, param, retval
+from pybindgen import Module, FileCodeSink, param, retval, cppclass
 
 def register_types(module):
     root_module = module.get_root()
@@ -16,37 +16,37 @@
     ## rectangle.h: ns3::Rectangle::Side [enumeration]
     module.add_enum('Side', ['RIGHT', 'LEFT', 'TOP', 'BOTTOM'], outer_class=root_module['ns3::Rectangle'])
     ## position-allocator.h: ns3::PositionAllocator [class]
-    module.add_class('PositionAllocator', allow_subclassing=True, parent=root_module['ns3::Object'])
+    module.add_class('PositionAllocator', parent=root_module['ns3::Object'])
     ## position-allocator.h: ns3::ListPositionAllocator [class]
-    module.add_class('ListPositionAllocator', allow_subclassing=True, parent=root_module['ns3::PositionAllocator'])
+    module.add_class('ListPositionAllocator', parent=root_module['ns3::PositionAllocator'])
     ## rectangle.h: ns3::RectangleValue [class]
-    module.add_class('RectangleValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue'])
+    module.add_class('RectangleValue', parent=root_module['ns3::AttributeValue'])
     ## position-allocator.h: ns3::RandomRectanglePositionAllocator [class]
-    module.add_class('RandomRectanglePositionAllocator', allow_subclassing=True, parent=root_module['ns3::PositionAllocator'])
+    module.add_class('RandomRectanglePositionAllocator', parent=root_module['ns3::PositionAllocator'])
     ## vector.h: ns3::VectorValue [class]
-    module.add_class('VectorValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue'])
+    module.add_class('VectorValue', parent=root_module['ns3::AttributeValue'])
     ## position-allocator.h: ns3::RandomDiscPositionAllocator [class]
-    module.add_class('RandomDiscPositionAllocator', allow_subclassing=True, parent=root_module['ns3::PositionAllocator'])
+    module.add_class('RandomDiscPositionAllocator', parent=root_module['ns3::PositionAllocator'])
     ## mobility-model.h: ns3::MobilityModel [class]
-    module.add_class('MobilityModel', allow_subclassing=True, parent=root_module['ns3::Object'])
+    module.add_class('MobilityModel', parent=root_module['ns3::Object'])
     ## random-direction-2d-mobility-model.h: ns3::RandomDirection2dMobilityModel [class]
-    module.add_class('RandomDirection2dMobilityModel', allow_subclassing=True, parent=root_module['ns3::MobilityModel'])
+    module.add_class('RandomDirection2dMobilityModel', parent=root_module['ns3::MobilityModel'])
     ## position-allocator.h: ns3::GridPositionAllocator [class]
-    module.add_class('GridPositionAllocator', allow_subclassing=True, parent=root_module['ns3::PositionAllocator'])
+    module.add_class('GridPositionAllocator', parent=root_module['ns3::PositionAllocator'])
     ## position-allocator.h: ns3::GridPositionAllocator::LayoutType [enumeration]
     module.add_enum('LayoutType', ['ROW_FIRST', 'COLUMN_FIRST'], outer_class=root_module['ns3::GridPositionAllocator'])
     ## random-waypoint-mobility-model.h: ns3::RandomWaypointMobilityModel [class]
-    module.add_class('RandomWaypointMobilityModel', allow_subclassing=True, parent=root_module['ns3::MobilityModel'])
+    module.add_class('RandomWaypointMobilityModel', parent=root_module['ns3::MobilityModel'])
     ## random-walk-2d-mobility-model.h: ns3::RandomWalk2dMobilityModel [class]
-    module.add_class('RandomWalk2dMobilityModel', allow_subclassing=True, parent=root_module['ns3::MobilityModel'])
+    module.add_class('RandomWalk2dMobilityModel', parent=root_module['ns3::MobilityModel'])
     ## random-walk-2d-mobility-model.h: ns3::RandomWalk2dMobilityModel::Mode [enumeration]
     module.add_enum('Mode', ['MODE_DISTANCE', 'MODE_TIME'], outer_class=root_module['ns3::RandomWalk2dMobilityModel'])
     ## static-speed-mobility-model.h: ns3::StaticSpeedMobilityModel [class]
-    module.add_class('StaticSpeedMobilityModel', allow_subclassing=True, parent=root_module['ns3::MobilityModel'])
+    module.add_class('StaticSpeedMobilityModel', parent=root_module['ns3::MobilityModel'])
     ## hierarchical-mobility-model.h: ns3::HierarchicalMobilityModel [class]
-    module.add_class('HierarchicalMobilityModel', allow_subclassing=True, parent=root_module['ns3::MobilityModel'])
+    module.add_class('HierarchicalMobilityModel', parent=root_module['ns3::MobilityModel'])
     ## static-mobility-model.h: ns3::StaticMobilityModel [class]
-    module.add_class('StaticMobilityModel', allow_subclassing=True, parent=root_module['ns3::MobilityModel'])
+    module.add_class('StaticMobilityModel', parent=root_module['ns3::MobilityModel'])
     
     ## Register a nested module for the namespace internal
     
@@ -112,36 +112,55 @@
 
 def register_Ns3StaticSpeedHelper_methods(root_module, cls):
     ## static-speed-helper.h: ns3::StaticSpeedHelper::StaticSpeedHelper() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## static-speed-helper.h: ns3::StaticSpeedHelper::StaticSpeedHelper(ns3::Vector const & position) [constructor]
-    cls.add_constructor([param('ns3::Vector&', 'position', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::Vector&', 'position', is_const=True)])
     ## static-speed-helper.h: ns3::StaticSpeedHelper::StaticSpeedHelper(ns3::Vector const & position, ns3::Vector const & speed) [constructor]
-    cls.add_constructor([param('ns3::Vector&', 'position', is_const=True), param('ns3::Vector&', 'speed', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::Vector&', 'position', is_const=True), param('ns3::Vector&', 'speed', is_const=True)])
     ## static-speed-helper.h: void ns3::StaticSpeedHelper::InitializePosition(ns3::Vector const & position) [member function]
-    cls.add_method('InitializePosition', 'void', [param('ns3::Vector&', 'position', is_const=True)])
+    cls.add_method('InitializePosition', 
+                   'void', 
+                   [param('ns3::Vector&', 'position', is_const=True)])
     ## static-speed-helper.h: void ns3::StaticSpeedHelper::Reset(ns3::Vector const & speed) [member function]
-    cls.add_method('Reset', 'void', [param('ns3::Vector&', 'speed', is_const=True)])
+    cls.add_method('Reset', 
+                   'void', 
+                   [param('ns3::Vector&', 'speed', is_const=True)])
     ## static-speed-helper.h: ns3::Vector ns3::StaticSpeedHelper::GetCurrentPosition(ns3::Rectangle const & bounds) const [member function]
-    cls.add_method('GetCurrentPosition', 'ns3::Vector', [param('ns3::Rectangle&', 'bounds', is_const=True)], is_const=True)
+    cls.add_method('GetCurrentPosition', 
+                   'ns3::Vector', 
+                   [param('ns3::Rectangle&', 'bounds', is_const=True)], 
+                   is_const=True)
     ## static-speed-helper.h: ns3::Vector ns3::StaticSpeedHelper::GetCurrentPosition() const [member function]
-    cls.add_method('GetCurrentPosition', 'ns3::Vector', [], is_const=True)
+    cls.add_method('GetCurrentPosition', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True)
     ## static-speed-helper.h: ns3::Vector ns3::StaticSpeedHelper::GetVelocity() const [member function]
-    cls.add_method('GetVelocity', 'ns3::Vector', [], is_const=True)
+    cls.add_method('GetVelocity', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True)
     ## static-speed-helper.h: void ns3::StaticSpeedHelper::SetSpeed(ns3::Vector const & speed) [member function]
-    cls.add_method('SetSpeed', 'void', [param('ns3::Vector&', 'speed', is_const=True)])
+    cls.add_method('SetSpeed', 
+                   'void', 
+                   [param('ns3::Vector&', 'speed', is_const=True)])
     ## static-speed-helper.h: void ns3::StaticSpeedHelper::Pause() [member function]
-    cls.add_method('Pause', 'void', [])
+    cls.add_method('Pause', 
+                   'void', 
+                   [])
     ## static-speed-helper.h: void ns3::StaticSpeedHelper::Unpause() [member function]
-    cls.add_method('Unpause', 'void', [])
+    cls.add_method('Unpause', 
+                   'void', 
+                   [])
     return
 
 def register_Ns3Vector_methods(root_module, cls):
     ## vector.h: ns3::Vector::Vector(ns3::Vector const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Vector&', 'arg0', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::Vector&', 'arg0', is_const=True)])
     ## vector.h: ns3::Vector::Vector(double _x, double _y, double _z) [constructor]
-    cls.add_constructor([param('double', '_x'), param('double', '_y'), param('double', '_z')], visibility='public')
+    cls.add_constructor([param('double', '_x'), param('double', '_y'), param('double', '_z')])
     ## vector.h: ns3::Vector::Vector() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## vector.h: ns3::Vector::x [variable]
     cls.add_instance_attribute('x', 'double', is_const=False)
     ## vector.h: ns3::Vector::y [variable]
@@ -161,17 +180,26 @@
 
 def register_Ns3Rectangle_methods(root_module, cls):
     ## rectangle.h: ns3::Rectangle::Rectangle(ns3::Rectangle const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Rectangle&', 'arg0', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::Rectangle&', 'arg0', is_const=True)])
     ## rectangle.h: ns3::Rectangle::Rectangle(double _xMin, double _xMax, double _yMin, double _yMax) [constructor]
-    cls.add_constructor([param('double', '_xMin'), param('double', '_xMax'), param('double', '_yMin'), param('double', '_yMax')], visibility='public')
+    cls.add_constructor([param('double', '_xMin'), param('double', '_xMax'), param('double', '_yMin'), param('double', '_yMax')])
     ## rectangle.h: ns3::Rectangle::Rectangle() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## rectangle.h: ns3::Vector ns3::Rectangle::CalculateIntersection(ns3::Vector const & current, ns3::Vector const & speed) const [member function]
-    cls.add_method('CalculateIntersection', 'ns3::Vector', [param('ns3::Vector&', 'current', is_const=True), param('ns3::Vector&', 'speed', is_const=True)], is_const=True)
+    cls.add_method('CalculateIntersection', 
+                   'ns3::Vector', 
+                   [param('ns3::Vector&', 'current', is_const=True), param('ns3::Vector&', 'speed', is_const=True)], 
+                   is_const=True)
     ## rectangle.h: ns3::Rectangle::Side ns3::Rectangle::GetClosestSide(ns3::Vector const & position) const [member function]
-    cls.add_method('GetClosestSide', 'ns3::Rectangle::Side', [param('ns3::Vector&', 'position', is_const=True)], is_const=True)
+    cls.add_method('GetClosestSide', 
+                   'ns3::Rectangle::Side', 
+                   [param('ns3::Vector&', 'position', is_const=True)], 
+                   is_const=True)
     ## rectangle.h: bool ns3::Rectangle::IsInside(ns3::Vector const & position) const [member function]
-    cls.add_method('IsInside', 'bool', [param('ns3::Vector&', 'position', is_const=True)], is_const=True)
+    cls.add_method('IsInside', 
+                   'bool', 
+                   [param('ns3::Vector&', 'position', is_const=True)], 
+                   is_const=True)
     ## rectangle.h: ns3::Rectangle::xMax [variable]
     cls.add_instance_attribute('xMax', 'double', is_const=False)
     ## rectangle.h: ns3::Rectangle::xMin [variable]
@@ -185,240 +213,460 @@
 
 def register_Ns3PositionAllocator_methods(root_module, cls):
     ## position-allocator.h: static ns3::TypeId ns3::PositionAllocator::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## position-allocator.h: ns3::PositionAllocator::PositionAllocator() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## position-allocator.h: ns3::Vector ns3::PositionAllocator::GetNext() const [member function]
-    cls.add_method('GetNext', 'ns3::Vector', [], is_pure_virtual=True, is_const=True, is_virtual=True)
+    cls.add_method('GetNext', 
+                   'ns3::Vector', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
     return
 
 def register_Ns3ListPositionAllocator_methods(root_module, cls):
     ## position-allocator.h: static ns3::TypeId ns3::ListPositionAllocator::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## position-allocator.h: ns3::ListPositionAllocator::ListPositionAllocator() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## position-allocator.h: void ns3::ListPositionAllocator::Add(ns3::Vector v) [member function]
-    cls.add_method('Add', 'void', [param('ns3::Vector', 'v')])
+    cls.add_method('Add', 
+                   'void', 
+                   [param('ns3::Vector', 'v')])
     ## position-allocator.h: ns3::Vector ns3::ListPositionAllocator::GetNext() const [member function]
-    cls.add_method('GetNext', 'ns3::Vector', [], is_const=True, is_virtual=True)
+    cls.add_method('GetNext', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, is_virtual=True)
     return
 
 def register_Ns3RectangleValue_methods(root_module, cls):
     ## rectangle.h: ns3::RectangleValue::RectangleValue() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## rectangle.h: ns3::RectangleValue::RectangleValue(ns3::Rectangle const & value) [constructor]
-    cls.add_constructor([param('ns3::Rectangle&', 'value', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::Rectangle&', 'value', is_const=True)])
     ## rectangle.h: void ns3::RectangleValue::Set(ns3::Rectangle const & value) [member function]
-    cls.add_method('Set', 'void', [param('ns3::Rectangle&', 'value', is_const=True)])
+    cls.add_method('Set', 
+                   'void', 
+                   [param('ns3::Rectangle&', 'value', is_const=True)])
     ## rectangle.h: ns3::Rectangle ns3::RectangleValue::Get() const [member function]
-    cls.add_method('Get', 'ns3::Rectangle', [], is_const=True)
+    cls.add_method('Get', 
+                   'ns3::Rectangle', 
+                   [], 
+                   is_const=True)
     ## rectangle.h: ns3::Ptr<ns3::AttributeValue> ns3::RectangleValue::Copy() const [member function]
-    cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## rectangle.h: std::string ns3::RectangleValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
-    cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True)
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, is_virtual=True)
     ## rectangle.h: bool ns3::RectangleValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
-    cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True)
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_virtual=True)
     return
 
 def register_Ns3RandomRectanglePositionAllocator_methods(root_module, cls):
     ## position-allocator.h: static ns3::TypeId ns3::RandomRectanglePositionAllocator::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## position-allocator.h: ns3::RandomRectanglePositionAllocator::RandomRectanglePositionAllocator() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## position-allocator.h: void ns3::RandomRectanglePositionAllocator::SetX(ns3::RandomVariable x) [member function]
-    cls.add_method('SetX', 'void', [param('ns3::RandomVariable', 'x')])
+    cls.add_method('SetX', 
+                   'void', 
+                   [param('ns3::RandomVariable', 'x')])
     ## position-allocator.h: void ns3::RandomRectanglePositionAllocator::SetY(ns3::RandomVariable y) [member function]
-    cls.add_method('SetY', 'void', [param('ns3::RandomVariable', 'y')])
+    cls.add_method('SetY', 
+                   'void', 
+                   [param('ns3::RandomVariable', 'y')])
     ## position-allocator.h: ns3::Vector ns3::RandomRectanglePositionAllocator::GetNext() const [member function]
-    cls.add_method('GetNext', 'ns3::Vector', [], is_const=True, is_virtual=True)
+    cls.add_method('GetNext', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, is_virtual=True)
     return
 
 def register_Ns3VectorValue_methods(root_module, cls):
     ## vector.h: ns3::VectorValue::VectorValue() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## vector.h: ns3::VectorValue::VectorValue(ns3::Vector const & value) [constructor]
-    cls.add_constructor([param('ns3::Vector&', 'value', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::Vector&', 'value', is_const=True)])
     ## vector.h: void ns3::VectorValue::Set(ns3::Vector const & value) [member function]
-    cls.add_method('Set', 'void', [param('ns3::Vector&', 'value', is_const=True)])
+    cls.add_method('Set', 
+                   'void', 
+                   [param('ns3::Vector&', 'value', is_const=True)])
     ## vector.h: ns3::Vector ns3::VectorValue::Get() const [member function]
-    cls.add_method('Get', 'ns3::Vector', [], is_const=True)
+    cls.add_method('Get', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True)
     ## vector.h: ns3::Ptr<ns3::AttributeValue> ns3::VectorValue::Copy() const [member function]
-    cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## vector.h: std::string ns3::VectorValue::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)
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, is_virtual=True)
     ## vector.h: bool ns3::VectorValue::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)
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_virtual=True)
     return
 
 def register_Ns3RandomDiscPositionAllocator_methods(root_module, cls):
     ## position-allocator.h: static ns3::TypeId ns3::RandomDiscPositionAllocator::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## position-allocator.h: ns3::RandomDiscPositionAllocator::RandomDiscPositionAllocator() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## position-allocator.h: void ns3::RandomDiscPositionAllocator::SetTheta(ns3::RandomVariable theta) [member function]
-    cls.add_method('SetTheta', 'void', [param('ns3::RandomVariable', 'theta')])
+    cls.add_method('SetTheta', 
+                   'void', 
+                   [param('ns3::RandomVariable', 'theta')])
     ## position-allocator.h: void ns3::RandomDiscPositionAllocator::SetRho(ns3::RandomVariable rho) [member function]
-    cls.add_method('SetRho', 'void', [param('ns3::RandomVariable', 'rho')])
+    cls.add_method('SetRho', 
+                   'void', 
+                   [param('ns3::RandomVariable', 'rho')])
     ## position-allocator.h: void ns3::RandomDiscPositionAllocator::SetX(double x) [member function]
-    cls.add_method('SetX', 'void', [param('double', 'x')])
+    cls.add_method('SetX', 
+                   'void', 
+                   [param('double', 'x')])
     ## position-allocator.h: void ns3::RandomDiscPositionAllocator::SetY(double y) [member function]
-    cls.add_method('SetY', 'void', [param('double', 'y')])
+    cls.add_method('SetY', 
+                   'void', 
+                   [param('double', 'y')])
     ## position-allocator.h: ns3::Vector ns3::RandomDiscPositionAllocator::GetNext() const [member function]
-    cls.add_method('GetNext', 'ns3::Vector', [], is_const=True, is_virtual=True)
+    cls.add_method('GetNext', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, is_virtual=True)
     return
 
 def register_Ns3MobilityModel_methods(root_module, cls):
     ## mobility-model.h: static ns3::TypeId ns3::MobilityModel::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## mobility-model.h: ns3::MobilityModel::MobilityModel() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## mobility-model.h: ns3::Vector ns3::MobilityModel::GetPosition() const [member function]
-    cls.add_method('GetPosition', 'ns3::Vector', [], is_const=True)
+    cls.add_method('GetPosition', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True)
     ## mobility-model.h: void ns3::MobilityModel::SetPosition(ns3::Vector const & position) [member function]
-    cls.add_method('SetPosition', 'void', [param('ns3::Vector&', 'position', is_const=True)])
+    cls.add_method('SetPosition', 
+                   'void', 
+                   [param('ns3::Vector&', 'position', is_const=True)])
     ## mobility-model.h: ns3::Vector ns3::MobilityModel::GetVelocity() const [member function]
-    cls.add_method('GetVelocity', 'ns3::Vector', [], is_const=True)
+    cls.add_method('GetVelocity', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True)
     ## mobility-model.h: double ns3::MobilityModel::GetDistanceFrom(ns3::Ptr<const ns3::MobilityModel> position) const [member function]
-    cls.add_method('GetDistanceFrom', 'double', [param('ns3::Ptr< const ns3::MobilityModel >', 'position')], is_const=True)
+    cls.add_method('GetDistanceFrom', 
+                   'double', 
+                   [param('ns3::Ptr< const ns3::MobilityModel >', 'position')], 
+                   is_const=True)
     ## mobility-model.h: void ns3::MobilityModel::NotifyCourseChange() const [member function]
-    cls.add_method('NotifyCourseChange', 'void', [], is_const=True, visibility='protected')
+    cls.add_method('NotifyCourseChange', 
+                   'void', 
+                   [], 
+                   is_const=True, visibility='protected')
     ## mobility-model.h: ns3::Vector ns3::MobilityModel::DoGetPosition() const [member function]
-    cls.add_method('DoGetPosition', 'ns3::Vector', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
+    cls.add_method('DoGetPosition', 
+                   'ns3::Vector', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
     ## mobility-model.h: void ns3::MobilityModel::DoSetPosition(ns3::Vector const & position) [member function]
-    cls.add_method('DoSetPosition', 'void', [param('ns3::Vector&', 'position', is_const=True)], is_pure_virtual=True, visibility='private', is_virtual=True)
+    cls.add_method('DoSetPosition', 
+                   'void', 
+                   [param('ns3::Vector&', 'position', is_const=True)], 
+                   is_pure_virtual=True, visibility='private', is_virtual=True)
     ## mobility-model.h: ns3::Vector ns3::MobilityModel::DoGetVelocity() const [member function]
-    cls.add_method('DoGetVelocity', 'ns3::Vector', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
+    cls.add_method('DoGetVelocity', 
+                   'ns3::Vector', 
+                   [], 
+                   is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
     return
 
 def register_Ns3RandomDirection2dMobilityModel_methods(root_module, cls):
     ## random-direction-2d-mobility-model.h: static ns3::TypeId ns3::RandomDirection2dMobilityModel::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## random-direction-2d-mobility-model.h: ns3::RandomDirection2dMobilityModel::RandomDirection2dMobilityModel() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## random-direction-2d-mobility-model.h: void ns3::RandomDirection2dMobilityModel::DoDispose() [member function]
-    cls.add_method('DoDispose', 'void', [], visibility='private', is_virtual=True)
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
     ## random-direction-2d-mobility-model.h: ns3::Vector ns3::RandomDirection2dMobilityModel::DoGetPosition() const [member function]
-    cls.add_method('DoGetPosition', 'ns3::Vector', [], is_const=True, visibility='private', is_virtual=True)
+    cls.add_method('DoGetPosition', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, visibility='private', is_virtual=True)
     ## random-direction-2d-mobility-model.h: void ns3::RandomDirection2dMobilityModel::DoSetPosition(ns3::Vector const & position) [member function]
-    cls.add_method('DoSetPosition', 'void', [param('ns3::Vector&', 'position', is_const=True)], visibility='private', is_virtual=True)
+    cls.add_method('DoSetPosition', 
+                   'void', 
+                   [param('ns3::Vector&', 'position', is_const=True)], 
+                   visibility='private', is_virtual=True)
     ## random-direction-2d-mobility-model.h: ns3::Vector ns3::RandomDirection2dMobilityModel::DoGetVelocity() const [member function]
-    cls.add_method('DoGetVelocity', 'ns3::Vector', [], is_const=True, visibility='private', is_virtual=True)
+    cls.add_method('DoGetVelocity', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, visibility='private', is_virtual=True)
     return
 
 def register_Ns3GridPositionAllocator_methods(root_module, cls):
     ## position-allocator.h: static ns3::TypeId ns3::GridPositionAllocator::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## position-allocator.h: ns3::GridPositionAllocator::GridPositionAllocator() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## position-allocator.h: void ns3::GridPositionAllocator::SetMinX(double xMin) [member function]
-    cls.add_method('SetMinX', 'void', [param('double', 'xMin')])
+    cls.add_method('SetMinX', 
+                   'void', 
+                   [param('double', 'xMin')])
     ## position-allocator.h: void ns3::GridPositionAllocator::SetMinY(double yMin) [member function]
-    cls.add_method('SetMinY', 'void', [param('double', 'yMin')])
+    cls.add_method('SetMinY', 
+                   'void', 
+                   [param('double', 'yMin')])
     ## position-allocator.h: void ns3::GridPositionAllocator::SetDeltaX(double deltaX) [member function]
-    cls.add_method('SetDeltaX', 'void', [param('double', 'deltaX')])
+    cls.add_method('SetDeltaX', 
+                   'void', 
+                   [param('double', 'deltaX')])
     ## position-allocator.h: void ns3::GridPositionAllocator::SetDeltaY(double deltaY) [member function]
-    cls.add_method('SetDeltaY', 'void', [param('double', 'deltaY')])
+    cls.add_method('SetDeltaY', 
+                   'void', 
+                   [param('double', 'deltaY')])
     ## position-allocator.h: void ns3::GridPositionAllocator::SetN(uint32_t n) [member function]
-    cls.add_method('SetN', 'void', [param('uint32_t', 'n')])
+    cls.add_method('SetN', 
+                   'void', 
+                   [param('uint32_t', 'n')])
     ## position-allocator.h: void ns3::GridPositionAllocator::SetLayoutType(ns3::GridPositionAllocator::LayoutType layoutType) [member function]
-    cls.add_method('SetLayoutType', 'void', [param('ns3::GridPositionAllocator::LayoutType', 'layoutType')])
+    cls.add_method('SetLayoutType', 
+                   'void', 
+                   [param('ns3::GridPositionAllocator::LayoutType', 'layoutType')])
     ## position-allocator.h: double ns3::GridPositionAllocator::GetMinX() const [member function]
-    cls.add_method('GetMinX', 'double', [], is_const=True)
+    cls.add_method('GetMinX', 
+                   'double', 
+                   [], 
+                   is_const=True)
     ## position-allocator.h: double ns3::GridPositionAllocator::GetMinY() const [member function]
-    cls.add_method('GetMinY', 'double', [], is_const=True)
+    cls.add_method('GetMinY', 
+                   'double', 
+                   [], 
+                   is_const=True)
     ## position-allocator.h: double ns3::GridPositionAllocator::GetDeltaX() const [member function]
-    cls.add_method('GetDeltaX', 'double', [], is_const=True)
+    cls.add_method('GetDeltaX', 
+                   'double', 
+                   [], 
+                   is_const=True)
     ## position-allocator.h: double ns3::GridPositionAllocator::GetDeltaY() const [member function]
-    cls.add_method('GetDeltaY', 'double', [], is_const=True)
+    cls.add_method('GetDeltaY', 
+                   'double', 
+                   [], 
+                   is_const=True)
     ## position-allocator.h: uint32_t ns3::GridPositionAllocator::GetN() const [member function]
-    cls.add_method('GetN', 'uint32_t', [], is_const=True)
+    cls.add_method('GetN', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## position-allocator.h: ns3::GridPositionAllocator::LayoutType ns3::GridPositionAllocator::GetLayoutType() const [member function]
-    cls.add_method('GetLayoutType', 'ns3::GridPositionAllocator::LayoutType', [], is_const=True)
+    cls.add_method('GetLayoutType', 
+                   'ns3::GridPositionAllocator::LayoutType', 
+                   [], 
+                   is_const=True)
     ## position-allocator.h: ns3::Vector ns3::GridPositionAllocator::GetNext() const [member function]
-    cls.add_method('GetNext', 'ns3::Vector', [], is_const=True, is_virtual=True)
+    cls.add_method('GetNext', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, is_virtual=True)
     return
 
 def register_Ns3RandomWaypointMobilityModel_methods(root_module, cls):
     ## random-waypoint-mobility-model.h: static ns3::TypeId ns3::RandomWaypointMobilityModel::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## random-waypoint-mobility-model.h: ns3::RandomWaypointMobilityModel::RandomWaypointMobilityModel() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## random-waypoint-mobility-model.h: ns3::Vector ns3::RandomWaypointMobilityModel::DoGetPosition() const [member function]
-    cls.add_method('DoGetPosition', 'ns3::Vector', [], is_const=True, visibility='private', is_virtual=True)
+    cls.add_method('DoGetPosition', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, visibility='private', is_virtual=True)
     ## random-waypoint-mobility-model.h: void ns3::RandomWaypointMobilityModel::DoSetPosition(ns3::Vector const & position) [member function]
-    cls.add_method('DoSetPosition', 'void', [param('ns3::Vector&', 'position', is_const=True)], visibility='private', is_virtual=True)
+    cls.add_method('DoSetPosition', 
+                   'void', 
+                   [param('ns3::Vector&', 'position', is_const=True)], 
+                   visibility='private', is_virtual=True)
     ## random-waypoint-mobility-model.h: ns3::Vector ns3::RandomWaypointMobilityModel::DoGetVelocity() const [member function]
-    cls.add_method('DoGetVelocity', 'ns3::Vector', [], is_const=True, visibility='private', is_virtual=True)
+    cls.add_method('DoGetVelocity', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, visibility='private', is_virtual=True)
     return
 
 def register_Ns3RandomWalk2dMobilityModel_methods(root_module, cls):
     ## random-walk-2d-mobility-model.h: static ns3::TypeId ns3::RandomWalk2dMobilityModel::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## random-walk-2d-mobility-model.h: ns3::RandomWalk2dMobilityModel::RandomWalk2dMobilityModel() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## random-walk-2d-mobility-model.h: void ns3::RandomWalk2dMobilityModel::DoDispose() [member function]
-    cls.add_method('DoDispose', 'void', [], visibility='private', is_virtual=True)
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
     ## random-walk-2d-mobility-model.h: ns3::Vector ns3::RandomWalk2dMobilityModel::DoGetPosition() const [member function]
-    cls.add_method('DoGetPosition', 'ns3::Vector', [], is_const=True, visibility='private', is_virtual=True)
+    cls.add_method('DoGetPosition', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, visibility='private', is_virtual=True)
     ## random-walk-2d-mobility-model.h: void ns3::RandomWalk2dMobilityModel::DoSetPosition(ns3::Vector const & position) [member function]
-    cls.add_method('DoSetPosition', 'void', [param('ns3::Vector&', 'position', is_const=True)], visibility='private', is_virtual=True)
+    cls.add_method('DoSetPosition', 
+                   'void', 
+                   [param('ns3::Vector&', 'position', is_const=True)], 
+                   visibility='private', is_virtual=True)
     ## random-walk-2d-mobility-model.h: ns3::Vector ns3::RandomWalk2dMobilityModel::DoGetVelocity() const [member function]
-    cls.add_method('DoGetVelocity', 'ns3::Vector', [], is_const=True, visibility='private', is_virtual=True)
+    cls.add_method('DoGetVelocity', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, visibility='private', is_virtual=True)
     return
 
 def register_Ns3StaticSpeedMobilityModel_methods(root_module, cls):
     ## static-speed-mobility-model.h: static ns3::TypeId ns3::StaticSpeedMobilityModel::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## static-speed-mobility-model.h: ns3::StaticSpeedMobilityModel::StaticSpeedMobilityModel() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## static-speed-mobility-model.h: void ns3::StaticSpeedMobilityModel::SetSpeed(ns3::Vector const & speed) [member function]
-    cls.add_method('SetSpeed', 'void', [param('ns3::Vector&', 'speed', is_const=True)])
+    cls.add_method('SetSpeed', 
+                   'void', 
+                   [param('ns3::Vector&', 'speed', is_const=True)])
     ## static-speed-mobility-model.h: ns3::Vector ns3::StaticSpeedMobilityModel::DoGetPosition() const [member function]
-    cls.add_method('DoGetPosition', 'ns3::Vector', [], is_const=True, visibility='private', is_virtual=True)
+    cls.add_method('DoGetPosition', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, visibility='private', is_virtual=True)
     ## static-speed-mobility-model.h: void ns3::StaticSpeedMobilityModel::DoSetPosition(ns3::Vector const & position) [member function]
-    cls.add_method('DoSetPosition', 'void', [param('ns3::Vector&', 'position', is_const=True)], visibility='private', is_virtual=True)
+    cls.add_method('DoSetPosition', 
+                   'void', 
+                   [param('ns3::Vector&', 'position', is_const=True)], 
+                   visibility='private', is_virtual=True)
     ## static-speed-mobility-model.h: ns3::Vector ns3::StaticSpeedMobilityModel::DoGetVelocity() const [member function]
-    cls.add_method('DoGetVelocity', 'ns3::Vector', [], is_const=True, visibility='private', is_virtual=True)
+    cls.add_method('DoGetVelocity', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, visibility='private', is_virtual=True)
     return
 
 def register_Ns3HierarchicalMobilityModel_methods(root_module, cls):
     ## hierarchical-mobility-model.h: static ns3::TypeId ns3::HierarchicalMobilityModel::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## hierarchical-mobility-model.h: ns3::HierarchicalMobilityModel::HierarchicalMobilityModel() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## hierarchical-mobility-model.h: ns3::Ptr<ns3::MobilityModel> ns3::HierarchicalMobilityModel::GetChild() const [member function]
-    cls.add_method('GetChild', 'ns3::Ptr< ns3::MobilityModel >', [], is_const=True)
+    cls.add_method('GetChild', 
+                   'ns3::Ptr< ns3::MobilityModel >', 
+                   [], 
+                   is_const=True)
     ## hierarchical-mobility-model.h: ns3::Ptr<ns3::MobilityModel> ns3::HierarchicalMobilityModel::GetParent() const [member function]
-    cls.add_method('GetParent', 'ns3::Ptr< ns3::MobilityModel >', [], is_const=True)
+    cls.add_method('GetParent', 
+                   'ns3::Ptr< ns3::MobilityModel >', 
+                   [], 
+                   is_const=True)
     ## hierarchical-mobility-model.h: ns3::Vector ns3::HierarchicalMobilityModel::DoGetPosition() const [member function]
-    cls.add_method('DoGetPosition', 'ns3::Vector', [], is_const=True, visibility='private', is_virtual=True)
+    cls.add_method('DoGetPosition', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, visibility='private', is_virtual=True)
     ## hierarchical-mobility-model.h: void ns3::HierarchicalMobilityModel::DoSetPosition(ns3::Vector const & position) [member function]
-    cls.add_method('DoSetPosition', 'void', [param('ns3::Vector&', 'position', is_const=True)], visibility='private', is_virtual=True)
+    cls.add_method('DoSetPosition', 
+                   'void', 
+                   [param('ns3::Vector&', 'position', is_const=True)], 
+                   visibility='private', is_virtual=True)
     ## hierarchical-mobility-model.h: ns3::Vector ns3::HierarchicalMobilityModel::DoGetVelocity() const [member function]
-    cls.add_method('DoGetVelocity', 'ns3::Vector', [], is_const=True, visibility='private', is_virtual=True)
+    cls.add_method('DoGetVelocity', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, visibility='private', is_virtual=True)
     return
 
 def register_Ns3StaticMobilityModel_methods(root_module, cls):
     ## static-mobility-model.h: static ns3::TypeId ns3::StaticMobilityModel::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## static-mobility-model.h: ns3::StaticMobilityModel::StaticMobilityModel() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## static-mobility-model.h: ns3::Vector ns3::StaticMobilityModel::DoGetPosition() const [member function]
-    cls.add_method('DoGetPosition', 'ns3::Vector', [], is_const=True, visibility='private', is_virtual=True)
+    cls.add_method('DoGetPosition', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, visibility='private', is_virtual=True)
     ## static-mobility-model.h: void ns3::StaticMobilityModel::DoSetPosition(ns3::Vector const & position) [member function]
-    cls.add_method('DoSetPosition', 'void', [param('ns3::Vector&', 'position', is_const=True)], visibility='private', is_virtual=True)
+    cls.add_method('DoSetPosition', 
+                   'void', 
+                   [param('ns3::Vector&', 'position', is_const=True)], 
+                   visibility='private', is_virtual=True)
     ## static-mobility-model.h: ns3::Vector ns3::StaticMobilityModel::DoGetVelocity() const [member function]
-    cls.add_method('DoGetVelocity', 'ns3::Vector', [], is_const=True, visibility='private', is_virtual=True)
+    cls.add_method('DoGetVelocity', 
+                   'ns3::Vector', 
+                   [], 
+                   is_const=True, visibility='private', is_virtual=True)
     return
 
 def register_functions(root_module):
     module = root_module
     ## rectangle.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeRectangleChecker() [free function]
-    module.add_function('MakeRectangleChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [])
+    module.add_function('MakeRectangleChecker', 
+                        'ns3::Ptr< ns3::AttributeChecker const >', 
+                        [])
     ## vector.h: extern double ns3::CalculateDistance(ns3::Vector const & a, ns3::Vector const & b) [free function]
-    module.add_function('CalculateDistance', 'double', [param('ns3::Vector&', 'a', is_const=True), param('ns3::Vector&', 'b', is_const=True)])
+    module.add_function('CalculateDistance', 
+                        'double', 
+                        [param('ns3::Vector&', 'a', is_const=True), param('ns3::Vector&', 'b', is_const=True)])
     ## vector.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeVectorChecker() [free function]
-    module.add_function('MakeVectorChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [])
+    module.add_function('MakeVectorChecker', 
+                        'ns3::Ptr< ns3::AttributeChecker const >', 
+                        [])
     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
--- a/bindings/python/ns3_module_node.py	Fri Jul 18 21:59:43 2008 -0700
+++ b/bindings/python/ns3_module_node.py	Mon Jul 21 15:53:03 2008 -0700
@@ -1,4 +1,4 @@
-from pybindgen import Module, FileCodeSink, write_preamble, param, retval
+from pybindgen import Module, FileCodeSink, param, retval, cppclass
 
 def register_types(module):
     root_module = module.get_root()
@@ -40,15 +40,15 @@
     ## ipv4-address.h: ns3::Ipv4Mask [class]
     module.add_class('Ipv4Mask')
     ## ipv4-address.h: ns3::Ipv4AddressValue [class]
-    module.add_class('Ipv4AddressValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue'])
+    module.add_class('Ipv4AddressValue', parent=root_module['ns3::AttributeValue'])
     ## ipv4.h: ns3::Ipv4RoutingProtocol [class]
-    module.add_class('Ipv4RoutingProtocol', allow_subclassing=True, parent=root_module['ns3::Object'])
+    module.add_class('Ipv4RoutingProtocol', parent=root_module['ns3::Object'])
     ## mac48-address.h: ns3::Mac48AddressValue [class]
-    module.add_class('Mac48AddressValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue'])
+    module.add_class('Mac48AddressValue', parent=root_module['ns3::AttributeValue'])
     ## ipv4-address.h: ns3::Ipv4MaskValue [class]
-    module.add_class('Ipv4MaskValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue'])
+    module.add_class('Ipv4MaskValue', parent=root_module['ns3::AttributeValue'])
     ## socket.h: ns3::SocketAddressTag [class]
-    module.add_class('SocketAddressTag', allow_subclassing=True, parent=root_module['ns3::Tag'])
+    module.add_class('SocketAddressTag', parent=root_module['ns3::Tag'])
     ## inet-socket-address.h: ns3::InetSocketAddress [class]
     module.add_class('InetSocketAddress')
     ## inet-socket-address.h: ns3::InetSocketAddress [class]
@@ -58,51 +58,53 @@
     ## ipv4-address.h: ns3::Ipv4Address [class]
     root_module['ns3::Ipv4Address'].implicitly_converts_to(root_module['ns3::Address'])
     ## application.h: ns3::Application [class]
-    module.add_class('Application', allow_subclassing=True, parent=root_module['ns3::Object'])
+    module.add_class('Application', parent=root_module['ns3::Object'])
     ## queue.h: ns3::Queue [class]
-    module.add_class('Queue', allow_subclassing=True, parent=root_module['ns3::Object'])
+    module.add_class('Queue', parent=root_module['ns3::Object'])
     ## socket.h: ns3::Socket [class]
-    module.add_class('Socket', allow_subclassing=True, parent=root_module['ns3::Object'])
+    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'])
     ## ipv4-header.h: ns3::Ipv4Header [class]
-    module.add_class('Ipv4Header', allow_subclassing=True, parent=root_module['ns3::Header'])
+    module.add_class('Ipv4Header', parent=root_module['ns3::Header'])
     ## udp-socket.h: ns3::UdpSocket [class]
-    module.add_class('UdpSocket', allow_subclassing=True, parent=root_module['ns3::Socket'])
+    module.add_class('UdpSocket', parent=root_module['ns3::Socket'])
     ## net-device.h: ns3::NetDevice [class]
-    module.add_class('NetDevice', allow_subclassing=True, parent=root_module['ns3::Object'])
+    module.add_class('NetDevice', parent=root_module['ns3::Object'])
+    ## net-device.h: ns3::NetDevice::PacketType [enumeration]
+    module.add_enum('PacketType', ['PACKET_HOST', 'PACKET_BROADCAST', 'PACKET_MULTICAST', 'PACKET_OTHERHOST'], outer_class=root_module['ns3::NetDevice'])
+    ## address.h: ns3::AddressValue [class]
+    module.add_class('AddressValue', parent=root_module['ns3::AttributeValue'])
+    ## node.h: ns3::Node [class]
+    module.add_class('Node', parent=root_module['ns3::Object'])
     ## channel.h: ns3::Channel [class]
-    module.add_class('Channel', allow_subclassing=True, parent=root_module['ns3::Object'])
-    ## simple-channel.h: ns3::SimpleChannel [class]
-    module.add_class('SimpleChannel', allow_subclassing=True, parent=root_module['ns3::Channel'])
-    ## address.h: ns3::AddressValue [class]
-    module.add_class('AddressValue', allow_subclassing=True, parent=root_module['ns3::AttributeValue'])
-    ## node.h: ns3::Node [class]
-    module.add_class('Node', allow_subclassing=True, parent=root_module['ns3::Object'])
+    module.add_class('Channel', parent=root_module['ns3::Object'])
     ## tcp-socket.h: ns3::TcpSocket [class]
-    module.add_class('TcpSocket', allow_subclassing=True, parent=root_module['ns3::Socket'])
+    module.add_class('TcpSocket', parent=root_module['ns3::Socket'])
     ## ethernet-header.h: ns3::EthernetHeader [class]
-    module.add_class('EthernetHeader', allow_subclassing=True, parent=root_module['ns3::Header'])
+    module.add_class('EthernetHeader', parent=root_module['ns3::Header'])
     ## socket.h: ns3::SocketIpTtlTag [class]
-    module.add_class('SocketIpTtlTag', allow_subclassing=True, parent=root_module['ns3::Tag'])
+    module.add_class('SocketIpTtlTag', parent=root_module['ns3::Tag'])
     ## ipv4.h: ns3::Ipv4 [class]
-    module.add_class('Ipv4', allow_subclassing=True, parent=root_module['ns3::Object'])
+    module.add_class('Ipv4', parent=root_module['ns3::Object'])
     ## socket-factory.h: ns3::SocketFactory [class]
-    module.add_class('SocketFactory', allow_subclassing=True, parent=root_module['ns3::Object'])
+    module.add_class('SocketFactory', parent=root_module['ns3::Object'])
     ## drop-tail-queue.h: ns3::DropTailQueue [class]
-    module.add_class('DropTailQueue', allow_subclassing=True, parent=root_module['ns3::Queue'])
+    module.add_class('DropTailQueue', parent=root_module['ns3::Queue'])
     ## ethernet-trailer.h: ns3::EthernetTrailer [class]
-    module.add_class('EthernetTrailer', allow_subclassing=True, parent=root_module['ns3::Trailer'])
+    module.add_class('EthernetTrailer', parent=root_module['ns3::Trailer'])
     ## llc-snap-header.h: ns3::LlcSnapHeader [class]
-    module.add_class('LlcSnapHeader', allow_subclassing=True, parent=root_module['ns3::Header'])
+    module.add_class('LlcSnapHeader', parent=root_module['ns3::Header'])
     ## udp-socket-factory.h: ns3::UdpSocketFactory [class]
     module.add_class('UdpSocketFactory', parent=root_module['ns3::SocketFactory'])
     ## simple-net-device.h: ns3::SimpleNetDevice [class]
-    module.add_class('SimpleNetDevice', allow_subclassing=True, parent=root_module['ns3::NetDevice'])
+    module.add_class('SimpleNetDevice', parent=root_module['ns3::NetDevice'])
+    ## simple-channel.h: ns3::SimpleChannel [class]
+    module.add_class('SimpleChannel', parent=root_module['ns3::Channel'])
     ## tcp-socket-factory.h: ns3::TcpSocketFactory [class]
     module.add_class('TcpSocketFactory', parent=root_module['ns3::SocketFactory'])
     ## packet-socket-factory.h: ns3::PacketSocketFactory [class]
-    module.add_class('PacketSocketFactory', allow_subclassing=True, parent=root_module['ns3::SocketFactory'])
+    module.add_class('PacketSocketFactory', parent=root_module['ns3::SocketFactory'])
     
     ## Register a nested module for the namespace internal
     
@@ -171,10 +173,9 @@
     register_Ns3Ipv4Header_methods(root_module, root_module['ns3::Ipv4Header'])
     register_Ns3UdpSocket_methods(root_module, root_module['ns3::UdpSocket'])
     register_Ns3NetDevice_methods(root_module, root_module['ns3::NetDevice'])
-    register_Ns3Channel_methods(root_module, root_module['ns3::Channel'])
-    register_Ns3SimpleChannel_methods(root_module, root_module['ns3::SimpleChannel'])
     register_Ns3AddressValue_methods(root_module, root_module['ns3::AddressValue'])
     register_Ns3Node_methods(root_module, root_module['ns3::Node'])
+    register_Ns3Channel_methods(root_module, root_module['ns3::Channel'])
     register_Ns3TcpSocket_methods(root_module, root_module['ns3::TcpSocket'])
     register_Ns3EthernetHeader_methods(root_module, root_module['ns3::EthernetHeader'])
     register_Ns3SocketIpTtlTag_methods(root_module, root_module['ns3::SocketIpTtlTag'])
@@ -185,55 +186,104 @@
     register_Ns3LlcSnapHeader_methods(root_module, root_module['ns3::LlcSnapHeader'])
     register_Ns3UdpSocketFactory_methods(root_module, root_module['ns3::UdpSocketFactory'])
     register_Ns3SimpleNetDevice_methods(root_module, root_module['ns3::SimpleNetDevice'])
+    register_Ns3SimpleChannel_methods(root_module, root_module['ns3::SimpleChannel'])
     register_Ns3TcpSocketFactory_methods(root_module, root_module['ns3::TcpSocketFactory'])
     register_Ns3PacketSocketFactory_methods(root_module, root_module['ns3::PacketSocketFactory'])
     return
 
 def register_Ns3NodeList_methods(root_module, cls):
     ## node-list.h: static uint32_t ns3::NodeList::Add(ns3::Ptr<ns3::Node> node) [member function]
-    cls.add_method('Add', 'uint32_t', [param('ns3::Ptr< ns3::Node >', 'node')], is_static=True)
+    cls.add_method('Add', 
+                   'uint32_t', 
+                   [param('ns3::Ptr< ns3::Node >', 'node')], 
+                   is_static=True)
     ## node-list.h: static __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Node>*,std::vector<ns3::Ptr<ns3::Node>, std::allocator<ns3::Ptr<ns3::Node> > > > ns3::NodeList::Begin() [member function]
-    cls.add_method('Begin', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node >, std::allocator< ns3::Ptr< ns3::Node > > > >', [], is_static=True)
+    cls.add_method('Begin', 
+                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node >, std::allocator< ns3::Ptr< ns3::Node > > > >', 
+                   [], 
+                   is_static=True)
     ## node-list.h: static __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Node>*,std::vector<ns3::Ptr<ns3::Node>, std::allocator<ns3::Ptr<ns3::Node> > > > ns3::NodeList::End() [member function]
-    cls.add_method('End', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node >, std::allocator< ns3::Ptr< ns3::Node > > > >', [], is_static=True)
+    cls.add_method('End', 
+                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node >, std::allocator< ns3::Ptr< ns3::Node > > > >', 
+                   [], 
+                   is_static=True)
     ## node-list.h: static ns3::Ptr<ns3::Node> ns3::NodeList::GetNode(uint32_t n) [member function]
-    cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', [param('uint32_t', 'n')], is_static=True)
+    cls.add_method('GetNode', 
+                   'ns3::Ptr< ns3::Node >', 
+                   [param('uint32_t', 'n')], 
+                   is_static=True)
     ## node-list.h: static uint32_t ns3::NodeList::GetNNodes() [member function]
-    cls.add_method('GetNNodes', 'uint32_t', [], is_static=True)
+    cls.add_method('GetNNodes', 
+                   'uint32_t', 
+                   [], 
+                   is_static=True)
     cls.add_constructor([])
     return
 
 def register_Ns3Address_methods(root_module, cls):
     ## address.h: ns3::Address::Address() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## address.h: ns3::Address::Address(uint8_t type, uint8_t const * buffer, uint8_t len) [constructor]
-    cls.add_constructor([param('uint8_t', 'type'), param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint8_t', 'len')], visibility='public')
+    cls.add_constructor([param('uint8_t', 'type'), param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint8_t', 'len')])
     ## address.h: ns3::Address::Address(ns3::Address const & address) [copy constructor]
-    cls.add_constructor([param('ns3::Address&', 'address', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::Address&', 'address', is_const=True)])
     ## address.h: bool ns3::Address::CheckCompatible(uint8_t type, uint8_t len) const [member function]
-    cls.add_method('CheckCompatible', 'bool', [param('uint8_t', 'type'), param('uint8_t', 'len')], is_const=True)
+    cls.add_method('CheckCompatible', 
+                   'bool', 
+                   [param('uint8_t', 'type'), param('uint8_t', 'len')], 
+                   is_const=True)
     ## address.h: uint32_t ns3::Address::CopyAllFrom(uint8_t const * buffer, uint8_t len) [member function]
-    cls.add_method('CopyAllFrom', 'uint32_t', [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint8_t', 'len')])
+    cls.add_method('CopyAllFrom', 
+                   'uint32_t', 
+                   [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint8_t', 'len')])
     ## address.h: uint32_t ns3::Address::CopyAllTo(uint8_t * buffer, uint8_t len) const [member function]
-    cls.add_method('CopyAllTo', 'uint32_t', [param('uint8_t *', 'buffer'), param('uint8_t', 'len')], is_const=True)
+    cls.add_method('CopyAllTo', 
+                   'uint32_t', 
+                   [param('uint8_t *', 'buffer'), param('uint8_t', 'len')], 
+                   is_const=True)
     ## address.h: uint32_t ns3::Address::CopyFrom(uint8_t const * buffer, uint8_t len) [member function]
-    cls.add_method('CopyFrom', 'uint32_t', [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint8_t', 'len')])
+    cls.add_method('CopyFrom', 
+                   'uint32_t', 
+                   [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint8_t', 'len')])
     ## address.h: uint32_t ns3::Address::CopyTo(uint8_t * buffer) const [member function]
-    cls.add_method('CopyTo', 'uint32_t', [param('uint8_t *', 'buffer')], is_const=True)
+    cls.add_method('CopyTo', 
+                   'uint32_t', 
+                   [param('uint8_t *', 'buffer')], 
+                   is_const=True)
     ## address.h: void ns3::Address::Deserialize(ns3::TagBuffer buffer) [member function]
-    cls.add_method('Deserialize', 'void', [param('ns3::TagBuffer', 'buffer')])
+    cls.add_method('Deserialize', 
+                   'void', 
+                   [param('ns3::TagBuffer', 'buffer')])
     ## address.h: uint8_t ns3::Address::GetLength() const [member function]
-    cls.add_method('GetLength', 'uint8_t', [], is_const=True)
+    cls.add_method('GetLength', 
+                   'uint8_t', 
+                   [], 
+                   is_const=True)
     ## address.h: uint32_t ns3::Address::GetSerializedSize() const [member function]
-    cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True)
+    cls.add_method('GetSerializedSize', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## address.h: bool ns3::Address::IsInvalid() const [member function]
-    cls.add_method('IsInvalid', 'bool', [], is_const=True)
+    cls.add_method('IsInvalid', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## address.h: bool ns3::Address::IsMatchingType(uint8_t type) const [member function]
-    cls.add_method('IsMatchingType', 'bool', [param('uint8_t', 'type')], is_const=True)
+    cls.add_method('IsMatchingType', 
+                   'bool', 
+                   [param('uint8_t', 'type')], 
+                   is_const=True)
     ## address.h: static uint8_t ns3::Address::Register() [member function]
-    cls.add_method('Register', 'uint8_t', [], is_static=True)
+    cls.add_method('Register', 
+                   'uint8_t', 
+                   [], 
+                   is_static=True)
     ## address.h: void ns3::Address::Serialize(ns3::TagBuffer buffer) const [member function]
-    cls.add_method('Serialize', 'void', [param('ns3::TagBuffer', 'buffer')], is_const=True)
+    cls.add_method('Serialize', 
+                   'void', 
+                   [param('ns3::TagBuffer', 'buffer')], 
+                   is_const=True)
     cls.add_output_stream_operator()
     return
 
@@ -243,69 +293,133 @@
 
 def register_Ns3Mac48Address_methods(root_module, cls):
     ## mac48-address.h: ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Mac48Address&', 'arg0', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::Mac48Address&', 'arg0', is_const=True)])
     ## mac48-address.h: ns3::Mac48Address::Mac48Address() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## mac48-address.h: ns3::Mac48Address::Mac48Address(char const * str) [constructor]
-    cls.add_constructor([param('char *', 'str', transfer_ownership=False, is_const=True)], visibility='public')
+    cls.add_constructor([param('char *', 'str', transfer_ownership=False, is_const=True)])
     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::Allocate() [member function]
-    cls.add_method('Allocate', 'ns3::Mac48Address', [], is_static=True)
+    cls.add_method('Allocate', 
+                   'ns3::Mac48Address', 
+                   [], 
+                   is_static=True)
     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::ConvertFrom(ns3::Address const & address) [member function]
-    cls.add_method('ConvertFrom', 'ns3::Mac48Address', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
+    cls.add_method('ConvertFrom', 
+                   'ns3::Mac48Address', 
+                   [param('ns3::Address&', 'address', is_const=True)], 
+                   is_static=True)
     ## mac48-address.h: void ns3::Mac48Address::CopyFrom(uint8_t const * buffer) [member function]
-    cls.add_method('CopyFrom', 'void', [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True)])
+    cls.add_method('CopyFrom', 
+                   'void', 
+                   [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True)])
     ## mac48-address.h: void ns3::Mac48Address::CopyTo(uint8_t * buffer) const [member function]
-    cls.add_method('CopyTo', 'void', [param('uint8_t *', 'buffer')], is_const=True)
+    cls.add_method('CopyTo', 
+                   'void', 
+                   [param('uint8_t *', 'buffer')], 
+                   is_const=True)
     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::GetBroadcast() [member function]
-    cls.add_method('GetBroadcast', 'ns3::Mac48Address', [], is_static=True)
+    cls.add_method('GetBroadcast', 
+                   'ns3::Mac48Address', 
+                   [], 
+                   is_static=True)
     ## mac48-address.h: bool ns3::Mac48Address::IsBroadcast() const [member function]
-    cls.add_method('IsBroadcast', 'bool', [], is_const=True)
+    cls.add_method('IsBroadcast', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## mac48-address.h: static bool ns3::Mac48Address::IsMatchingType(ns3::Address const & address) [member function]
-    cls.add_method('IsMatchingType', 'bool', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
+    cls.add_method('IsMatchingType', 
+                   'bool', 
+                   [param('ns3::Address&', 'address', is_const=True)], 
+                   is_static=True)
     ## mac48-address.h: bool ns3::Mac48Address::IsMulticast() const [member function]
-    cls.add_method('IsMulticast', 'bool', [], is_const=True)
+    cls.add_method('IsMulticast', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     cls.add_output_stream_operator()
     return
 
 def register_Ns3Mac64Address_methods(root_module, cls):
     ## mac64-address.h: ns3::Mac64Address::Mac64Address(ns3::Mac64Address const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Mac64Address&', 'arg0', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::Mac64Address&', 'arg0', is_const=True)])
     ## mac64-address.h: ns3::Mac64Address::Mac64Address() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## mac64-address.h: ns3::Mac64Address::Mac64Address(char const * str) [constructor]
-    cls.add_constructor([param('char *', 'str', transfer_ownership=False, is_const=True)], visibility='public')
+    cls.add_constructor([param('char *', 'str', transfer_ownership=False, is_const=True)])
     ## mac64-address.h: static ns3::Mac64Address ns3::Mac64Address::Allocate() [member function]
-    cls.add_method('Allocate', 'ns3::Mac64Address', [], is_static=True)
+    cls.add_method('Allocate', 
+                   'ns3::Mac64Address', 
+                   [], 
+                   is_static=True)
     ## mac64-address.h: static ns3::Mac64Address ns3::Mac64Address::ConvertFrom(ns3::Address const & address) [member function]
-    cls.add_method('ConvertFrom', 'ns3::Mac64Address', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
+    cls.add_method('ConvertFrom', 
+                   'ns3::Mac64Address', 
+                   [param('ns3::Address&', 'address', is_const=True)], 
+                   is_static=True)
     ## mac64-address.h: void ns3::Mac64Address::CopyFrom(uint8_t const * buffer) [member function]
-    cls.add_method('CopyFrom', 'void', [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True)])
+    cls.add_method('CopyFrom', 
+                   'void', 
+                   [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True)])
     ## mac64-address.h: void ns3::Mac64Address::CopyTo(uint8_t * buffer) const [member function]
-    cls.add_method('CopyTo', 'void', [param('uint8_t *', 'buffer')], is_const=True)
+    cls.add_method('CopyTo', 
+                   'void', 
+                   [param('uint8_t *', 'buffer')], 
+                   is_const=True)
     ## mac64-address.h: static bool ns3::Mac64Address::IsMatchingType(ns3::Address const & address) [member function]
-    cls.add_method('IsMatchingType', 'bool', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
+    cls.add_method('IsMatchingType', 
+                   'bool', 
+                   [param('ns3::Address&', 'address', is_const=True)], 
+                   is_static=True)
     cls.add_output_stream_operator()
     return
 
 def register_Ns3Ipv4AddressGenerator_methods(root_module, cls):
     ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::Init(ns3::Ipv4Address const net, ns3::Ipv4Mask const mask, ns3::Ipv4Address const addr="0.0.0.1") [member function]
-    cls.add_method('Init', 'void', [param('ns3::Ipv4Address', 'net', is_const=True), param('ns3::Ipv4Mask', 'mask', is_const=True), param('ns3::Ipv4Address', 'addr', default_value='"0.0.0.1"', is_const=True)], is_static=True)
+    cls.add_method('Init', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'net', is_const=True), param('ns3::Ipv4Mask', 'mask', is_const=True), param('ns3::Ipv4Address', 'addr', default_value='"0.0.0.1"', is_const=True)], 
+                   is_static=True)
     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::NextNetwork(ns3::Ipv4Mask const mask) [member function]
-    cls.add_method('NextNetwork', 'ns3::Ipv4Address', [param('ns3::Ipv4Mask', 'mask', is_const=True)], is_static=True)
+    cls.add_method('NextNetwork', 
+                   'ns3::Ipv4Address', 
+                   [param('ns3::Ipv4Mask', 'mask', is_const=True)], 
+                   is_static=True)
     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::GetNetwork(ns3::Ipv4Mask const mask) [member function]
-    cls.add_method('GetNetwork', 'ns3::Ipv4Address', [param('ns3::Ipv4Mask', 'mask', is_const=True)], is_static=True)
+    cls.add_method('GetNetwork', 
+                   'ns3::Ipv4Address', 
+                   [param('ns3::Ipv4Mask', 'mask', is_const=True)], 
+                   is_static=True)
     ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::InitAddress(ns3::Ipv4Address const addr, ns3::Ipv4Mask const mask) [member function]
-    cls.add_method('InitAddress', 'void', [param('ns3::Ipv4Address', 'addr', is_const=True), param('ns3::Ipv4Mask', 'mask', is_const=True)], is_static=True)
+    cls.add_method('InitAddress', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'addr', is_const=True), param('ns3::Ipv4Mask', 'mask', is_const=True)], 
+                   is_static=True)
     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::NextAddress(ns3::Ipv4Mask const mask) [member function]
-    cls.add_method('NextAddress', 'ns3::Ipv4Address', [param('ns3::Ipv4Mask', 'mask', is_const=True)], is_static=True)
+    cls.add_method('NextAddress', 
+                   'ns3::Ipv4Address', 
+                   [param('ns3::Ipv4Mask', 'mask', is_const=True)], 
+                   is_static=True)
     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::GetAddress(ns3::Ipv4Mask const mask) [member function]
-    cls.add_method('GetAddress', 'ns3::Ipv4Address', [param('ns3::Ipv4Mask', 'mask', is_const=True)], is_static=True)
+    cls.add_method('GetAddress', 
+                   'ns3::Ipv4Address', 
+                   [param('ns3::Ipv4Mask', 'mask', is_const=True)], 
+                   is_static=True)
     ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::Reset() [member function]
-    cls.add_method('Reset', 'void', [], is_static=True)
+    cls.add_method('Reset', 
+                   'void', 
+                   [], 
+                   is_static=True)
     ## ipv4-address-generator.h: static bool ns3::Ipv4AddressGenerator::AddAllocated(ns3::Ipv4Address const addr) [member function]
-    cls.add_method('AddAllocated', 'bool', [param('ns3::Ipv4Address', 'addr', is_const=True)], is_static=True)
+    cls.add_method('AddAllocated', 
+                   'bool', 
+                   [param('ns3::Ipv4Address', 'addr', is_const=True)], 
+                   is_static=True)
     ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::TestMode() [member function]
-    cls.add_method('TestMode', 'void', [], is_static=True)
+    cls.add_method('TestMode', 
+                   'void', 
+                   [], 
+                   is_static=True)
     cls.add_constructor([])
     return
 
@@ -319,63 +433,126 @@
 
 def register_Ns3Ipv4Route_methods(root_module, cls):
     ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route(ns3::Ipv4Route const & route) [copy constructor]
-    cls.add_constructor([param('ns3::Ipv4Route&', 'route', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::Ipv4Route&', 'route', is_const=True)])
     ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route(ns3::Ipv4Route const * route) [constructor]
-    cls.add_constructor([param('ns3::Ipv4Route *', 'route', transfer_ownership=False, is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::Ipv4Route *', 'route', transfer_ownership=False, is_const=True)])
     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateDefaultRoute(ns3::Ipv4Address nextHop, uint32_t interface) [member function]
-    cls.add_method('CreateDefaultRoute', 'ns3::Ipv4Route', [param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], is_static=True)
+    cls.add_method('CreateDefaultRoute', 
+                   'ns3::Ipv4Route', 
+                   [param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], 
+                   is_static=True)
     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateHostRouteTo(ns3::Ipv4Address dest, ns3::Ipv4Address nextHop, uint32_t interface) [member function]
-    cls.add_method('CreateHostRouteTo', 'ns3::Ipv4Route', [param('ns3::Ipv4Address', 'dest'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], is_static=True)
+    cls.add_method('CreateHostRouteTo', 
+                   'ns3::Ipv4Route', 
+                   [param('ns3::Ipv4Address', 'dest'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], 
+                   is_static=True)
     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateHostRouteTo(ns3::Ipv4Address dest, uint32_t interface) [member function]
-    cls.add_method('CreateHostRouteTo', 'ns3::Ipv4Route', [param('ns3::Ipv4Address', 'dest'), param('uint32_t', 'interface')], is_static=True)
+    cls.add_method('CreateHostRouteTo', 
+                   'ns3::Ipv4Route', 
+                   [param('ns3::Ipv4Address', 'dest'), param('uint32_t', 'interface')], 
+                   is_static=True)
     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, ns3::Ipv4Address nextHop, uint32_t interface) [member function]
-    cls.add_method('CreateNetworkRouteTo', 'ns3::Ipv4Route', [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], is_static=True)
+    cls.add_method('CreateNetworkRouteTo', 
+                   'ns3::Ipv4Route', 
+                   [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], 
+                   is_static=True)
     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, uint32_t interface) [member function]
-    cls.add_method('CreateNetworkRouteTo', 'ns3::Ipv4Route', [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('uint32_t', 'interface')], is_static=True)
+    cls.add_method('CreateNetworkRouteTo', 
+                   'ns3::Ipv4Route', 
+                   [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('uint32_t', 'interface')], 
+                   is_static=True)
     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4Route::GetDest() const [member function]
-    cls.add_method('GetDest', 'ns3::Ipv4Address', [], is_const=True)
+    cls.add_method('GetDest', 
+                   'ns3::Ipv4Address', 
+                   [], 
+                   is_const=True)
     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4Route::GetDestNetwork() const [member function]
-    cls.add_method('GetDestNetwork', 'ns3::Ipv4Address', [], is_const=True)
+    cls.add_method('GetDestNetwork', 
+                   'ns3::Ipv4Address', 
+                   [], 
+                   is_const=True)
     ## ipv4-route.h: ns3::Ipv4Mask ns3::Ipv4Route::GetDestNetworkMask() const [member function]
-    cls.add_method('GetDestNetworkMask', 'ns3::Ipv4Mask', [], is_const=True)
+    cls.add_method('GetDestNetworkMask', 
+                   'ns3::Ipv4Mask', 
+                   [], 
+                   is_const=True)
     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4Route::GetGateway() const [member function]
-    cls.add_method('GetGateway', 'ns3::Ipv4Address', [], is_const=True)
+    cls.add_method('GetGateway', 
+                   'ns3::Ipv4Address', 
+                   [], 
+                   is_const=True)
     ## ipv4-route.h: uint32_t ns3::Ipv4Route::GetInterface() const [member function]
-    cls.add_method('GetInterface', 'uint32_t', [], is_const=True)
+    cls.add_method('GetInterface', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## ipv4-route.h: bool ns3::Ipv4Route::IsDefault() const [member function]
-    cls.add_method('IsDefault', 'bool', [], is_const=True)
+    cls.add_method('IsDefault', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## ipv4-route.h: bool ns3::Ipv4Route::IsGateway() const [member function]
-    cls.add_method('IsGateway', 'bool', [], is_const=True)
+    cls.add_method('IsGateway', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## ipv4-route.h: bool ns3::Ipv4Route::IsHost() const [member function]
-    cls.add_method('IsHost', 'bool', [], is_const=True)
+    cls.add_method('IsHost', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## ipv4-route.h: bool ns3::Ipv4Route::IsNetwork() const [member function]
-    cls.add_method('IsNetwork', 'bool', [], is_const=True)
+    cls.add_method('IsNetwork', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     cls.add_output_stream_operator()
     return
 
 def register_Ns3Ipv4MulticastRoute_methods(root_module, cls):
     ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute(ns3::Ipv4MulticastRoute const & route) [copy constructor]
-    cls.add_constructor([param('ns3::Ipv4MulticastRoute&', 'route', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::Ipv4MulticastRoute&', 'route', is_const=True)])
     ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute(ns3::Ipv4MulticastRoute const * route) [constructor]
-    cls.add_constructor([param('ns3::Ipv4MulticastRoute *', 'route', transfer_ownership=False, is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::Ipv4MulticastRoute *', 'route', transfer_ownership=False, is_const=True)])
     ## ipv4-route.h: static ns3::Ipv4MulticastRoute ns3::Ipv4MulticastRoute::CreateMulticastRoute(ns3::Ipv4Address origin, ns3::Ipv4Address group, uint32_t inputInterface, std::vector<unsigned int, std::allocator<unsigned int> > outputInterfaces) [member function]
-    cls.add_method('CreateMulticastRoute', 'ns3::Ipv4MulticastRoute', [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int, std::allocator< unsigned int > >', 'outputInterfaces')], is_static=True)
+    cls.add_method('CreateMulticastRoute', 
+                   'ns3::Ipv4MulticastRoute', 
+                   [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int, std::allocator< unsigned int > >', 'outputInterfaces')], 
+                   is_static=True)
     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4MulticastRoute::GetGroup() const [member function]
-    cls.add_method('GetGroup', 'ns3::Ipv4Address', [], is_const=True)
+    cls.add_method('GetGroup', 
+                   'ns3::Ipv4Address', 
+                   [], 
+                   is_const=True)
     ## ipv4-route.h: uint32_t ns3::Ipv4MulticastRoute::GetInputInterface() const [member function]
-    cls.add_method('GetInputInterface', 'uint32_t', [], is_const=True)
+    cls.add_method('GetInputInterface', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## ipv4-route.h: uint32_t ns3::Ipv4MulticastRoute::GetNOutputInterfaces() const [member function]
-    cls.add_method('GetNOutputInterfaces', 'uint32_t', [], is_const=True)
+    cls.add_method('GetNOutputInterfaces', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4MulticastRoute::GetOrigin() const [member function]
-    cls.add_method('GetOrigin', 'ns3::Ipv4Address', [], is_const=True)
+    cls.add_method('GetOrigin', 
+                   'ns3::Ipv4Address', 
+                   [], 
+                   is_const=True)
     ## ipv4-route.h: uint32_t ns3::Ipv4MulticastRoute::GetOutputInterface(uint32_t n) const [member function]
-    cls.add_method('GetOutputInterface', 'uint32_t', [param('uint32_t', 'n')], is_const=True)
+    cls.add_method('GetOutputInterface', 
+                   'uint32_t', 
+                   [param('uint32_t', 'n')], 
+                   is_const=True)
     ## ipv4-route.h: std::vector<unsigned int, std::allocator<unsigned int> > ns3::Ipv4MulticastRoute::GetOutputInterfaces() const [member function]
-    cls.add_method('GetOutputInterfaces', 'std::vector< unsigned int, std::allocator< unsigned int > >', [], is_const=True)
+    cls.add_method('GetOutputInterfaces', 
+                   'std::vector< unsigned int, std::allocator< unsigned int > >', 
+                   [], 
+                   is_const=True)
     cls.add_output_stream_operator()
     return
 
@@ -385,925 +562,1961 @@
 
 def register_Ns3PacketSocketAddress_methods(root_module, cls):
     ## packet-socket-address.h: ns3::PacketSocketAddress::PacketSocketAddress() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetProtocol(uint16_t protocol) [member function]
-    cls.add_method('SetProtocol', 'void', [param('uint16_t', 'protocol')])
+    cls.add_method('SetProtocol', 
+                   'void', 
+                   [param('uint16_t', 'protocol')])
     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetAllDevices() [member function]
-    cls.add_method('SetAllDevices', 'void', [])
+    cls.add_method('SetAllDevices', 
+                   'void', 
+                   [])
     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetSingleDevice(uint32_t device) [member function]
-    cls.add_method('SetSingleDevice', 'void', [param('uint32_t', 'device')])
+    cls.add_method('SetSingleDevice', 
+                   'void', 
+                   [param('uint32_t', 'device')])
     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetPhysicalAddress(ns3::Address const address) [member function]
-    cls.add_method('SetPhysicalAddress', 'void', [param('ns3::Address', 'address', is_const=True)])
+    cls.add_method('SetPhysicalAddress', 
+                   'void', 
+                   [param('ns3::Address', 'address', is_const=True)])
     ## packet-socket-address.h: uint16_t ns3::PacketSocketAddress::GetProtocol() const [member function]
-    cls.add_method('GetProtocol', 'uint16_t', [], is_const=True)
+    cls.add_method('GetProtocol', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
     ## packet-socket-address.h: uint32_t ns3::PacketSocketAddress::GetSingleDevice() const [member function]
-    cls.add_method('GetSingleDevice', 'uint32_t', [], is_const=True)
+    cls.add_method('GetSingleDevice', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## packet-socket-address.h: bool ns3::PacketSocketAddress::IsSingleDevice() const [member function]
-    cls.add_method('IsSingleDevice', 'bool', [], is_const=True)
+    cls.add_method('IsSingleDevice', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## packet-socket-address.h: ns3::Address ns3::PacketSocketAddress::GetPhysicalAddress() const [member function]
-    cls.add_method('GetPhysicalAddress', 'ns3::Address', [], is_const=True)
+    cls.add_method('GetPhysicalAddress', 
+                   'ns3::Address', 
+                   [], 
+                   is_const=True)
     ## packet-socket-address.h: static ns3::PacketSocketAddress ns3::PacketSocketAddress::ConvertFrom(ns3::Address const & address) [member function]
-    cls.add_method('ConvertFrom', 'ns3::PacketSocketAddress', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
+    cls.add_method('ConvertFrom', 
+                   'ns3::PacketSocketAddress', 
+                   [param('ns3::Address&', 'address', is_const=True)], 
+                   is_static=True)
     ## packet-socket-address.h: static bool ns3::PacketSocketAddress::IsMatchingType(ns3::Address const & address) [member function]
-    cls.add_method('IsMatchingType', 'bool', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
+    cls.add_method('IsMatchingType', 
+                   'bool', 
+                   [param('ns3::Address&', 'address', is_const=True)], 
+                   is_static=True)
     return
 
 def register_Ns3Ipv4Mask_methods(root_module, cls):
     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Ipv4Mask&', 'arg0', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::Ipv4Mask&', 'arg0', is_const=True)])
     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(uint32_t mask) [constructor]
-    cls.add_constructor([param('uint32_t', 'mask')], visibility='public')
+    cls.add_constructor([param('uint32_t', 'mask')])
     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(char const * mask) [constructor]
-    cls.add_constructor([param('char *', 'mask', transfer_ownership=False, is_const=True)], visibility='public')
+    cls.add_constructor([param('char *', 'mask', transfer_ownership=False, is_const=True)])
     ## ipv4-address.h: uint32_t ns3::Ipv4Mask::Get() const [member function]
-    cls.add_method('Get', 'uint32_t', [], is_const=True)
+    cls.add_method('Get', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## ipv4-address.h: uint32_t ns3::Ipv4Mask::GetInverse() const [member function]
-    cls.add_method('GetInverse', 'uint32_t', [], is_const=True)
+    cls.add_method('GetInverse', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetLoopback() [member function]
-    cls.add_method('GetLoopback', 'ns3::Ipv4Mask', [], is_static=True)
+    cls.add_method('GetLoopback', 
+                   'ns3::Ipv4Mask', 
+                   [], 
+                   is_static=True)
     ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetZero() [member function]
-    cls.add_method('GetZero', 'ns3::Ipv4Mask', [], is_static=True)
+    cls.add_method('GetZero', 
+                   'ns3::Ipv4Mask', 
+                   [], 
+                   is_static=True)
     ## ipv4-address.h: bool ns3::Ipv4Mask::IsEqual(ns3::Ipv4Mask other) const [member function]
-    cls.add_method('IsEqual', 'bool', [param('ns3::Ipv4Mask', 'other')], is_const=True)
+    cls.add_method('IsEqual', 
+                   'bool', 
+                   [param('ns3::Ipv4Mask', 'other')], 
+                   is_const=True)
     ## ipv4-address.h: bool ns3::Ipv4Mask::IsMatch(ns3::Ipv4Address a, ns3::Ipv4Address b) const [member function]
-    cls.add_method('IsMatch', 'bool', [param('ns3::Ipv4Address', 'a'), param('ns3::Ipv4Address', 'b')], is_const=True)
+    cls.add_method('IsMatch', 
+                   'bool', 
+                   [param('ns3::Ipv4Address', 'a'), param('ns3::Ipv4Address', 'b')], 
+                   is_const=True)
     ## ipv4-address.h: void ns3::Ipv4Mask::Print(std::ostream & os) const [member function]
-    cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True)
+    cls.add_method('Print', 
+                   'void', 
+                   [param('std::ostream&', 'os')], 
+                   is_const=True)
     ## ipv4-address.h: void ns3::Ipv4Mask::Set(uint32_t mask) [member function]
-    cls.add_method('Set', 'void', [param('uint32_t', 'mask')])
+    cls.add_method('Set', 
+                   'void', 
+                   [param('uint32_t', 'mask')])
     cls.add_output_stream_operator()
     return
 
 def register_Ns3Ipv4AddressValue_methods(root_module, cls):
     ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4Address const & value) [constructor]
-    cls.add_constructor([param('ns3::Ipv4Address&', 'value', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::Ipv4Address&', 'value', is_const=True)])
     ## ipv4-address.h: void ns3::Ipv4AddressValue::Set(ns3::Ipv4Address const & value) [member function]
-    cls.add_method('Set', 'void', [param('ns3::Ipv4Address&', 'value', is_const=True)])
+    cls.add_method('Set', 
+                   'void', 
+                   [param('ns3::Ipv4Address&', 'value', is_const=True)])
     ## ipv4-address.h: ns3::Ipv4Address ns3::Ipv4AddressValue::Get() const [member function]
-    cls.add_method('Get', 'ns3::Ipv4Address', [], is_const=True)
+    cls.add_method('Get', 
+                   'ns3::Ipv4Address', 
+                   [], 
+                   is_const=True)
     ## ipv4-address.h: ns3::Ptr<ns3::AttributeValue> ns3::Ipv4AddressValue::Copy() const [member function]
-    cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## ipv4-address.h: std::string ns3::Ipv4AddressValue::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)
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, is_virtual=True)
     ## ipv4-address.h: bool ns3::Ipv4AddressValue::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)
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_virtual=True)
     return
 
 def register_Ns3Ipv4RoutingProtocol_methods(root_module, cls):
     ## ipv4.h: ns3::Ipv4RoutingProtocol::IF_INDEX_ANY [variable]
     cls.add_static_attribute('IF_INDEX_ANY', retval('uint32_t', is_const=True), is_const=True)
     ## ipv4.h: bool ns3::Ipv4RoutingProtocol::RequestRoute(uint32_t ifIndex, ns3::Ipv4Header const & ipHeader, ns3::Ptr<ns3::Packet> packet, ns3::Callback<void,bool,const ns3::Ipv4Route&,ns3::Ptr<ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty> routeReply) [member function]
-    cls.add_method('RequestRoute', 'bool', [param('uint32_t', 'ifIndex'), param('ns3::Ipv4Header&', 'ipHeader', is_const=True), param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Callback< void, bool, const ns3::Ipv4Route&, ns3::Ptr< ns3::Packet >, const ns3::Ipv4Header&, ns3::empty, ns3::empty >', 'routeReply')], is_pure_virtual=True, is_virtual=True)
+    cls.add_method('RequestRoute', 
+                   'bool', 
+                   [param('uint32_t', 'ifIndex'), param('ns3::Ipv4Header&', 'ipHeader', is_const=True), param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Callback< void, bool, const ns3::Ipv4Route&, ns3::Ptr< ns3::Packet >, const ns3::Ipv4Header&, ns3::empty, ns3::empty >', 'routeReply')], 
+                   is_pure_virtual=True, is_virtual=True)
     ## ipv4.h: bool ns3::Ipv4RoutingProtocol::RequestIfIndex(ns3::Ipv4Address destination, uint32_t & ifIndex) [member function]
-    cls.add_method('RequestIfIndex', 'bool', [param('ns3::Ipv4Address', 'destination'), param('uint32_t&', 'ifIndex')], is_pure_virtual=True, is_virtual=True)
+    cls.add_method('RequestIfIndex', 
+                   'bool', 
+                   [param('ns3::Ipv4Address', 'destination'), param('uint32_t&', 'ifIndex')], 
+                   is_pure_virtual=True, is_virtual=True)
     cls.add_constructor([])
     return
 
 def register_Ns3Mac48AddressValue_methods(root_module, cls):
     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48Address const & value) [constructor]
-    cls.add_constructor([param('ns3::Mac48Address&', 'value', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::Mac48Address&', 'value', is_const=True)])
     ## mac48-address.h: void ns3::Mac48AddressValue::Set(ns3::Mac48Address const & value) [member function]
-    cls.add_method('Set', 'void', [param('ns3::Mac48Address&', 'value', is_const=True)])
+    cls.add_method('Set', 
+                   'void', 
+                   [param('ns3::Mac48Address&', 'value', is_const=True)])
     ## mac48-address.h: ns3::Mac48Address ns3::Mac48AddressValue::Get() const [member function]
-    cls.add_method('Get', 'ns3::Mac48Address', [], is_const=True)
+    cls.add_method('Get', 
+                   'ns3::Mac48Address', 
+                   [], 
+                   is_const=True)
     ## mac48-address.h: ns3::Ptr<ns3::AttributeValue> ns3::Mac48AddressValue::Copy() const [member function]
-    cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## mac48-address.h: std::string ns3::Mac48AddressValue::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)
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, is_virtual=True)
     ## mac48-address.h: bool ns3::Mac48AddressValue::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)
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_virtual=True)
     return
 
 def register_Ns3Ipv4MaskValue_methods(root_module, cls):
     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4Mask const & value) [constructor]
-    cls.add_constructor([param('ns3::Ipv4Mask&', 'value', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::Ipv4Mask&', 'value', is_const=True)])
     ## ipv4-address.h: void ns3::Ipv4MaskValue::Set(ns3::Ipv4Mask const & value) [member function]
-    cls.add_method('Set', 'void', [param('ns3::Ipv4Mask&', 'value', is_const=True)])
+    cls.add_method('Set', 
+                   'void', 
+                   [param('ns3::Ipv4Mask&', 'value', is_const=True)])
     ## ipv4-address.h: ns3::Ipv4Mask ns3::Ipv4MaskValue::Get() const [member function]
-    cls.add_method('Get', 'ns3::Ipv4Mask', [], is_const=True)
+    cls.add_method('Get', 
+                   'ns3::Ipv4Mask', 
+                   [], 
+                   is_const=True)
     ## ipv4-address.h: ns3::Ptr<ns3::AttributeValue> ns3::Ipv4MaskValue::Copy() const [member function]
-    cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
+    cls.add_method('Copy', 
+                   'ns3::Ptr< ns3::AttributeValue >', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## ipv4-address.h: std::string ns3::Ipv4MaskValue::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)
+    cls.add_method('SerializeToString', 
+                   'std::string', 
+                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_const=True, is_virtual=True)
     ## ipv4-address.h: bool ns3::Ipv4MaskValue::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)
+    cls.add_method('DeserializeFromString', 
+                   'bool', 
+                   [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
+                   is_virtual=True)
     return
 
 def register_Ns3SocketAddressTag_methods(root_module, cls):
     ## socket.h: ns3::SocketAddressTag::SocketAddressTag() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## socket.h: void ns3::SocketAddressTag::SetAddress(ns3::Address addr) [member function]
-    cls.add_method('SetAddress', 'void', [param('ns3::Address', 'addr')])
+    cls.add_method('SetAddress', 
+                   'void', 
+                   [param('ns3::Address', 'addr')])
     ## socket.h: ns3::Address ns3::SocketAddressTag::GetAddress() const [member function]
-    cls.add_method('GetAddress', 'ns3::Address', [], is_const=True)
+    cls.add_method('GetAddress', 
+                   'ns3::Address', 
+                   [], 
+                   is_const=True)
     ## socket.h: static ns3::TypeId ns3::SocketAddressTag::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## socket.h: ns3::TypeId ns3::SocketAddressTag::GetInstanceTypeId() const [member function]
-    cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True)
+    cls.add_method('GetInstanceTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## socket.h: uint32_t ns3::SocketAddressTag::GetSerializedSize() const [member function]
-    cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True, is_virtual=True)
+    cls.add_method('GetSerializedSize', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True, is_virtual=True)
     ## socket.h: void ns3::SocketAddressTag::Serialize(ns3::TagBuffer i) const [member function]
-    cls.add_method('Serialize', 'void', [param('ns3::TagBuffer', 'i')], is_const=True, is_virtual=True)
+    cls.add_method('Serialize', 
+                   'void', 
+                   [param('ns3::TagBuffer', 'i')], 
+                   is_const=True, is_virtual=True)
     ## socket.h: void ns3::SocketAddressTag::Deserialize(ns3::TagBuffer i) [member function]
-    cls.add_method('Deserialize', 'void', [param('ns3::TagBuffer', 'i')], is_virtual=True)
+    cls.add_method('Deserialize', 
+                   'void', 
+                   [param('ns3::TagBuffer', 'i')], 
+                   is_virtual=True)
     ## socket.h: void ns3::SocketAddressTag::Print(std::ostream & os) const [member function]
-    cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True, is_virtual=True)
+    cls.add_method('Print', 
+                   'void', 
+                   [param('std::ostream&', 'os')], 
+                   is_const=True, is_virtual=True)
     return
 
 def register_Ns3InetSocketAddress_methods(root_module, cls):
     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(ns3::Ipv4Address ipv4, uint16_t port) [constructor]
-    cls.add_constructor([param('ns3::Ipv4Address', 'ipv4'), param('uint16_t', 'port')], visibility='public')
+    cls.add_constructor([param('ns3::Ipv4Address', 'ipv4'), param('uint16_t', 'port')])
     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(ns3::Ipv4Address ipv4) [constructor]
-    cls.add_constructor([param('ns3::Ipv4Address', 'ipv4')], visibility='public')
+    cls.add_constructor([param('ns3::Ipv4Address', 'ipv4')])
     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(uint16_t port) [constructor]
-    cls.add_constructor([param('uint16_t', 'port')], visibility='public')
+    cls.add_constructor([param('uint16_t', 'port')])
     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(char const * ipv4, uint16_t port) [constructor]
-    cls.add_constructor([param('char *', 'ipv4', transfer_ownership=False, is_const=True), param('uint16_t', 'port')], visibility='public')
+    cls.add_constructor([param('char *', 'ipv4', transfer_ownership=False, is_const=True), param('uint16_t', 'port')])
     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(char const * ipv4) [constructor]
-    cls.add_constructor([param('char *', 'ipv4', transfer_ownership=False, is_const=True)], visibility='public')
+    cls.add_constructor([param('char *', 'ipv4', transfer_ownership=False, is_const=True)])
     ## inet-socket-address.h: uint16_t ns3::InetSocketAddress::GetPort() const [member function]
-    cls.add_method('GetPort', 'uint16_t', [], is_const=True)
+    cls.add_method('GetPort', 
+                   'uint16_t', 
+                   [], 
+                   is_const=True)
     ## inet-socket-address.h: ns3::Ipv4Address ns3::InetSocketAddress::GetIpv4() const [member function]
-    cls.add_method('GetIpv4', 'ns3::Ipv4Address', [], is_const=True)
+    cls.add_method('GetIpv4', 
+                   'ns3::Ipv4Address', 
+                   [], 
+                   is_const=True)
     ## inet-socket-address.h: void ns3::InetSocketAddress::SetPort(uint16_t port) [member function]
-    cls.add_method('SetPort', 'void', [param('uint16_t', 'port')])
+    cls.add_method('SetPort', 
+                   'void', 
+                   [param('uint16_t', 'port')])
     ## inet-socket-address.h: void ns3::InetSocketAddress::SetIpv4(ns3::Ipv4Address address) [member function]
-    cls.add_method('SetIpv4', 'void', [param('ns3::Ipv4Address', 'address')])
+    cls.add_method('SetIpv4', 
+                   'void', 
+                   [param('ns3::Ipv4Address', 'address')])
     ## inet-socket-address.h: static bool ns3::InetSocketAddress::IsMatchingType(ns3::Address const & address) [member function]
-    cls.add_method('IsMatchingType', 'bool', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
+    cls.add_method('IsMatchingType', 
+                   'bool', 
+                   [param('ns3::Address&', 'address', is_const=True)], 
+                   is_static=True)
     ## inet-socket-address.h: static ns3::InetSocketAddress ns3::InetSocketAddress::ConvertFrom(ns3::Address const & address) [member function]
-    cls.add_method('ConvertFrom', 'ns3::InetSocketAddress', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
+    cls.add_method('ConvertFrom', 
+                   'ns3::InetSocketAddress', 
+                   [param('ns3::Address&', 'address', is_const=True)], 
+                   is_static=True)
     return
 
 def register_Ns3Ipv4Address_methods(root_module, cls):
     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Ipv4Address&', 'arg0', is_const=True)], visibility='public')
+    cls.add_constructor([param('ns3::Ipv4Address&', 'arg0', is_const=True)])
     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(uint32_t address) [constructor]
-    cls.add_constructor([param('uint32_t', 'address')], visibility='public')
+    cls.add_constructor([param('uint32_t', 'address')])
     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(char const * address) [constructor]
-    cls.add_constructor([param('char *', 'address', transfer_ownership=False, is_const=True)], visibility='public')
+    cls.add_constructor([param('char *', 'address', transfer_ownership=False, is_const=True)])
     ## ipv4-address.h: ns3::Ipv4Address ns3::Ipv4Address::CombineMask(ns3::Ipv4Mask const & mask) const [member function]
-    cls.add_method('CombineMask', 'ns3::Ipv4Address', [param('ns3::Ipv4Mask&', 'mask', is_const=True)], is_const=True)
+    cls.add_method('CombineMask', 
+                   'ns3::Ipv4Address', 
+                   [param('ns3::Ipv4Mask&', 'mask', is_const=True)], 
+                   is_const=True)
     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::ConvertFrom(ns3::Address const & address) [member function]
-    cls.add_method('ConvertFrom', 'ns3::Ipv4Address', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
+    cls.add_method('ConvertFrom', 
+                   'ns3::Ipv4Address', 
+                   [param('ns3::Address&', 'address', is_const=True)], 
+                   is_static=True)
     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::Deserialize(uint8_t const * buf) [member function]
-    cls.add_method('Deserialize', 'ns3::Ipv4Address', [param('uint8_t *', 'buf', transfer_ownership=False, is_const=True)], is_static=True)
+    cls.add_method('Deserialize', 
+                   'ns3::Ipv4Address', 
+                   [param('uint8_t *', 'buf', transfer_ownership=False, is_const=True)], 
+                   is_static=True)
     ## ipv4-address.h: uint32_t ns3::Ipv4Address::Get() const [member function]
-    cls.add_method('Get', 'uint32_t', [], is_const=True)
+    cls.add_method('Get', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetAny() [member function]
-    cls.add_method('GetAny', 'ns3::Ipv4Address', [], is_static=True)
+    cls.add_method('GetAny', 
+                   'ns3::Ipv4Address', 
+                   [], 
+                   is_static=True)
     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetBroadcast() [member function]
-    cls.add_method('GetBroadcast', 'ns3::Ipv4Address', [], is_static=True)
+    cls.add_method('GetBroadcast', 
+                   'ns3::Ipv4Address', 
+                   [], 
+                   is_static=True)
     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetLoopback() [member function]
-    cls.add_method('GetLoopback', 'ns3::Ipv4Address', [], is_static=True)
+    cls.add_method('GetLoopback', 
+                   'ns3::Ipv4Address', 
+                   [], 
+                   is_static=True)
     ## ipv4-address.h: ns3::Ipv4Address ns3::Ipv4Address::GetSubnetDirectedBroadcast(ns3::Ipv4Mask const & mask) const [member function]
-    cls.add_method('GetSubnetDirectedBroadcast', 'ns3::Ipv4Address', [param('ns3::Ipv4Mask&', 'mask', is_const=True)], is_const=True)
+    cls.add_method('GetSubnetDirectedBroadcast', 
+                   'ns3::Ipv4Address', 
+                   [param('ns3::Ipv4Mask&', 'mask', is_const=True)], 
+                   is_const=True)
     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetZero() [member function]
-    cls.add_method('GetZero', 'ns3::Ipv4Address', [], is_static=True)
+    cls.add_method('GetZero', 
+                   'ns3::Ipv4Address', 
+                   [], 
+                   is_static=True)
     ## ipv4-address.h: bool ns3::Ipv4Address::IsBroadcast() const [member function]
-    cls.add_method('IsBroadcast', 'bool', [], is_const=True)
+    cls.add_method('IsBroadcast', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## ipv4-address.h: bool ns3::Ipv4Address::IsEqual(ns3::Ipv4Address const & other) const [member function]
-    cls.add_method('IsEqual', 'bool', [param('ns3::Ipv4Address&', 'other', is_const=True)], is_const=True)
+    cls.add_method('IsEqual', 
+                   'bool', 
+                   [param('ns3::Ipv4Address&', 'other', is_const=True)], 
+                   is_const=True)
     ## ipv4-address.h: static bool ns3::Ipv4Address::IsMatchingType(ns3::Address const & address) [member function]
-    cls.add_method('IsMatchingType', 'bool', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
+    cls.add_method('IsMatchingType', 
+                   'bool', 
+                   [param('ns3::Address&', 'address', is_const=True)], 
+                   is_static=True)
     ## ipv4-address.h: bool ns3::Ipv4Address::IsMulticast() const [member function]
-    cls.add_method('IsMulticast', 'bool', [], is_const=True)
+    cls.add_method('IsMulticast', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## ipv4-address.h: bool ns3::Ipv4Address::IsSubnetDirectedBroadcast(ns3::Ipv4Mask const & mask) const [member function]
-    cls.add_method('IsSubnetDirectedBroadcast', 'bool', [param('ns3::Ipv4Mask&', 'mask', is_const=True)], is_const=True)
+    cls.add_method('IsSubnetDirectedBroadcast', 
+                   'bool', 
+                   [param('ns3::Ipv4Mask&', 'mask', is_const=True)], 
+                   is_const=True)
     ## ipv4-address.h: void ns3::Ipv4Address::Print(std::ostream & os) const [member function]
-    cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True)
+    cls.add_method('Print', 
+                   'void', 
+                   [param('std::ostream&', 'os')], 
+                   is_const=True)
     ## ipv4-address.h: void ns3::Ipv4Address::Serialize(uint8_t * buf) const [member function]
-    cls.add_method('Serialize', 'void', [param('uint8_t *', 'buf')], is_const=True)
+    cls.add_method('Serialize', 
+                   'void', 
+                   [param('uint8_t *', 'buf')], 
+                   is_const=True)
     ## ipv4-address.h: void ns3::Ipv4Address::Set(uint32_t address) [member function]
-    cls.add_method('Set', 'void', [param('uint32_t', 'address')])
+    cls.add_method('Set', 
+                   'void', 
+                   [param('uint32_t', 'address')])
     ## ipv4-address.h: void ns3::Ipv4Address::Set(char const * address) [member function]
-    cls.add_method('Set', 'void', [param('char *', 'address', transfer_ownership=False, is_const=True)])
+    cls.add_method('Set', 
+                   'void', 
+                   [param('char *', 'address', transfer_ownership=False, is_const=True)])
     cls.add_output_stream_operator()
     return
 
 def register_Ns3Application_methods(root_module, cls):
     ## application.h: static ns3::TypeId ns3::Application::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## application.h: ns3::Application::Application() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## application.h: void ns3::Application::Start(ns3::Time const & startTime) [member function]
-    cls.add_method('Start', 'void', [param('ns3::Time&', 'startTime', is_const=True)])
+    cls.add_method('Start', 
+                   'void', 
+                   [param('ns3::Time&', 'startTime', is_const=True)])
     ## application.h: void ns3::Application::Start(ns3::RandomVariable const & startVariable) [member function]
-    cls.add_method('Start', 'void', [param('ns3::RandomVariable&', 'startVariable', is_const=True)])
+    cls.add_method('Start', 
+                   'void', 
+                   [param('ns3::RandomVariable&', 'startVariable', is_const=True)])
     ## application.h: void ns3::Application::Stop(ns3::Time const & stopTime) [member function]
-    cls.add_method('Stop', 'void', [param('ns3::Time&', 'stopTime', is_const=True)])
+    cls.add_method('Stop', 
+                   'void', 
+                   [param('ns3::Time&', 'stopTime', is_const=True)])
     ## application.h: void ns3::Application::Stop(ns3::RandomVariable const & stopVariable) [member function]
-    cls.add_method('Stop', 'void', [param('ns3::RandomVariable&', 'stopVariable', is_const=True)])
+    cls.add_method('Stop', 
+                   'void', 
+                   [param('ns3::RandomVariable&', 'stopVariable', is_const=True)])
     ## application.h: ns3::Ptr<ns3::Node> ns3::Application::GetNode() const [member function]
-    cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', [], is_const=True)
+    cls.add_method('GetNode', 
+                   'ns3::Ptr< ns3::Node >', 
+                   [], 
+                   is_const=True)
     ## application.h: void ns3::Application::SetNode(ns3::Ptr<ns3::Node> node) [member function]
-    cls.add_method('SetNode', 'void', [param('ns3::Ptr< ns3::Node >', 'node')])
+    cls.add_method('SetNode', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Node >', 'node')])
     ## application.h: void ns3::Application::DoDispose() [member function]
-    cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True)
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
     ## application.h: void ns3::Application::StartApplication() [member function]
-    cls.add_method('StartApplication', 'void', [], visibility='private', is_virtual=True)
+    cls.add_method('StartApplication', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
     ## application.h: void ns3::Application::StopApplication() [member function]
-    cls.add_method('StopApplication', 'void', [], visibility='private', is_virtual=True)
+    cls.add_method('StopApplication', 
+                   'void', 
+                   [], 
+                   visibility='private', is_virtual=True)
     return
 
 def register_Ns3Queue_methods(root_module, cls):
     ## queue.h: static ns3::TypeId ns3::Queue::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
     ## queue.h: ns3::Queue::Queue() [constructor]
-    cls.add_constructor([], visibility='public')
+    cls.add_constructor([])
     ## queue.h: bool ns3::Queue::IsEmpty() const [member function]
-    cls.add_method('IsEmpty', 'bool', [], is_const=True)
+    cls.add_method('IsEmpty', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## queue.h: bool ns3::Queue::Enqueue(ns3::Ptr<ns3::Packet> p) [member function]
-    cls.add_method('Enqueue', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p')])
+    cls.add_method('Enqueue', 
+                   'bool', 
+                   [param('ns3::Ptr< ns3::Packet >', 'p')])
     ## queue.h: ns3::Ptr<ns3::Packet> ns3::Queue::Dequeue() [member function]
-    cls.add_method('Dequeue', 'ns3::Ptr< ns3::Packet >', [])
+    cls.add_method('Dequeue', 
+                   'ns3::Ptr< ns3::Packet >', 
+                   [])
     ## queue.h: ns3::Ptr<ns3::Packet> ns3::Queue::Peek() const [member function]
-    cls.add_method('Peek', 'ns3::Ptr< ns3::Packet >', [], is_const=True)
+    cls.add_method('Peek', 
+                   'ns3::Ptr< ns3::Packet >', 
+                   [], 
+                   is_const=True)
     ## queue.h: void ns3::Queue::DequeueAll() [member function]
-    cls.add_method('DequeueAll', 'void', [])
+    cls.add_method('DequeueAll', 
+                   'void', 
+                   [])
     ## queue.h: uint32_t ns3::Queue::GetNPackets() const [member function]
-    cls.add_method('GetNPackets', 'uint32_t', [], is_const=True)
+    cls.add_method('GetNPackets', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## queue.h: uint32_t ns3::Queue::GetNBytes() const [member function]
-    cls.add_method('GetNBytes', 'uint32_t', [], is_const=True)
+    cls.add_method('GetNBytes', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## queue.h: uint32_t ns3::Queue::GetTotalReceivedBytes() const [member function]
-    cls.add_method('GetTotalReceivedBytes', 'uint32_t', [], is_const=True)
+    cls.add_method('GetTotalReceivedBytes', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## queue.h: uint32_t ns3::Queue::GetTotalReceivedPackets() const [member function]
-    cls.add_method('GetTotalReceivedPackets', 'uint32_t', [], is_const=True)
+    cls.add_method('GetTotalReceivedPackets', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## queue.h: uint32_t ns3::Queue::GetTotalDroppedBytes() const [member function]
-    cls.add_method('GetTotalDroppedBytes', 'uint32_t', [], is_const=True)
+    cls.add_method('GetTotalDroppedBytes', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## queue.h: uint32_t ns3::Queue::GetTotalDroppedPackets() const [member function]
-    cls.add_method('GetTotalDroppedPackets', 'uint32_t', [], is_const=True)
+    cls.add_method('GetTotalDroppedPackets', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
     ## queue.h: void ns3::Queue::ResetStatistics() [member function]
-    cls.add_method('ResetStatistics', 'void', [])
+    cls.add_method('ResetStatistics', 
+                   'void', 
+                   [])
     ## queue.h: void ns3::Queue::Drop(ns3::Ptr<ns3::Packet> packet) [member function]
-    cls.add_method('Drop', 'void', [param('ns3::Ptr< ns3::Packet >', 'packet')], visibility='protected')
+    cls.add_method('Drop', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Packet >', 'packet')], 
+                   visibility='protected')
     ## queue.h: bool ns3::Queue::DoEnqueue(ns3::Ptr<ns3::Packet> p) [member function]
-    cls.add_method('DoEnqueue', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p')], is_pure_virtual=True, visibility='private', is_virtual=True)
+    cls.add_method('DoEnqueue', 
+                   'bool', 
+                   [param('ns3::Ptr< ns3::Packet >', 'p')], 
+                   is_pure_virtual