New pybindgen and API rescan. Extensive API description files changes because pybindgen now handles consts differently.
authorGustavo J. A. M. Carneiro <gjc@inescporto.pt>
Tue, 02 Sep 2008 11:12:42 +0100
changeset 3574 b6804efbe16b
parent 3573 352cfe96e593
child 3575 1f5d9b97a1a2
New pybindgen and API rescan. Extensive API description files changes because pybindgen now handles consts differently.
bindings/python/ns3_module_bridge.py
bindings/python/ns3_module_common.py
bindings/python/ns3_module_contrib.py
bindings/python/ns3_module_core.py
bindings/python/ns3_module_csma.py
bindings/python/ns3_module_global_routing.py
bindings/python/ns3_module_helper.py
bindings/python/ns3_module_internet_stack.py
bindings/python/ns3_module_mobility.py
bindings/python/ns3_module_node.py
bindings/python/ns3_module_olsr.py
bindings/python/ns3_module_onoff.py
bindings/python/ns3_module_packet_sink.py
bindings/python/ns3_module_point_to_point.py
bindings/python/ns3_module_simulator.py
bindings/python/ns3_module_stats.py
bindings/python/ns3_module_udp_echo.py
bindings/python/ns3_module_wifi.py
bindings/python/ns3modulegen_core_customizations.py
bindings/python/ns3modulegen_generated.py
bindings/python/wscript
--- a/bindings/python/ns3_module_bridge.py	Sun Aug 31 22:33:23 2008 +0100
+++ b/bindings/python/ns3_module_bridge.py	Tue Sep 02 11:12:42 2008 +0100
@@ -55,7 +55,7 @@
 
 def register_Ns3BridgeNetDevice_methods(root_module, cls):
     ## bridge-net-device.h: ns3::BridgeNetDevice::BridgeNetDevice(ns3::BridgeNetDevice const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::BridgeNetDevice&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::BridgeNetDevice const &', 'arg0')])
     ## bridge-net-device.h: static ns3::TypeId ns3::BridgeNetDevice::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -70,7 +70,7 @@
     ## 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)], 
+                   [param('std::string const', 'name')], 
                    is_virtual=True)
     ## bridge-net-device.h: std::string ns3::BridgeNetDevice::GetName() const [member function]
     cls.add_method('GetName', 
@@ -80,7 +80,7 @@
     ## 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)], 
+                   [param('uint32_t const', 'index')], 
                    is_virtual=True)
     ## bridge-net-device.h: uint32_t ns3::BridgeNetDevice::GetIfIndex() const [member function]
     cls.add_method('GetIfIndex', 
@@ -100,7 +100,7 @@
     ## 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)], 
+                   [param('uint16_t const', 'mtu')], 
                    is_virtual=True)
     ## bridge-net-device.h: uint16_t ns3::BridgeNetDevice::GetMtu() const [member function]
     cls.add_method('GetMtu', 
@@ -150,12 +150,12 @@
     ## 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')], 
+                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'dest'), 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')], 
+                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'source'), param('ns3::Address const &', 'dest'), 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', 
@@ -195,7 +195,7 @@
     ## bridge-net-device.h: void ns3::BridgeNetDevice::ReceiveFromDevice(ns3::Ptr<ns3::NetDevice> device, ns3::Ptr<const 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< const 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')], 
+                   [param('ns3::Ptr< ns3::NetDevice >', 'device'), param('ns3::Ptr< const ns3::Packet >', 'packet'), param('uint16_t', 'protocol'), param('ns3::Address const &', 'source'), param('ns3::Address const &', 'destination'), param('ns3::NetDevice::PacketType', 'packetType')], 
                    visibility='protected')
     ## bridge-net-device.h: void ns3::BridgeNetDevice::ForwardUnicast(ns3::Ptr<ns3::NetDevice> incomingPort, ns3::Ptr<const ns3::Packet> packet, uint16_t protocol, ns3::Mac48Address src, ns3::Mac48Address dst) [member function]
     cls.add_method('ForwardUnicast', 
@@ -221,7 +221,7 @@
 
 def register_Ns3BridgeChannel_methods(root_module, cls):
     ## bridge-channel.h: ns3::BridgeChannel::BridgeChannel(ns3::BridgeChannel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::BridgeChannel&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::BridgeChannel const &', 'arg0')])
     ## bridge-channel.h: static ns3::TypeId ns3::BridgeChannel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
--- a/bindings/python/ns3_module_common.py	Sun Aug 31 22:33:23 2008 +0100
+++ b/bindings/python/ns3_module_common.py	Tue Sep 02 11:12:42 2008 +0100
@@ -113,11 +113,11 @@
     ## packet.h: ns3::Packet::Packet() [constructor]
     cls.add_constructor([])
     ## packet.h: ns3::Packet::Packet(ns3::Packet const & o) [copy constructor]
-    cls.add_constructor([param('ns3::Packet&', 'o', is_const=True)])
+    cls.add_constructor([param('ns3::Packet const &', 'o')])
     ## packet.h: ns3::Packet::Packet(uint32_t size) [constructor]
     cls.add_constructor([param('uint32_t', 'size')])
     ## packet.h: ns3::Packet::Packet(uint8_t const * buffer, uint32_t size) [constructor]
-    cls.add_constructor([param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint32_t', 'size')])
+    cls.add_constructor([param('uint8_t const *', 'buffer'), param('uint32_t', 'size')])
     ## packet.h: void ns3::Packet::AddAtEnd(ns3::Ptr<const ns3::Packet> packet) [member function]
     cls.add_method('AddAtEnd', 
                    'void', 
@@ -125,7 +125,7 @@
     ## packet.h: void ns3::Packet::AddHeader(ns3::Header const & header) [member function]
     cls.add_method('AddHeader', 
                    'void', 
-                   [param('ns3::Header&', 'header', is_const=True)])
+                   [param('ns3::Header const &', 'header')])
     ## packet.h: void ns3::Packet::AddPaddingAtEnd(uint32_t size) [member function]
     cls.add_method('AddPaddingAtEnd', 
                    'void', 
@@ -133,12 +133,12 @@
     ## 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)], 
+                   [param('ns3::Tag const &', 'tag')], 
                    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)])
+                   [param('ns3::Trailer const &', 'trailer')])
     ## packet.h: ns3::PacketMetadata::ItemIterator ns3::Packet::BeginItem() const [member function]
     cls.add_method('BeginItem', 
                    'ns3::PacketMetadata::ItemIterator', 
@@ -176,7 +176,7 @@
     ## packet.h: bool ns3::Packet::FindFirstMatchingTag(ns3::Tag & tag) const [member function]
     cls.add_method('FindFirstMatchingTag', 
                    'bool', 
-                   [param('ns3::Tag&', 'tag')], 
+                   [param('ns3::Tag &', 'tag')], 
                    is_const=True)
     ## packet.h: uint32_t ns3::Packet::GetSize() const [member function]
     cls.add_method('GetSize', 
@@ -195,26 +195,26 @@
                    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), 
+                   'uint8_t const *', 
                    [], 
                    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')])
+                   [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')])
+                   [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')], 
+                   [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')], 
+                   [param('std::ostream &', 'os')], 
                    is_const=True)
     ## packet.h: void ns3::Packet::RemoveAllTags() [member function]
     cls.add_method('RemoveAllTags', 
@@ -231,11 +231,11 @@
     ## packet.h: uint32_t ns3::Packet::RemoveHeader(ns3::Header & header) [member function]
     cls.add_method('RemoveHeader', 
                    'uint32_t', 
-                   [param('ns3::Header&', 'header')])
+                   [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')])
+                   [param('ns3::Trailer &', 'trailer')])
     ## packet.h: ns3::Buffer ns3::Packet::Serialize() const [member function]
     cls.add_method('Serialize', 
                    'ns3::Buffer', 
@@ -246,7 +246,7 @@
 
 def register_Ns3TagIterator_methods(root_module, cls):
     ## packet.h: ns3::TagIterator::TagIterator(ns3::TagIterator const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::TagIterator&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::TagIterator const &', 'arg0')])
     ## packet.h: bool ns3::TagIterator::HasNext() const [member function]
     cls.add_method('HasNext', 
                    'bool', 
@@ -260,7 +260,7 @@
 
 def register_Ns3TagIteratorItem_methods(root_module, cls):
     ## packet.h: ns3::TagIterator::Item::Item(ns3::TagIterator::Item const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::TagIterator::Item&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::TagIterator::Item const &', 'arg0')])
     ## packet.h: ns3::TypeId ns3::TagIterator::Item::GetTypeId() const [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -279,7 +279,7 @@
     ## packet.h: void ns3::TagIterator::Item::GetTag(ns3::Tag & tag) const [member function]
     cls.add_method('GetTag', 
                    'void', 
-                   [param('ns3::Tag&', 'tag')], 
+                   [param('ns3::Tag &', 'tag')], 
                    is_const=True)
     return
 
@@ -287,7 +287,7 @@
     ## tag-list.h: ns3::TagList::TagList() [constructor]
     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)])
+    cls.add_constructor([param('ns3::TagList const &', 'o')])
     ## 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', 
@@ -295,7 +295,7 @@
     ## 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)])
+                   [param('ns3::TagList const &', 'o')])
     ## tag-list.h: void ns3::TagList::RemoveAll() [member function]
     cls.add_method('RemoveAll', 
                    'void', 
@@ -317,7 +317,7 @@
 
 def register_Ns3TagListIterator_methods(root_module, cls):
     ## tag-list.h: ns3::TagList::Iterator::Iterator(ns3::TagList::Iterator const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::TagList::Iterator&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::TagList::Iterator const &', 'arg0')])
     ## tag-list.h: bool ns3::TagList::Iterator::HasNext() const [member function]
     cls.add_method('HasNext', 
                    'bool', 
@@ -346,14 +346,14 @@
     ## 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::TagList::Iterator::Item const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::TagList::Iterator::Item&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::TagList::Iterator::Item const &', 'arg0')])
     ## tag-list.h: ns3::TagList::Iterator::Item::Item(ns3::TagBuffer buf) [constructor]
     cls.add_constructor([param('ns3::TagBuffer', 'buf')])
     return
 
 def register_Ns3TagBuffer_methods(root_module, cls):
     ## tag-buffer.h: ns3::TagBuffer::TagBuffer(ns3::TagBuffer const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::TagBuffer&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::TagBuffer const &', 'arg0')])
     ## tag-buffer.h: ns3::TagBuffer::TagBuffer(uint8_t * start, uint8_t * end) [constructor]
     cls.add_constructor([param('uint8_t *', 'start'), param('uint8_t *', 'end')])
     ## tag-buffer.h: void ns3::TagBuffer::TrimAtEnd(uint32_t trim) [member function]
@@ -387,7 +387,7 @@
     ## 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')])
+                   [param('uint8_t const *', 'buffer'), param('uint32_t', 'size')])
     ## tag-buffer.h: uint8_t ns3::TagBuffer::ReadU8() [member function]
     cls.add_method('ReadU8', 
                    'uint8_t', 
@@ -422,7 +422,7 @@
                    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), 
+                   'uint8_t const *', 
                    [], 
                    is_const=True)
     ## buffer.h: bool ns3::Buffer::AddAtStart(uint32_t start) [member function]
@@ -436,7 +436,7 @@
     ## buffer.h: void ns3::Buffer::AddAtEnd(ns3::Buffer const & o) [member function]
     cls.add_method('AddAtEnd', 
                    'void', 
-                   [param('ns3::Buffer&', 'o', is_const=True)])
+                   [param('ns3::Buffer const &', 'o')])
     ## buffer.h: void ns3::Buffer::RemoveAtStart(uint32_t start) [member function]
     cls.add_method('RemoveAtStart', 
                    'void', 
@@ -476,7 +476,7 @@
                    [], 
                    is_const=True)
     ## buffer.h: ns3::Buffer::Buffer(ns3::Buffer const & o) [copy constructor]
-    cls.add_constructor([param('ns3::Buffer&', 'o', is_const=True)])
+    cls.add_constructor([param('ns3::Buffer const &', 'o')])
     ## buffer.h: ns3::Buffer::Buffer() [constructor]
     cls.add_constructor([])
     ## buffer.h: ns3::Buffer::Buffer(uint32_t dataSize) [constructor]
@@ -485,7 +485,7 @@
 
 def register_Ns3BufferIterator_methods(root_module, cls):
     ## buffer.h: ns3::Buffer::Iterator::Iterator(ns3::Buffer::Iterator const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Buffer::Iterator&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Buffer::Iterator const &', 'arg0')])
     ## buffer.h: ns3::Buffer::Iterator::Iterator() [constructor]
     cls.add_constructor([])
     ## buffer.h: void ns3::Buffer::Iterator::Next() [member function]
@@ -507,7 +507,7 @@
     ## 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)], 
+                   [param('ns3::Buffer::Iterator const &', 'o')], 
                    is_const=True)
     ## buffer.h: bool ns3::Buffer::Iterator::IsEnd() const [member function]
     cls.add_method('IsEnd', 
@@ -566,7 +566,7 @@
     ## 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')])
+                   [param('uint8_t const *', 'buffer'), 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', 
@@ -632,7 +632,7 @@
 
 def register_Ns3Chunk_methods(root_module, cls):
     ## chunk.h: ns3::Chunk::Chunk(ns3::Chunk const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Chunk&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Chunk const &', 'arg0')])
     ## chunk.h: ns3::Chunk::Chunk() [constructor]
     cls.add_constructor([])
     ## chunk.h: static ns3::TypeId ns3::Chunk::GetTypeId() [member function]
@@ -648,13 +648,13 @@
     ## chunk.h: void ns3::Chunk::Print(std::ostream & os) const [member function]
     cls.add_method('Print', 
                    'void', 
-                   [param('std::ostream&', 'os')], 
+                   [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)])
+    cls.add_constructor([param('ns3::DataRate const &', 'arg0')])
     ## data-rate.h: ns3::DataRate::DataRate() [constructor]
     cls.add_constructor([])
     ## data-rate.h: ns3::DataRate::DataRate(uint64_t bps) [constructor]
@@ -676,7 +676,7 @@
 
 def register_Ns3Tag_methods(root_module, cls):
     ## tag.h: ns3::Tag::Tag(ns3::Tag const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Tag&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Tag const &', 'arg0')])
     ## tag.h: ns3::Tag::Tag() [constructor]
     cls.add_constructor([])
     ## tag.h: static ns3::TypeId ns3::Tag::GetTypeId() [member function]
@@ -702,19 +702,19 @@
     ## tag.h: void ns3::Tag::Print(std::ostream & os) const [member function]
     cls.add_method('Print', 
                    'void', 
-                   [param('std::ostream&', 'os')], 
+                   [param('std::ostream &', 'os')], 
                    is_pure_virtual=True, is_const=True, is_virtual=True)
     return
 
 def register_Ns3PcapWriter_methods(root_module, cls):
     ## pcap-writer.h: ns3::PcapWriter::PcapWriter(ns3::PcapWriter const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::PcapWriter&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::PcapWriter const &', 'arg0')])
     ## pcap-writer.h: ns3::PcapWriter::PcapWriter() [constructor]
     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)])
+                   [param('std::string const &', 'name')])
     ## pcap-writer.h: void ns3::PcapWriter::WriteEthernetHeader() [member function]
     cls.add_method('WriteEthernetHeader', 
                    'void', 
@@ -739,14 +739,14 @@
 
 def register_Ns3DataRateChecker_methods(root_module, cls):
     ## data-rate.h: ns3::DataRateChecker::DataRateChecker(ns3::DataRateChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::DataRateChecker&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::DataRateChecker const &', 'arg0')])
     ## data-rate.h: ns3::DataRateChecker::DataRateChecker() [constructor]
     cls.add_constructor([])
     return
 
 def register_Ns3ErrorModel_methods(root_module, cls):
     ## error-model.h: ns3::ErrorModel::ErrorModel(ns3::ErrorModel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::ErrorModel&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::ErrorModel const &', 'arg0')])
     ## error-model.h: static ns3::TypeId ns3::ErrorModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -791,7 +791,7 @@
     ## header.h: ns3::Header::Header() [constructor]
     cls.add_constructor([])
     ## header.h: ns3::Header::Header(ns3::Header const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Header&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Header const &', 'arg0')])
     ## header.h: uint32_t ns3::Header::Deserialize(ns3::Buffer::Iterator start) [member function]
     cls.add_method('Deserialize', 
                    'uint32_t', 
@@ -810,7 +810,7 @@
     ## header.h: void ns3::Header::Print(std::ostream & os) const [member function]
     cls.add_method('Print', 
                    'void', 
-                   [param('std::ostream&', 'os')], 
+                   [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', 
@@ -824,7 +824,7 @@
     ## trailer.h: ns3::Trailer::Trailer() [constructor]
     cls.add_constructor([])
     ## trailer.h: ns3::Trailer::Trailer(ns3::Trailer const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Trailer&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Trailer const &', 'arg0')])
     ## trailer.h: uint32_t ns3::Trailer::Deserialize(ns3::Buffer::Iterator end) [member function]
     cls.add_method('Deserialize', 
                    'uint32_t', 
@@ -843,7 +843,7 @@
     ## trailer.h: void ns3::Trailer::Print(std::ostream & os) const [member function]
     cls.add_method('Print', 
                    'void', 
-                   [param('std::ostream&', 'os')], 
+                   [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', 
@@ -855,7 +855,7 @@
 
 def register_Ns3ListErrorModel_methods(root_module, cls):
     ## error-model.h: ns3::ListErrorModel::ListErrorModel(ns3::ListErrorModel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::ListErrorModel&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::ListErrorModel const &', 'arg0')])
     ## error-model.h: static ns3::TypeId ns3::ListErrorModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -871,7 +871,7 @@
     ## 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 >&', 'packetlist', is_const=True)])
+                   [param('std::list< unsigned int >', 'packetlist')])
     ## error-model.h: bool ns3::ListErrorModel::DoCorrupt(ns3::Ptr<ns3::Packet> p) [member function]
     cls.add_method('DoCorrupt', 
                    'bool', 
@@ -886,15 +886,15 @@
 
 def register_Ns3DataRateValue_methods(root_module, cls):
     ## data-rate.h: ns3::DataRateValue::DataRateValue(ns3::DataRateValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::DataRateValue&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::DataRateValue const &', 'arg0')])
     ## data-rate.h: ns3::DataRateValue::DataRateValue() [constructor]
     cls.add_constructor([])
     ## data-rate.h: ns3::DataRateValue::DataRateValue(ns3::DataRate const & value) [constructor]
-    cls.add_constructor([param('ns3::DataRate&', 'value', is_const=True)])
+    cls.add_constructor([param('ns3::DataRate const &', 'value')])
     ## 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)])
+                   [param('ns3::DataRate const &', 'value')])
     ## data-rate.h: ns3::DataRate ns3::DataRateValue::Get() const [member function]
     cls.add_method('Get', 
                    'ns3::DataRate', 
@@ -919,7 +919,7 @@
 
 def register_Ns3RateErrorModel_methods(root_module, cls):
     ## error-model.h: ns3::RateErrorModel::RateErrorModel(ns3::RateErrorModel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::RateErrorModel&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::RateErrorModel const &', 'arg0')])
     ## error-model.h: static ns3::TypeId ns3::RateErrorModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -948,7 +948,7 @@
     ## 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)])
+                   [param('ns3::RandomVariable const &', 'ranvar')])
     ## error-model.h: bool ns3::RateErrorModel::DoCorrupt(ns3::Ptr<ns3::Packet> p) [member function]
     cls.add_method('DoCorrupt', 
                    'bool', 
--- a/bindings/python/ns3_module_contrib.py	Sun Aug 31 22:33:23 2008 +0100
+++ b/bindings/python/ns3_module_contrib.py	Tue Sep 02 11:12:42 2008 +0100
@@ -71,7 +71,7 @@
 
 def register_Ns3Gnuplot_methods(root_module, cls):
     ## gnuplot.h: ns3::Gnuplot::Gnuplot(ns3::Gnuplot const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Gnuplot&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Gnuplot const &', 'arg0')])
     ## gnuplot.h: ns3::Gnuplot::Gnuplot(std::string pngFilename) [constructor]
     cls.add_constructor([param('std::string', 'pngFilename')])
     ## gnuplot.h: void ns3::Gnuplot::SetLegend(std::string xLegend, std::string yLegend) [member function]
@@ -81,16 +81,16 @@
     ## gnuplot.h: void ns3::Gnuplot::AddDataset(ns3::GnuplotDataset const & dataset) [member function]
     cls.add_method('AddDataset', 
                    'void', 
-                   [param('ns3::GnuplotDataset&', 'dataset', is_const=True)])
+                   [param('ns3::GnuplotDataset const &', 'dataset')])
     ## gnuplot.h: void ns3::Gnuplot::GenerateOutput(std::ostream & os) [member function]
     cls.add_method('GenerateOutput', 
                    'void', 
-                   [param('std::ostream&', 'os')])
+                   [param('std::ostream &', 'os')])
     return
 
 def register_Ns3EventGarbageCollector_methods(root_module, cls):
     ## event-garbage-collector.h: ns3::EventGarbageCollector::EventGarbageCollector(ns3::EventGarbageCollector const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::EventGarbageCollector&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::EventGarbageCollector const &', 'arg0')])
     ## event-garbage-collector.h: ns3::EventGarbageCollector::EventGarbageCollector() [constructor]
     cls.add_constructor([])
     ## event-garbage-collector.h: void ns3::EventGarbageCollector::Track(ns3::EventId event) [member function]
@@ -101,7 +101,7 @@
 
 def register_Ns3GnuplotDataset_methods(root_module, cls):
     ## gnuplot.h: ns3::GnuplotDataset::GnuplotDataset(ns3::GnuplotDataset const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::GnuplotDataset&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::GnuplotDataset const &', 'arg0')])
     ## gnuplot.h: ns3::GnuplotDataset::GnuplotDataset() [constructor]
     cls.add_constructor([])
     ## gnuplot.h: ns3::GnuplotDataset::GnuplotDataset(std::string title) [constructor]
@@ -126,7 +126,7 @@
 
 def register_Ns3GtkConfigStore_methods(root_module, cls):
     ## gtk-config-store.h: ns3::GtkConfigStore::GtkConfigStore(ns3::GtkConfigStore const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::GtkConfigStore&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::GtkConfigStore const &', 'arg0')])
     ## gtk-config-store.h: ns3::GtkConfigStore::GtkConfigStore() [constructor]
     cls.add_constructor([])
     ## gtk-config-store.h: void ns3::GtkConfigStore::Configure() [member function]
@@ -137,7 +137,7 @@
 
 def register_Ns3ConfigStore_methods(root_module, cls):
     ## config-store.h: ns3::ConfigStore::ConfigStore(ns3::ConfigStore const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::ConfigStore&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::ConfigStore const &', 'arg0')])
     ## config-store.h: static ns3::TypeId ns3::ConfigStore::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -158,7 +158,7 @@
 
 def register_Ns3DelayJitterEstimation_methods(root_module, cls):
     ## delay-jitter-estimation.h: ns3::DelayJitterEstimation::DelayJitterEstimation(ns3::DelayJitterEstimation const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::DelayJitterEstimation&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::DelayJitterEstimation const &', 'arg0')])
     ## delay-jitter-estimation.h: ns3::DelayJitterEstimation::DelayJitterEstimation() [constructor]
     cls.add_constructor([])
     ## delay-jitter-estimation.h: static void ns3::DelayJitterEstimation::PrepareTx(ns3::Ptr<const ns3::Packet> packet) [member function]
--- a/bindings/python/ns3_module_core.py	Sun Aug 31 22:33:23 2008 +0100
+++ b/bindings/python/ns3_module_core.py	Tue Sep 02 11:12:42 2008 +0100
@@ -272,7 +272,7 @@
     ## random-variable.h: ns3::RandomVariable::RandomVariable() [constructor]
     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)])
+    cls.add_constructor([param('ns3::RandomVariable const &', 'o')])
     ## random-variable.h: uint32_t ns3::RandomVariable::GetInteger() const [member function]
     cls.add_method('GetInteger', 
                    'uint32_t', 
@@ -308,7 +308,7 @@
 
 def register_Ns3TriangularVariable_methods(root_module, cls):
     ## random-variable.h: ns3::TriangularVariable::TriangularVariable(ns3::TriangularVariable const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::TriangularVariable&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::TriangularVariable const &', 'arg0')])
     ## random-variable.h: ns3::TriangularVariable::TriangularVariable() [constructor]
     cls.add_constructor([])
     ## random-variable.h: ns3::TriangularVariable::TriangularVariable(double s, double l, double mean) [constructor]
@@ -322,9 +322,9 @@
 
 def register_Ns3GlobalValue_methods(root_module, cls):
     ## global-value.h: ns3::GlobalValue::GlobalValue(ns3::GlobalValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::GlobalValue&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::GlobalValue const &', 'arg0')])
     ## 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')])
+    cls.add_constructor([param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')])
     ## global-value.h: std::string ns3::GlobalValue::GetName() const [member function]
     cls.add_method('GetName', 
                    'std::string', 
@@ -338,7 +338,7 @@
     ## global-value.h: void ns3::GlobalValue::GetValue(ns3::AttributeValue & value) const [member function]
     cls.add_method('GetValue', 
                    'void', 
-                   [param('ns3::AttributeValue&', 'value')], 
+                   [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', 
@@ -348,16 +348,16 @@
     ## 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)])
+                   [param('ns3::AttributeValue const &', 'value')])
     ## 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)], 
+                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')], 
                    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)], 
+                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')], 
                    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', 
@@ -375,24 +375,24 @@
     ## ref-count-base.h: ns3::RefCountBase::RefCountBase() [constructor]
     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)])
+    cls.add_constructor([param('ns3::RefCountBase const &', 'o')])
     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)])
+    cls.add_constructor([param('ns3::TypeId const &', 'arg0')])
     ## type-id.h: ns3::TypeId::TypeId(char const * name) [constructor]
-    cls.add_constructor([param('char *', 'name', transfer_ownership=False, is_const=True)])
+    cls.add_constructor([param('char const *', 'name')])
     ## type-id.h: ns3::TypeId::TypeId() [constructor]
     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')])
+                   [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), 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')])
+                   [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue const &', 'initialValue'), 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', 
@@ -561,14 +561,14 @@
     ## type-id.h: ns3::TypeId::AttributeInfo::checker [variable]
     cls.add_instance_attribute('checker', 'ns3::Ptr< ns3::AttributeChecker const >', is_const=False)
     ## type-id.h: ns3::TypeId::AttributeInfo::AttributeInfo(ns3::TypeId::AttributeInfo const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::TypeId::AttributeInfo&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::TypeId::AttributeInfo const &', 'arg0')])
     ## type-id.h: ns3::TypeId::AttributeInfo::AttributeInfo() [constructor]
     cls.add_constructor([])
     return
 
 def register_Ns3SystemWallClockMs_methods(root_module, cls):
     ## system-wall-clock-ms.h: ns3::SystemWallClockMs::SystemWallClockMs(ns3::SystemWallClockMs const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::SystemWallClockMs&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::SystemWallClockMs const &', 'arg0')])
     ## system-wall-clock-ms.h: ns3::SystemWallClockMs::SystemWallClockMs() [constructor]
     cls.add_constructor([])
     ## system-wall-clock-ms.h: void ns3::SystemWallClockMs::Start() [member function]
@@ -583,7 +583,7 @@
 
 def register_Ns3CallbackImplBase_methods(root_module, cls):
     ## callback.h: ns3::CallbackImplBase::CallbackImplBase(ns3::CallbackImplBase const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::CallbackImplBase&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::CallbackImplBase const &', 'arg0')])
     ## callback.h: ns3::CallbackImplBase::CallbackImplBase() [constructor]
     cls.add_constructor([])
     ## callback.h: bool ns3::CallbackImplBase::IsEqual(ns3::Ptr<ns3::CallbackImplBase const> other) const [member function]
@@ -595,14 +595,14 @@
 
 def register_Ns3CriticalSection_methods(root_module, cls):
     ## system-mutex.h: ns3::CriticalSection::CriticalSection(ns3::CriticalSection const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::CriticalSection&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::CriticalSection const &', 'arg0')])
     ## system-mutex.h: ns3::CriticalSection::CriticalSection(ns3::SystemMutex & mutex) [constructor]
-    cls.add_constructor([param('ns3::SystemMutex&', 'mutex')])
+    cls.add_constructor([param('ns3::SystemMutex &', 'mutex')])
     return
 
 def register_Ns3TraceSourceAccessor_methods(root_module, cls):
     ## trace-source-accessor.h: ns3::TraceSourceAccessor::TraceSourceAccessor(ns3::TraceSourceAccessor const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::TraceSourceAccessor&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::TraceSourceAccessor const &', 'arg0')])
     ## trace-source-accessor.h: ns3::TraceSourceAccessor::TraceSourceAccessor() [constructor]
     cls.add_constructor([])
     ## trace-source-accessor.h: void ns3::TraceSourceAccessor::Ref() const [member function]
@@ -618,34 +618,34 @@
     ## 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)], 
+                   [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase const &', 'cb')], 
                    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)], 
+                   [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')], 
                    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)], 
+                   [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase const &', 'cb')], 
                    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)], 
+                   [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')], 
                    is_pure_virtual=True, is_const=True, is_virtual=True)
     return
 
 def register_Ns3AttributeChecker_methods(root_module, cls):
     ## attribute.h: ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::AttributeChecker&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::AttributeChecker const &', 'arg0')])
     ## attribute.h: ns3::AttributeChecker::AttributeChecker() [constructor]
     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)], 
+                   [param('ns3::AttributeValue const &', 'value')], 
                    is_pure_virtual=True, is_const=True, is_virtual=True)
     ## attribute.h: std::string ns3::AttributeChecker::GetValueTypeName() const [member function]
     cls.add_method('GetValueTypeName', 
@@ -670,20 +670,20 @@
     ## 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')], 
+                   [param('ns3::AttributeValue const &', 'source'), param('ns3::AttributeValue &', 'destination')], 
                    is_pure_virtual=True, is_const=True, is_virtual=True)
     return
 
 def register_Ns3RandomVariableChecker_methods(root_module, cls):
     ## random-variable.h: ns3::RandomVariableChecker::RandomVariableChecker(ns3::RandomVariableChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::RandomVariableChecker&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::RandomVariableChecker const &', 'arg0')])
     ## random-variable.h: ns3::RandomVariableChecker::RandomVariableChecker() [constructor]
     cls.add_constructor([])
     return
 
 def register_Ns3SystemMutex_methods(root_module, cls):
     ## system-mutex.h: ns3::SystemMutex::SystemMutex(ns3::SystemMutex const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::SystemMutex&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::SystemMutex const &', 'arg0')])
     ## system-mutex.h: ns3::SystemMutex::SystemMutex() [constructor]
     cls.add_constructor([])
     ## system-mutex.h: void ns3::SystemMutex::Lock() [member function]
@@ -698,7 +698,7 @@
 
 def register_Ns3NormalVariable_methods(root_module, cls):
     ## random-variable.h: ns3::NormalVariable::NormalVariable(ns3::NormalVariable const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::NormalVariable&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::NormalVariable const &', 'arg0')])
     ## random-variable.h: ns3::NormalVariable::NormalVariable() [constructor]
     cls.add_constructor([])
     ## random-variable.h: ns3::NormalVariable::NormalVariable(double m, double v) [constructor]
@@ -719,7 +719,7 @@
 
 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)])
+    cls.add_constructor([param('ns3::ObjectFactory const &', 'arg0')])
     ## object-factory.h: ns3::ObjectFactory::ObjectFactory() [constructor]
     cls.add_constructor([])
     ## object-factory.h: ns3::Ptr<ns3::Object> ns3::ObjectFactory::Create() const [member function]
@@ -735,7 +735,7 @@
     ## 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)])
+                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
     ## object-factory.h: void ns3::ObjectFactory::SetTypeId(ns3::TypeId tid) [member function]
     cls.add_method('SetTypeId', 
                    'void', 
@@ -743,7 +743,7 @@
     ## 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)])
+                   [param('char const *', 'tid')])
     ## object-factory.h: void ns3::ObjectFactory::SetTypeId(std::string tid) [member function]
     cls.add_method('SetTypeId', 
                    'void', 
@@ -753,18 +753,18 @@
 
 def register_Ns3AttributeAccessor_methods(root_module, cls):
     ## attribute.h: ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::AttributeAccessor&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::AttributeAccessor const &', 'arg0')])
     ## attribute.h: ns3::AttributeAccessor::AttributeAccessor() [constructor]
     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)], 
+                   [param('ns3::ObjectBase *', 'object', transfer_ownership=False), param('ns3::AttributeValue const &', 'value')], 
                    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')], 
+                   [param('ns3::ObjectBase const *', 'object'), 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', 
@@ -780,7 +780,7 @@
 
 def register_Ns3ParetoVariable_methods(root_module, cls):
     ## random-variable.h: ns3::ParetoVariable::ParetoVariable(ns3::ParetoVariable const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::ParetoVariable&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::ParetoVariable const &', 'arg0')])
     ## random-variable.h: ns3::ParetoVariable::ParetoVariable() [constructor]
     cls.add_constructor([])
     ## random-variable.h: ns3::ParetoVariable::ParetoVariable(double m) [constructor]
@@ -798,7 +798,7 @@
 
 def register_Ns3ConstantVariable_methods(root_module, cls):
     ## random-variable.h: ns3::ConstantVariable::ConstantVariable(ns3::ConstantVariable const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::ConstantVariable&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::ConstantVariable const &', 'arg0')])
     ## random-variable.h: ns3::ConstantVariable::ConstantVariable() [constructor]
     cls.add_constructor([])
     ## random-variable.h: ns3::ConstantVariable::ConstantVariable(double c) [constructor]
@@ -811,7 +811,7 @@
 
 def register_Ns3EmpiricalVariable_methods(root_module, cls):
     ## random-variable.h: ns3::EmpiricalVariable::EmpiricalVariable(ns3::EmpiricalVariable const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::EmpiricalVariable&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::EmpiricalVariable const &', 'arg0')])
     ## random-variable.h: ns3::EmpiricalVariable::EmpiricalVariable() [constructor]
     cls.add_constructor([])
     ## random-variable.h: void ns3::EmpiricalVariable::CDF(double v, double c) [member function]
@@ -822,7 +822,7 @@
 
 def register_Ns3EnumChecker_methods(root_module, cls):
     ## enum.h: ns3::EnumChecker::EnumChecker(ns3::EnumChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::EnumChecker&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::EnumChecker const &', 'arg0')])
     ## enum.h: ns3::EnumChecker::EnumChecker() [constructor]
     cls.add_constructor([])
     ## enum.h: void ns3::EnumChecker::AddDefault(int v, std::string name) [member function]
@@ -836,7 +836,7 @@
     ## 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)], 
+                   [param('ns3::AttributeValue const &', 'value')], 
                    is_const=True, is_virtual=True)
     ## enum.h: std::string ns3::EnumChecker::GetValueTypeName() const [member function]
     cls.add_method('GetValueTypeName', 
@@ -861,20 +861,20 @@
     ## 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')], 
+                   [param('ns3::AttributeValue const &', 'src'), param('ns3::AttributeValue &', 'dst')], 
                    is_const=True, is_virtual=True)
     return
 
 def register_Ns3Empty_methods(root_module, cls):
     ## empty.h: ns3::empty::empty(ns3::empty const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::empty&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::empty const &', 'arg0')])
     ## empty.h: ns3::empty::empty() [constructor]
     cls.add_constructor([])
     return
 
 def register_Ns3ObjectBase_methods(root_module, cls):
     ## object-base.h: ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::ObjectBase&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::ObjectBase const &', 'arg0')])
     ## object-base.h: ns3::ObjectBase::ObjectBase() [constructor]
     cls.add_constructor([])
     ## object-base.h: static ns3::TypeId ns3::ObjectBase::GetTypeId() [member function]
@@ -890,37 +890,37 @@
     ## 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)])
+                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
     ## 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)])
+                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
     ## 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')], 
+                   [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')], 
+                   [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)])
+                   [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')])
     ## 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)])
+                   [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])
     ## 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)])
+                   [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')])
     ## 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)])
+                   [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])
     ## object-base.h: void ns3::ObjectBase::NotifyConstructionCompleted() [member function]
     cls.add_method('NotifyConstructionCompleted', 
                    'void', 
@@ -929,71 +929,78 @@
     ## 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)], 
+                   [param('ns3::AttributeList const &', 'attributes')], 
                    visibility='protected')
     return
 
 def register_Ns3CommandLine_methods(root_module, cls):
     ## command-line.h: ns3::CommandLine::CommandLine(ns3::CommandLine const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::CommandLine&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::CommandLine const &', 'arg0')])
     ## command-line.h: ns3::CommandLine::CommandLine() [constructor]
     cls.add_constructor([])
     return
 
 def register_Ns3IntToType__6_methods(root_module, cls):
     ## int-to-type.h: ns3::IntToType<6>::IntToType(ns3::IntToType<6> const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::IntToType< 6 >&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::IntToType< 6 >', 'arg0')])
     ## int-to-type.h: ns3::IntToType<6>::IntToType() [constructor]
     cls.add_constructor([])
+    cls.add_copy_constructor()
     return
 
 def register_Ns3IntToType__5_methods(root_module, cls):
     ## int-to-type.h: ns3::IntToType<5>::IntToType(ns3::IntToType<5> const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::IntToType< 5 >&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::IntToType< 5 >', 'arg0')])
     ## int-to-type.h: ns3::IntToType<5>::IntToType() [constructor]
     cls.add_constructor([])
+    cls.add_copy_constructor()
     return
 
 def register_Ns3IntToType__4_methods(root_module, cls):
     ## int-to-type.h: ns3::IntToType<4>::IntToType(ns3::IntToType<4> const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::IntToType< 4 >&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::IntToType< 4 >', 'arg0')])
     ## int-to-type.h: ns3::IntToType<4>::IntToType() [constructor]
     cls.add_constructor([])
+    cls.add_copy_constructor()
     return
 
 def register_Ns3IntToType__3_methods(root_module, cls):
     ## int-to-type.h: ns3::IntToType<3>::IntToType(ns3::IntToType<3> const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::IntToType< 3 >&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::IntToType< 3 >', 'arg0')])
     ## int-to-type.h: ns3::IntToType<3>::IntToType() [constructor]
     cls.add_constructor([])
+    cls.add_copy_constructor()
     return
 
 def register_Ns3IntToType__2_methods(root_module, cls):
     ## int-to-type.h: ns3::IntToType<2>::IntToType(ns3::IntToType<2> const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::IntToType< 2 >&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::IntToType< 2 >', 'arg0')])
     ## int-to-type.h: ns3::IntToType<2>::IntToType() [constructor]
     cls.add_constructor([])
+    cls.add_copy_constructor()
     return
 
 def register_Ns3IntToType__1_methods(root_module, cls):
     ## int-to-type.h: ns3::IntToType<1>::IntToType(ns3::IntToType<1> const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::IntToType< 1 >&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::IntToType< 1 >', 'arg0')])
     ## int-to-type.h: ns3::IntToType<1>::IntToType() [constructor]
     cls.add_constructor([])
+    cls.add_copy_constructor()
     return
 
 def register_Ns3IntToType__0_methods(root_module, cls):
     ## int-to-type.h: ns3::IntToType<0>::IntToType(ns3::IntToType<0> const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::IntToType< 0 >&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::IntToType< 0 >', 'arg0')])
     ## int-to-type.h: ns3::IntToType<0>::IntToType() [constructor]
     cls.add_constructor([])
+    cls.add_copy_constructor()
     return
 
 def register_Ns3RngStream_methods(root_module, cls):
     ## rng-stream.h: ns3::RngStream::RngStream() [constructor]
     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)])
+    cls.add_constructor([param('ns3::RngStream const &', 'arg0')])
     ## rng-stream.h: void ns3::RngStream::InitializeStream() [member function]
     cls.add_method('InitializeStream', 
                    'void', 
@@ -1025,7 +1032,7 @@
     ## 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)])
+                   [param('uint32_t const *', 'seed')])
     ## rng-stream.h: void ns3::RngStream::AdvanceState(int32_t e, int32_t c) [member function]
     cls.add_method('AdvanceState', 
                    'void', 
@@ -1046,18 +1053,18 @@
     ## 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)], 
+                   [param('uint32_t const *', 'seed')], 
                    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)], 
+                   [param('uint32_t const *', 'seed')], 
                    is_static=True)
     return
 
 def register_Ns3LogNormalVariable_methods(root_module, cls):
     ## random-variable.h: ns3::LogNormalVariable::LogNormalVariable(ns3::LogNormalVariable const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::LogNormalVariable&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::LogNormalVariable const &', 'arg0')])
     ## random-variable.h: ns3::LogNormalVariable::LogNormalVariable(double mu, double sigma) [constructor]
     cls.add_constructor([param('double', 'mu'), param('double', 'sigma')])
     ## random-variable.h: static double ns3::LogNormalVariable::GetSingleValue(double mu, double sigma) [member function]
@@ -1069,14 +1076,14 @@
 
 def register_Ns3IntEmpiricalVariable_methods(root_module, cls):
     ## random-variable.h: ns3::IntEmpiricalVariable::IntEmpiricalVariable(ns3::IntEmpiricalVariable const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::IntEmpiricalVariable&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::IntEmpiricalVariable const &', 'arg0')])
     ## random-variable.h: ns3::IntEmpiricalVariable::IntEmpiricalVariable() [constructor]
     cls.add_constructor([])
     return
 
 def register_Ns3PointerChecker_methods(root_module, cls):
     ## pointer.h: ns3::PointerChecker::PointerChecker(ns3::PointerChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::PointerChecker&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::PointerChecker const &', 'arg0')])
     ## pointer.h: ns3::PointerChecker::PointerChecker() [constructor]
     cls.add_constructor([])
     ## pointer.h: ns3::TypeId ns3::PointerChecker::GetPointeeTypeId() const [member function]
@@ -1088,7 +1095,7 @@
 
 def register_Ns3WeibullVariable_methods(root_module, cls):
     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(ns3::WeibullVariable const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::WeibullVariable&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::WeibullVariable const &', 'arg0')])
     ## random-variable.h: ns3::WeibullVariable::WeibullVariable() [constructor]
     cls.add_constructor([])
     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(double m) [constructor]
@@ -1106,7 +1113,7 @@
 
 def register_Ns3CallbackBase_methods(root_module, cls):
     ## callback.h: ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::CallbackBase&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::CallbackBase const &', 'arg0')])
     ## callback.h: ns3::CallbackBase::CallbackBase() [constructor]
     cls.add_constructor([])
     ## callback.h: ns3::Ptr<ns3::CallbackImplBase> ns3::CallbackBase::GetImpl() const [member function]
@@ -1121,7 +1128,7 @@
 
 def register_Ns3ExponentialVariable_methods(root_module, cls):
     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable(ns3::ExponentialVariable const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::ExponentialVariable&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::ExponentialVariable const &', 'arg0')])
     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable() [constructor]
     cls.add_constructor([])
     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable(double m) [constructor]
@@ -1137,14 +1144,14 @@
 
 def register_Ns3DeterministicVariable_methods(root_module, cls):
     ## random-variable.h: ns3::DeterministicVariable::DeterministicVariable(ns3::DeterministicVariable const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::DeterministicVariable&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::DeterministicVariable const &', 'arg0')])
     ## random-variable.h: ns3::DeterministicVariable::DeterministicVariable(double * d, uint32_t c) [constructor]
     cls.add_constructor([param('double *', 'd'), param('uint32_t', 'c')])
     return
 
 def register_Ns3SystemThread_methods(root_module, cls):
     ## system-thread.h: ns3::SystemThread::SystemThread(ns3::SystemThread const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::SystemThread&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::SystemThread const &', 'arg0')])
     ## 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]
@@ -1171,19 +1178,19 @@
     ## attribute-list.h: ns3::AttributeList::AttributeList() [constructor]
     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)])
+    cls.add_constructor([param('ns3::AttributeList const &', 'o')])
     ## 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)])
+                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
     ## 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)])
+                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
     ## 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)])
+                   [param('ns3::TypeId', 'tid'), param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
     ## attribute-list.h: void ns3::AttributeList::Reset() [member function]
     cls.add_method('Reset', 
                    'void', 
@@ -1206,7 +1213,7 @@
 
 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)])
+    cls.add_constructor([param('ns3::AttributeValue const &', 'arg0')])
     ## attribute.h: ns3::AttributeValue::AttributeValue() [constructor]
     cls.add_constructor([])
     ## attribute.h: ns3::Ptr<ns3::AttributeValue> ns3::AttributeValue::Copy() const [member function]
@@ -1228,7 +1235,7 @@
 
 def register_Ns3UniformVariable_methods(root_module, cls):
     ## random-variable.h: ns3::UniformVariable::UniformVariable(ns3::UniformVariable const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::UniformVariable&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::UniformVariable const &', 'arg0')])
     ## random-variable.h: ns3::UniformVariable::UniformVariable() [constructor]
     cls.add_constructor([])
     ## random-variable.h: ns3::UniformVariable::UniformVariable(double s, double l) [constructor]
@@ -1277,13 +1284,13 @@
                    [], 
                    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)], 
+    cls.add_constructor([param('ns3::Object const &', 'o')], 
                         visibility='protected')
     return
 
 def register_Ns3ObjectAggregateIterator_methods(root_module, cls):
     ## object.h: ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Object::AggregateIterator&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Object::AggregateIterator const &', 'arg0')])
     ## object.h: ns3::Object::AggregateIterator::AggregateIterator() [constructor]
     cls.add_constructor([])
     ## object.h: bool ns3::Object::AggregateIterator::HasNext() const [member function]
@@ -1299,7 +1306,7 @@
 
 def register_Ns3SystemCondition_methods(root_module, cls):
     ## system-condition.h: ns3::SystemCondition::SystemCondition(ns3::SystemCondition const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::SystemCondition&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::SystemCondition const &', 'arg0')])
     ## system-condition.h: ns3::SystemCondition::SystemCondition() [constructor]
     cls.add_constructor([])
     ## system-condition.h: void ns3::SystemCondition::SetCondition(bool condition) [member function]
@@ -1330,16 +1337,16 @@
 
 def register_Ns3SequentialVariable_methods(root_module, cls):
     ## random-variable.h: ns3::SequentialVariable::SequentialVariable(ns3::SequentialVariable const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::SequentialVariable&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::SequentialVariable const &', 'arg0')])
     ## 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')])
     ## 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')])
+    cls.add_constructor([param('double', 'f'), param('double', 'l'), param('ns3::RandomVariable const &', 'i'), param('uint32_t', 'c', default_value='1')])
     return
 
 def register_Ns3ObjectVectorChecker_methods(root_module, cls):
     ## object-vector.h: ns3::ObjectVectorChecker::ObjectVectorChecker(ns3::ObjectVectorChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::ObjectVectorChecker&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::ObjectVectorChecker const &', 'arg0')])
     ## object-vector.h: ns3::ObjectVectorChecker::ObjectVectorChecker() [constructor]
     cls.add_constructor([])
     ## object-vector.h: ns3::TypeId ns3::ObjectVectorChecker::GetItemTypeId() const [member function]
@@ -1351,14 +1358,14 @@
 
 def register_Ns3StringChecker_methods(root_module, cls):
     ## string.h: ns3::StringChecker::StringChecker(ns3::StringChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::StringChecker&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::StringChecker const &', 'arg0')])
     ## string.h: ns3::StringChecker::StringChecker() [constructor]
     cls.add_constructor([])
     return
 
 def register_Ns3ObjectVectorValue_methods(root_module, cls):
     ## object-vector.h: ns3::ObjectVectorValue::ObjectVectorValue(ns3::ObjectVectorValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::ObjectVectorValue&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::ObjectVectorValue const &', 'arg0')])
     ## object-vector.h: ns3::ObjectVectorValue::ObjectVectorValue() [constructor]
     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]
@@ -1400,22 +1407,22 @@
 
 def register_Ns3BooleanChecker_methods(root_module, cls):
     ## boolean.h: ns3::BooleanChecker::BooleanChecker(ns3::BooleanChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::BooleanChecker&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::BooleanChecker const &', 'arg0')])
     ## boolean.h: ns3::BooleanChecker::BooleanChecker() [constructor]
     cls.add_constructor([])
     return
 
 def register_Ns3UintegerValue_methods(root_module, cls):
     ## uinteger.h: ns3::UintegerValue::UintegerValue(ns3::UintegerValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::UintegerValue&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::UintegerValue const &', 'arg0')])
     ## uinteger.h: ns3::UintegerValue::UintegerValue() [constructor]
     cls.add_constructor([])
     ## uinteger.h: ns3::UintegerValue::UintegerValue(uint64_t const & value) [constructor]
-    cls.add_constructor([param('uint64_t&', 'value', is_const=True)])
+    cls.add_constructor([param('uint64_t const &', 'value')])
     ## uinteger.h: void ns3::UintegerValue::Set(uint64_t const & value) [member function]
     cls.add_method('Set', 
                    'void', 
-                   [param('uint64_t&', 'value', is_const=True)])
+                   [param('uint64_t const &', 'value')])
     ## uinteger.h: uint64_t ns3::UintegerValue::Get() const [member function]
     cls.add_method('Get', 
                    'uint64_t', 
@@ -1440,18 +1447,18 @@
 
 def register_Ns3ObjectVectorAccessor_methods(root_module, cls):
     ## object-vector.h: ns3::ObjectVectorAccessor::ObjectVectorAccessor(ns3::ObjectVectorAccessor const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::ObjectVectorAccessor&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::ObjectVectorAccessor const &', 'arg0')])
     ## object-vector.h: ns3::ObjectVectorAccessor::ObjectVectorAccessor() [constructor]
     cls.add_constructor([])
     ## 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)], 
+                   [param('ns3::ObjectBase *', 'object'), param('ns3::AttributeValue const &', 'value')], 
                    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')], 
+                   [param('ns3::ObjectBase const *', 'object'), param('ns3::AttributeValue &', 'value')], 
                    is_const=True, is_virtual=True)
     ## object-vector.h: bool ns3::ObjectVectorAccessor::HasGetter() const [member function]
     cls.add_method('HasGetter', 
@@ -1466,18 +1473,18 @@
     ## 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')], 
+                   [param('ns3::ObjectBase const *', 'object'), 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')], 
+                   [param('ns3::ObjectBase const *', 'object'), param('uint32_t', 'i')], 
                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
     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)])
+    cls.add_constructor([param('ns3::PointerValue const &', 'arg0')])
     ## pointer.h: ns3::PointerValue::PointerValue() [constructor]
     cls.add_constructor([])
     ## pointer.h: ns3::PointerValue::PointerValue(ns3::Ptr<ns3::Object> object) [constructor]
@@ -1510,29 +1517,29 @@
 
 def register_Ns3ObjectFactoryChecker_methods(root_module, cls):
     ## object-factory.h: ns3::ObjectFactoryChecker::ObjectFactoryChecker(ns3::ObjectFactoryChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::ObjectFactoryChecker&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::ObjectFactoryChecker const &', 'arg0')])
     ## object-factory.h: ns3::ObjectFactoryChecker::ObjectFactoryChecker() [constructor]
     cls.add_constructor([])
     return
 
 def register_Ns3TypeIdChecker_methods(root_module, cls):
     ## type-id.h: ns3::TypeIdChecker::TypeIdChecker(ns3::TypeIdChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::TypeIdChecker&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::TypeIdChecker const &', 'arg0')])
     ## type-id.h: ns3::TypeIdChecker::TypeIdChecker() [constructor]
     cls.add_constructor([])
     return
 
 def register_Ns3DoubleValue_methods(root_module, cls):
     ## double.h: ns3::DoubleValue::DoubleValue(ns3::DoubleValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::DoubleValue&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::DoubleValue const &', 'arg0')])
     ## double.h: ns3::DoubleValue::DoubleValue() [constructor]
     cls.add_constructor([])
     ## double.h: ns3::DoubleValue::DoubleValue(double const & value) [constructor]
-    cls.add_constructor([param('double&', 'value', is_const=True)])
+    cls.add_constructor([param('double const &', 'value')])
     ## double.h: void ns3::DoubleValue::Set(double const & value) [member function]
     cls.add_method('Set', 
                    'void', 
-                   [param('double&', 'value', is_const=True)])
+                   [param('double const &', 'value')])
     ## double.h: double ns3::DoubleValue::Get() const [member function]
     cls.add_method('Get', 
                    'double', 
@@ -1557,15 +1564,15 @@
 
 def register_Ns3TypeIdValue_methods(root_module, cls):
     ## type-id.h: ns3::TypeIdValue::TypeIdValue(ns3::TypeIdValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::TypeIdValue&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::TypeIdValue const &', 'arg0')])
     ## type-id.h: ns3::TypeIdValue::TypeIdValue() [constructor]
     cls.add_constructor([])
     ## type-id.h: ns3::TypeIdValue::TypeIdValue(ns3::TypeId const & value) [constructor]
-    cls.add_constructor([param('ns3::TypeId&', 'value', is_const=True)])
+    cls.add_constructor([param('ns3::TypeId const &', 'value')])
     ## 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)])
+                   [param('ns3::TypeId const &', 'value')])
     ## type-id.h: ns3::TypeId ns3::TypeIdValue::Get() const [member function]
     cls.add_method('Get', 
                    'ns3::TypeId', 
@@ -1590,7 +1597,7 @@
 
 def register_Ns3EnumValue_methods(root_module, cls):
     ## enum.h: ns3::EnumValue::EnumValue(ns3::EnumValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::EnumValue&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::EnumValue const &', 'arg0')])
     ## enum.h: ns3::EnumValue::EnumValue() [constructor]
     cls.add_constructor([])
     ## enum.h: ns3::EnumValue::EnumValue(int v) [constructor]
@@ -1623,15 +1630,15 @@
 
 def register_Ns3RandomVariableValue_methods(root_module, cls):
     ## random-variable.h: ns3::RandomVariableValue::RandomVariableValue(ns3::RandomVariableValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::RandomVariableValue&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::RandomVariableValue const &', 'arg0')])
     ## random-variable.h: ns3::RandomVariableValue::RandomVariableValue() [constructor]
     cls.add_constructor([])
     ## random-variable.h: ns3::RandomVariableValue::RandomVariableValue(ns3::RandomVariable const & value) [constructor]
-    cls.add_constructor([param('ns3::RandomVariable&', 'value', is_const=True)])
+    cls.add_constructor([param('ns3::RandomVariable const &', 'value')])
     ## 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)])
+                   [param('ns3::RandomVariable const &', 'value')])
     ## random-variable.h: ns3::RandomVariable ns3::RandomVariableValue::Get() const [member function]
     cls.add_method('Get', 
                    'ns3::RandomVariable', 
@@ -1656,15 +1663,15 @@
 
 def register_Ns3ObjectFactoryValue_methods(root_module, cls):
     ## object-factory.h: ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactoryValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::ObjectFactoryValue&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::ObjectFactoryValue const &', 'arg0')])
     ## object-factory.h: ns3::ObjectFactoryValue::ObjectFactoryValue() [constructor]
     cls.add_constructor([])
     ## object-factory.h: ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactory const & value) [constructor]
-    cls.add_constructor([param('ns3::ObjectFactory&', 'value', is_const=True)])
+    cls.add_constructor([param('ns3::ObjectFactory const &', 'value')])
     ## 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)])
+                   [param('ns3::ObjectFactory const &', 'value')])
     ## object-factory.h: ns3::ObjectFactory ns3::ObjectFactoryValue::Get() const [member function]
     cls.add_method('Get', 
                    'ns3::ObjectFactory', 
@@ -1689,15 +1696,15 @@
 
 def register_Ns3IntegerValue_methods(root_module, cls):
     ## integer.h: ns3::IntegerValue::IntegerValue(ns3::IntegerValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::IntegerValue&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::IntegerValue const &', 'arg0')])
     ## integer.h: ns3::IntegerValue::IntegerValue() [constructor]
     cls.add_constructor([])
     ## integer.h: ns3::IntegerValue::IntegerValue(int64_t const & value) [constructor]
-    cls.add_constructor([param('int64_t&', 'value', is_const=True)])
+    cls.add_constructor([param('int64_t const &', 'value')])
     ## integer.h: void ns3::IntegerValue::Set(int64_t const & value) [member function]
     cls.add_method('Set', 
                    'void', 
-                   [param('int64_t&', 'value', is_const=True)])
+                   [param('int64_t const &', 'value')])
     ## integer.h: int64_t ns3::IntegerValue::Get() const [member function]
     cls.add_method('Get', 
                    'int64_t', 
@@ -1722,7 +1729,7 @@
 
 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)])
+    cls.add_constructor([param('ns3::BooleanValue const &', 'arg0')])
     ## boolean.h: ns3::BooleanValue::BooleanValue() [constructor]
     cls.add_constructor([])
     ## boolean.h: ns3::BooleanValue::BooleanValue(bool value) [constructor]
@@ -1756,15 +1763,15 @@
 
 def register_Ns3StringValue_methods(root_module, cls):
     ## string.h: ns3::StringValue::StringValue(ns3::StringValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::StringValue&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::StringValue const &', 'arg0')])
     ## 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)])
+    cls.add_constructor([param('std::string const &', 'value')])
     ## string.h: void ns3::StringValue::Set(std::string const & value) [member function]
     cls.add_method('Set', 
                    'void', 
-                   [param('std::string&', 'value', is_const=True)])
+                   [param('std::string const &', 'value')])
     ## string.h: std::string ns3::StringValue::Get() const [member function]
     cls.add_method('Get', 
                    'std::string', 
@@ -1789,7 +1796,7 @@
 
 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)])
+    cls.add_constructor([param('ns3::EmptyAttributeValue const &', 'arg0')])
     ## attribute.h: ns3::EmptyAttributeValue::EmptyAttributeValue() [constructor]
     cls.add_constructor([])
     ## attribute.h: ns3::Ptr<ns3::AttributeValue> ns3::EmptyAttributeValue::Copy() const [member function]
@@ -1813,42 +1820,43 @@
     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue() [constructor]
     cls.add_constructor([])
     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::TracedValue<unsigned int> const & o) [copy constructor]
-    cls.add_constructor([param('ns3::TracedValue< unsigned int >&', 'o', is_const=True)])
+    cls.add_constructor([param('ns3::TracedValue< unsigned int >', 'o')])
     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(unsigned int const & v) [constructor]
-    cls.add_constructor([param('unsigned int&', 'v', is_const=True)])
+    cls.add_constructor([param('unsigned int const &', 'v')])
     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::IntegerValue const & value) [constructor]
-    cls.add_constructor([param('ns3::IntegerValue&', 'value', is_const=True)])
+    cls.add_constructor([param('ns3::IntegerValue const &', 'value')])
     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::UintegerValue const & value) [constructor]
-    cls.add_constructor([param('ns3::UintegerValue&', 'value', is_const=True)])
+    cls.add_constructor([param('ns3::UintegerValue const &', 'value')])
     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::BooleanValue const & value) [constructor]
-    cls.add_constructor([param('ns3::BooleanValue&', 'value', is_const=True)])
+    cls.add_constructor([param('ns3::BooleanValue const &', 'value')])
     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::EnumValue const & value) [constructor]
-    cls.add_constructor([param('ns3::EnumValue&', 'value', is_const=True)])
+    cls.add_constructor([param('ns3::EnumValue const &', 'value')])
     ## 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)])
+                   [param('ns3::CallbackBase const &', 'cb')])
     ## 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')])
+                   [param('ns3::CallbackBase const &', 'cb'), param('std::string', 'path')])
     ## traced-value.h: void ns3::TracedValue<unsigned int>::DisconnectWithoutContext(ns3::CallbackBase const & cb) [member function]
     cls.add_method('DisconnectWithoutContext', 
                    'void', 
-                   [param('ns3::CallbackBase&', 'cb', is_const=True)])
+                   [param('ns3::CallbackBase const &', 'cb')])
     ## 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')])
+                   [param('ns3::CallbackBase const &', 'cb'), 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)])
+                   [param('unsigned int const &', 'v')])
     ## traced-value.h: unsigned int ns3::TracedValue<unsigned int>::Get() const [member function]
     cls.add_method('Get', 
                    'unsigned int', 
                    [], 
                    is_const=True)
+    cls.add_copy_constructor()
     return
 
 def register_functions(root_module):
@@ -1952,11 +1960,11 @@
     ## log.h: extern void ns3::LogComponentDisable(char const * name, ns3::LogLevel level) [free function]
     module.add_function('LogComponentDisable', 
                         'void', 
-                        [param('char *', 'name', transfer_ownership=False, is_const=True), param('ns3::LogLevel', 'level')])
+                        [param('char const *', 'name'), param('ns3::LogLevel', 'level')])
     ## log.h: extern void ns3::LogComponentEnable(char const * name, ns3::LogLevel level) [free function]
     module.add_function('LogComponentEnable', 
                         'void', 
-                        [param('char *', 'name', transfer_ownership=False, is_const=True), param('ns3::LogLevel', 'level')])
+                        [param('char const *', 'name'), param('ns3::LogLevel', 'level')])
     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)
@@ -1985,19 +1993,19 @@
     ## 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)])
+                        [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
     ## 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)])
+                        [param('std::string', 'path'), param('ns3::CallbackBase const &', 'cb')])
     ## 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)])
+                        [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
     ## 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)])
+                        [param('std::string', 'path'), param('ns3::CallbackBase const &', 'cb')])
     ## config.h: extern ns3::Ptr<ns3::Object> ns3::Config::GetRootNamespaceObject(uint32_t i) [free function]
     module.add_function('GetRootNamespaceObject', 
                         'ns3::Ptr< ns3::Object >', 
@@ -2005,7 +2013,7 @@
     ## 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)])
+                        [param('std::string', 'path'), param('ns3::CallbackBase const &', 'cb')])
     ## config.h: extern void ns3::Config::UnregisterRootNamespaceObject(ns3::Ptr<ns3::Object> obj) [free function]
     module.add_function('UnregisterRootNamespaceObject', 
                         'void', 
@@ -2013,7 +2021,7 @@
     ## 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)])
+                        [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
     ## config.h: extern uint32_t ns3::Config::GetRootNamespaceObjectN() [free function]
     module.add_function('GetRootNamespaceObjectN', 
                         'uint32_t', 
@@ -2021,11 +2029,11 @@
     ## 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)])
+                        [param('std::string', 'path'), param('ns3::AttributeValue const &', 'value')])
     ## 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)])
+                        [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
     ## config.h: extern void ns3::Config::RegisterRootNamespaceObject(ns3::Ptr<ns3::Object> obj) [free function]
     module.add_function('RegisterRootNamespaceObject', 
                         'void', 
@@ -2033,7 +2041,7 @@
     ## 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)])
+                        [param('std::string', 'path'), param('ns3::CallbackBase const &', 'cb')])
     return
 
 def register_functions_ns3_olsr(module, root_module):
--- a/bindings/python/ns3_module_csma.py	Sun Aug 31 22:33:23 2008 +0100
+++ b/bindings/python/ns3_module_csma.py	Tue Sep 02 11:12:42 2008 +0100
@@ -69,7 +69,7 @@
     ## csma-channel.h: ns3::CsmaDeviceRec::active [variable]
     cls.add_instance_attribute('active', 'bool', is_const=False)
     ## csma-channel.h: ns3::CsmaDeviceRec::CsmaDeviceRec(ns3::CsmaDeviceRec const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::CsmaDeviceRec&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::CsmaDeviceRec const &', 'arg0')])
     ## csma-channel.h: ns3::CsmaDeviceRec::CsmaDeviceRec() [constructor]
     cls.add_constructor([])
     ## csma-channel.h: ns3::CsmaDeviceRec::CsmaDeviceRec(ns3::Ptr<ns3::CsmaNetDevice> device) [constructor]
@@ -92,7 +92,7 @@
     ## backoff.h: ns3::Backoff::m_slotTime [variable]
     cls.add_instance_attribute('m_slotTime', 'ns3::Time', is_const=False)
     ## backoff.h: ns3::Backoff::Backoff(ns3::Backoff const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Backoff&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Backoff const &', 'arg0')])
     ## backoff.h: ns3::Backoff::Backoff() [constructor]
     cls.add_constructor([])
     ## backoff.h: ns3::Backoff::Backoff(ns3::Time slotTime, uint32_t minSlots, uint32_t maxSlots, uint32_t ceiling, uint32_t maxRetries) [constructor]
@@ -117,7 +117,7 @@
 
 def register_Ns3CsmaChannel_methods(root_module, cls):
     ## csma-channel.h: ns3::CsmaChannel::CsmaChannel(ns3::CsmaChannel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::CsmaChannel&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::CsmaChannel const &', 'arg0')])
     ## csma-channel.h: static ns3::TypeId ns3::CsmaChannel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -285,7 +285,7 @@
     ## 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)], 
+                   [param('std::string const', 'name')], 
                    is_virtual=True)
     ## csma-net-device.h: std::string ns3::CsmaNetDevice::GetName() const [member function]
     cls.add_method('GetName', 
@@ -295,7 +295,7 @@
     ## 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)], 
+                   [param('uint32_t const', 'index')], 
                    is_virtual=True)
     ## csma-net-device.h: uint32_t ns3::CsmaNetDevice::GetIfIndex() const [member function]
     cls.add_method('GetIfIndex', 
@@ -310,7 +310,7 @@
     ## 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)], 
+                   [param('uint16_t const', 'mtu')], 
                    is_virtual=True)
     ## csma-net-device.h: uint16_t ns3::CsmaNetDevice::GetMtu() const [member function]
     cls.add_method('GetMtu', 
@@ -365,12 +365,12 @@
     ## 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')], 
+                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'dest'), 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')], 
+                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'source'), param('ns3::Address const &', 'dest'), 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', 
@@ -420,7 +420,7 @@
     ## 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')], 
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint16_t &', 'param')], 
                    visibility='protected')
     return
 
--- a/bindings/python/ns3_module_global_routing.py	Sun Aug 31 22:33:23 2008 +0100
+++ b/bindings/python/ns3_module_global_routing.py	Tue Sep 02 11:12:42 2008 +0100
@@ -84,7 +84,7 @@
     ## 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')])
     ## global-router-interface.h: ns3::GlobalRoutingLSA::GlobalRoutingLSA(ns3::GlobalRoutingLSA & lsa) [constructor]
-    cls.add_constructor([param('ns3::GlobalRoutingLSA&', 'lsa')])
+    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', 
@@ -100,7 +100,7 @@
     ## 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)])
+                   [param('ns3::GlobalRoutingLSA const &', 'lsa')])
     ## global-router-interface.h: ns3::Ipv4Address ns3::GlobalRoutingLSA::GetAdvertisingRouter() const [member function]
     cls.add_method('GetAdvertisingRouter', 
                    'ns3::Ipv4Address', 
@@ -154,7 +154,7 @@
     ## global-router-interface.h: void ns3::GlobalRoutingLSA::Print(std::ostream & os) const [member function]
     cls.add_method('Print', 
                    'void', 
-                   [param('std::ostream&', 'os')], 
+                   [param('std::ostream &', 'os')], 
                    is_const=True)
     ## global-router-interface.h: void ns3::GlobalRoutingLSA::SetAdvertisingRouter(ns3::Ipv4Address rtr) [member function]
     cls.add_method('SetAdvertisingRouter', 
@@ -181,7 +181,7 @@
 
 def register_Ns3GlobalRoutingLinkRecord_methods(root_module, cls):
     ## global-router-interface.h: ns3::GlobalRoutingLinkRecord::GlobalRoutingLinkRecord(ns3::GlobalRoutingLinkRecord const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::GlobalRoutingLinkRecord&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::GlobalRoutingLinkRecord const &', 'arg0')])
     ## global-router-interface.h: ns3::GlobalRoutingLinkRecord::GlobalRoutingLinkRecord() [constructor]
     cls.add_constructor([])
     ## global-router-interface.h: ns3::GlobalRoutingLinkRecord::GlobalRoutingLinkRecord(ns3::GlobalRoutingLinkRecord::LinkType linkType, ns3::Ipv4Address linkId, ns3::Ipv4Address linkData, uint16_t metric) [constructor]
@@ -249,7 +249,7 @@
     ## 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')], 
+                   [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', 
--- a/bindings/python/ns3_module_helper.py	Sun Aug 31 22:33:23 2008 +0100
+++ b/bindings/python/ns3_module_helper.py	Tue Sep 02 11:12:42 2008 +0100
@@ -106,7 +106,7 @@
 
 def register_Ns3MobilityHelper_methods(root_module, cls):
     ## mobility-helper.h: ns3::MobilityHelper::MobilityHelper(ns3::MobilityHelper const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::MobilityHelper&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::MobilityHelper const &', 'arg0')])
     ## mobility-helper.h: ns3::MobilityHelper::MobilityHelper() [constructor]
     cls.add_constructor([])
     ## mobility-helper.h: void ns3::MobilityHelper::SetPositionAllocator(ns3::Ptr<ns3::PositionAllocator> allocator) [member function]
@@ -116,11 +116,11 @@
     ## 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)])
+                   [param('std::string', 'type'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue const &', 'v1', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue const &', 'v2', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue const &', 'v3', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue const &', 'v4', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue const &', 'v5', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue const &', 'v6', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue const &', 'v7', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n8', default_value='""'), param('ns3::AttributeValue const &', 'v8', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n9', default_value='""'), param('ns3::AttributeValue const &', 'v9', default_value='ns3::EmptyAttributeValue()')])
     ## 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)])
+                   [param('std::string', 'type'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue const &', 'v1', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue const &', 'v2', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue const &', 'v3', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue const &', 'v4', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue const &', 'v5', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue const &', 'v6', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue const &', 'v7', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n8', default_value='""'), param('ns3::AttributeValue const &', 'v8', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n9', default_value='""'), param('ns3::AttributeValue const &', 'v9', default_value='ns3::EmptyAttributeValue()')])
     ## mobility-helper.h: void ns3::MobilityHelper::PushReferenceMobilityModel(ns3::Ptr<ns3::Object> reference) [member function]
     cls.add_method('PushReferenceMobilityModel', 
                    'void', 
@@ -145,23 +145,23 @@
     ## mobility-helper.h: static void ns3::MobilityHelper::EnableAscii(std::ostream & os, uint32_t nodeid) [member function]
     cls.add_method('EnableAscii', 
                    'void', 
-                   [param('std::ostream&', 'os'), param('uint32_t', 'nodeid')], 
+                   [param('std::ostream &', 'os'), param('uint32_t', 'nodeid')], 
                    is_static=True)
     ## mobility-helper.h: static void ns3::MobilityHelper::EnableAscii(std::ostream & os, ns3::NodeContainer n) [member function]
     cls.add_method('EnableAscii', 
                    'void', 
-                   [param('std::ostream&', 'os'), param('ns3::NodeContainer', 'n')], 
+                   [param('std::ostream &', 'os'), param('ns3::NodeContainer', 'n')], 
                    is_static=True)
     ## mobility-helper.h: static void ns3::MobilityHelper::EnableAsciiAll(std::ostream & os) [member function]
     cls.add_method('EnableAsciiAll', 
                    'void', 
-                   [param('std::ostream&', 'os')], 
+                   [param('std::ostream &', 'os')], 
                    is_static=True)
     return
 
 def register_Ns3InternetStackHelper_methods(root_module, cls):
     ## internet-stack-helper.h: ns3::InternetStackHelper::InternetStackHelper(ns3::InternetStackHelper const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::InternetStackHelper&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::InternetStackHelper const &', 'arg0')])
     ## internet-stack-helper.h: ns3::InternetStackHelper::InternetStackHelper() [constructor]
     cls.add_constructor([])
     ## internet-stack-helper.h: void ns3::InternetStackHelper::Install(ns3::NodeContainer c) [member function]
@@ -177,17 +177,17 @@
 
 def register_Ns3NodeContainer_methods(root_module, cls):
     ## node-container.h: ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::NodeContainer&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::NodeContainer const &', 'arg0')])
     ## node-container.h: ns3::NodeContainer::NodeContainer() [constructor]
     cls.add_constructor([])
     ## node-container.h: ns3::NodeContainer::NodeContainer(ns3::Ptr<ns3::Node> node) [constructor]
     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)])
+    cls.add_constructor([param('ns3::NodeContainer const &', 'a'), param('ns3::NodeContainer const &', 'b')])
     ## 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)])
+    cls.add_constructor([param('ns3::NodeContainer const &', 'a'), param('ns3::NodeContainer const &', 'b'), param('ns3::NodeContainer const &', 'c')])
     ## 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)])
+    cls.add_constructor([param('ns3::NodeContainer const &', 'a'), param('ns3::NodeContainer const &', 'b'), param('ns3::NodeContainer const &', 'c'), param('ns3::NodeContainer const &', 'd')])
     ## 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 > > >', 
@@ -229,30 +229,30 @@
 
 def register_Ns3PointToPointHelper_methods(root_module, cls):
     ## point-to-point-helper.h: ns3::PointToPointHelper::PointToPointHelper(ns3::PointToPointHelper const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::PointToPointHelper&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::PointToPointHelper const &', 'arg0')])
     ## point-to-point-helper.h: ns3::PointToPointHelper::PointToPointHelper() [constructor]
     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)])
+                   [param('std::string', 'type'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue const &', 'v1', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue const &', 'v2', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue const &', 'v3', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue const &', 'v4', default_value='ns3::EmptyAttributeValue()')])
     ## 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)])
+                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
     ## 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)])
+                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
     ## 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)], 
+                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')], 
                    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)], 
+                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')], 
                    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', 
@@ -277,22 +277,22 @@
     ## 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')], 
+                   [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')], 
+                   [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')], 
+                   [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')], 
+                   [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', 
@@ -306,7 +306,7 @@
 
 def register_Ns3NetDeviceContainer_methods(root_module, cls):
     ## net-device-container.h: ns3::NetDeviceContainer::NetDeviceContainer(ns3::NetDeviceContainer const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::NetDeviceContainer&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::NetDeviceContainer const &', 'arg0')])
     ## net-device-container.h: ns3::NetDeviceContainer::NetDeviceContainer() [constructor]
     cls.add_constructor([])
     ## 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]
@@ -341,30 +341,30 @@
 
 def register_Ns3CsmaHelper_methods(root_module, cls):
     ## csma-helper.h: ns3::CsmaHelper::CsmaHelper(ns3::CsmaHelper const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::CsmaHelper&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::CsmaHelper const &', 'arg0')])
     ## csma-helper.h: ns3::CsmaHelper::CsmaHelper() [constructor]
     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)])
+                   [param('std::string', 'type'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue const &', 'v1', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue const &', 'v2', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue const &', 'v3', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue const &', 'v4', default_value='ns3::EmptyAttributeValue()')])
     ## 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)])
+                   [param('std::string', 'n1'), param('ns3::AttributeValue const &', 'v1')])
     ## 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)])
+                   [param('std::string', 'n1'), param('ns3::AttributeValue const &', 'v1')])
     ## 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)], 
+                   [param('std::string', 'n1'), param('ns3::AttributeValue const &', 'v1')], 
                    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)], 
+                   [param('std::string', 'n1'), param('ns3::AttributeValue const &', 'v1')], 
                    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', 
@@ -389,42 +389,42 @@
     ## 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')], 
+                   [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')], 
+                   [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')], 
+                   [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')], 
+                   [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)])
+                   [param('ns3::NodeContainer const &', 'c')])
     ## 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')])
+                   [param('ns3::NodeContainer const &', 'c'), param('ns3::Ptr< ns3::CsmaChannel >', 'channel')])
     return
 
 def register_Ns3UdpEchoServerHelper_methods(root_module, cls):
     ## udp-echo-helper.h: ns3::UdpEchoServerHelper::UdpEchoServerHelper(ns3::UdpEchoServerHelper const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::UdpEchoServerHelper&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::UdpEchoServerHelper const &', 'arg0')])
     ## udp-echo-helper.h: ns3::UdpEchoServerHelper::UdpEchoServerHelper(uint16_t port) [constructor]
     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)])
+                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
     ## udp-echo-helper.h: ns3::ApplicationContainer ns3::UdpEchoServerHelper::Install(ns3::NodeContainer c) [member function]
     cls.add_method('Install', 
                    'ns3::ApplicationContainer', 
@@ -433,13 +433,13 @@
 
 def register_Ns3OlsrHelper_methods(root_module, cls):
     ## olsr-helper.h: ns3::OlsrHelper::OlsrHelper(ns3::OlsrHelper const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::OlsrHelper&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::OlsrHelper const &', 'arg0')])
     ## olsr-helper.h: ns3::OlsrHelper::OlsrHelper() [constructor]
     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)])
+                   [param('std::string', 'tid'), param('std::string', 'n0', default_value='""'), param('ns3::AttributeValue const &', 'v0', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue const &', 'v1', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue const &', 'v2', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue const &', 'v3', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue const &', 'v4', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue const &', 'v5', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue const &', 'v6', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue const &', 'v7', default_value='ns3::EmptyAttributeValue()')])
     ## olsr-helper.h: void ns3::OlsrHelper::Install(ns3::NodeContainer container) [member function]
     cls.add_method('Install', 
                    'void', 
@@ -456,7 +456,7 @@
 
 def register_Ns3PacketSocketHelper_methods(root_module, cls):
     ## packet-socket-helper.h: ns3::PacketSocketHelper::PacketSocketHelper(ns3::PacketSocketHelper const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::PacketSocketHelper&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::PacketSocketHelper const &', 'arg0')])
     ## packet-socket-helper.h: ns3::PacketSocketHelper::PacketSocketHelper() [constructor]
     cls.add_constructor([])
     ## packet-socket-helper.h: void ns3::PacketSocketHelper::Install(ns3::NodeContainer c) [member function]
@@ -467,13 +467,13 @@
 
 def register_Ns3OnOffHelper_methods(root_module, cls):
     ## on-off-helper.h: ns3::OnOffHelper::OnOffHelper(ns3::OnOffHelper const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::OnOffHelper&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::OnOffHelper const &', 'arg0')])
     ## 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')])
     ## 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)])
+                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
     ## on-off-helper.h: ns3::ApplicationContainer ns3::OnOffHelper::Install(ns3::NodeContainer c) [member function]
     cls.add_method('Install', 
                    'ns3::ApplicationContainer', 
@@ -482,13 +482,13 @@
 
 def register_Ns3UdpEchoClientHelper_methods(root_module, cls):
     ## udp-echo-helper.h: ns3::UdpEchoClientHelper::UdpEchoClientHelper(ns3::UdpEchoClientHelper const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::UdpEchoClientHelper&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::UdpEchoClientHelper const &', 'arg0')])
     ## 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')])
     ## 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)])
+                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
     ## udp-echo-helper.h: ns3::ApplicationContainer ns3::UdpEchoClientHelper::Install(ns3::NodeContainer c) [member function]
     cls.add_method('Install', 
                    'ns3::ApplicationContainer', 
@@ -497,7 +497,7 @@
 
 def register_Ns3StaticMulticastRouteHelper_methods(root_module, cls):
     ## static-multicast-route-helper.h: ns3::StaticMulticastRouteHelper::StaticMulticastRouteHelper(ns3::StaticMulticastRouteHelper const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::StaticMulticastRouteHelper&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::StaticMulticastRouteHelper const &', 'arg0')])
     ## static-multicast-route-helper.h: ns3::StaticMulticastRouteHelper::StaticMulticastRouteHelper() [constructor]
     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]
@@ -516,7 +516,7 @@
 
 def register_Ns3Ipv4InterfaceContainer_methods(root_module, cls):
     ## ipv4-interface-container.h: ns3::Ipv4InterfaceContainer::Ipv4InterfaceContainer(ns3::Ipv4InterfaceContainer const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Ipv4InterfaceContainer&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Ipv4InterfaceContainer const &', 'arg0')])
     ## ipv4-interface-container.h: ns3::Ipv4InterfaceContainer::Ipv4InterfaceContainer() [constructor]
     cls.add_constructor([])
     ## ipv4-interface-container.h: uint32_t ns3::Ipv4InterfaceContainer::GetN() const [member function]
@@ -541,7 +541,7 @@
 
 def register_Ns3ApplicationContainer_methods(root_module, cls):
     ## application-container.h: ns3::ApplicationContainer::ApplicationContainer(ns3::ApplicationContainer const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::ApplicationContainer&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::ApplicationContainer const &', 'arg0')])
     ## application-container.h: ns3::ApplicationContainer::ApplicationContainer() [constructor]
     cls.add_constructor([])
     ## 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]
@@ -584,21 +584,21 @@
 
 def register_Ns3WifiHelper_methods(root_module, cls):
     ## wifi-helper.h: ns3::WifiHelper::WifiHelper(ns3::WifiHelper const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::WifiHelper&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::WifiHelper const &', 'arg0')])
     ## wifi-helper.h: ns3::WifiHelper::WifiHelper() [constructor]
     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)])
+                   [param('std::string', 'type'), param('std::string', 'n0', default_value='""'), param('ns3::AttributeValue const &', 'v0', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue const &', 'v1', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue const &', 'v2', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue const &', 'v3', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue const &', 'v4', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue const &', 'v5', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue const &', 'v6', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue const &', 'v7', default_value='ns3::EmptyAttributeValue()')])
     ## 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)])
+                   [param('std::string', 'type'), param('std::string', 'n0', default_value='""'), param('ns3::AttributeValue const &', 'v0', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue const &', 'v1', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue const &', 'v2', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue const &', 'v3', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue const &', 'v4', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue const &', 'v5', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue const &', 'v6', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue const &', 'v7', default_value='ns3::EmptyAttributeValue()')])
     ## 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)])
+                   [param('std::string', 'phyType'), param('std::string', 'n0', default_value='""'), param('ns3::AttributeValue const &', 'v0', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue const &', 'v1', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue const &', 'v2', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue const &', 'v3', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue const &', 'v4', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue const &', 'v5', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue const &', 'v6', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue const &', 'v7', default_value='ns3::EmptyAttributeValue()')])
     ## wifi-helper.h: static void ns3::WifiHelper::EnablePcap(std::string filename, uint32_t nodeid, uint32_t deviceid) [member function]
     cls.add_method('EnablePcap', 
                    'void', 
@@ -622,22 +622,22 @@
     ## 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')], 
+                   [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')], 
+                   [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')], 
+                   [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')], 
+                   [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', 
@@ -653,7 +653,7 @@
 
 def register_Ns3Ipv4AddressHelper_methods(root_module, cls):
     ## ipv4-address-helper.h: ns3::Ipv4AddressHelper::Ipv4AddressHelper(ns3::Ipv4AddressHelper const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Ipv4AddressHelper&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Ipv4AddressHelper const &', 'arg0')])
     ## ipv4-address-helper.h: ns3::Ipv4AddressHelper::Ipv4AddressHelper() [constructor]
     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]
@@ -671,18 +671,18 @@
     ## 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)])
+                   [param('ns3::NetDeviceContainer const &', 'c')])
     return
 
 def register_Ns3BridgeHelper_methods(root_module, cls):
     ## bridge-helper.h: ns3::BridgeHelper::BridgeHelper(ns3::BridgeHelper const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::BridgeHelper&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::BridgeHelper const &', 'arg0')])
     ## bridge-helper.h: ns3::BridgeHelper::BridgeHelper() [constructor]
     cls.add_constructor([])
     ## bridge-helper.h: void ns3::BridgeHelper::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)])
+                   [param('std::string', 'n1'), param('ns3::AttributeValue const &', 'v1')])
     ## bridge-helper.h: ns3::NetDeviceContainer ns3::BridgeHelper::Install(ns3::Ptr<ns3::Node> node, ns3::NetDeviceContainer c) [member function]
     cls.add_method('Install', 
                    'ns3::NetDeviceContainer', 
@@ -691,13 +691,13 @@
 
 def register_Ns3PacketSinkHelper_methods(root_module, cls):
     ## packet-sink-helper.h: ns3::PacketSinkHelper::PacketSinkHelper(ns3::PacketSinkHelper const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::PacketSinkHelper&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::PacketSinkHelper const &', 'arg0')])
     ## 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')])
     ## 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)])
+                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
     ## packet-sink-helper.h: ns3::ApplicationContainer ns3::PacketSinkHelper::Install(ns3::NodeContainer c) [member function]
     cls.add_method('Install', 
                    'ns3::ApplicationContainer', 
@@ -706,7 +706,7 @@
 
 def register_Ns3Ns2MobilityHelper_methods(root_module, cls):
     ## ns2-mobility-helper.h: ns3::Ns2MobilityHelper::Ns2MobilityHelper(ns3::Ns2MobilityHelper const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Ns2MobilityHelper&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Ns2MobilityHelper const &', 'arg0')])
     ## ns2-mobility-helper.h: ns3::Ns2MobilityHelper::Ns2MobilityHelper(std::string filename) [constructor]
     cls.add_constructor([param('std::string', 'filename')])
     ## ns2-mobility-helper.h: void ns3::Ns2MobilityHelper::Install() const [member function]
--- a/bindings/python/ns3_module_internet_stack.py	Sun Aug 31 22:33:23 2008 +0100
+++ b/bindings/python/ns3_module_internet_stack.py	Tue Sep 02 11:12:42 2008 +0100
@@ -66,7 +66,7 @@
 
 def register_Ns3Ipv4Interface_methods(root_module, cls):
     ## ipv4-interface.h: ns3::Ipv4Interface::Ipv4Interface(ns3::Ipv4Interface const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Ipv4Interface&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Ipv4Interface const &', 'arg0')])
     ## ipv4-interface.h: static ns3::TypeId ns3::Ipv4Interface::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -152,7 +152,7 @@
 
 def register_Ns3UdpHeader_methods(root_module, cls):
     ## udp-header.h: ns3::UdpHeader::UdpHeader(ns3::UdpHeader const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::UdpHeader&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::UdpHeader const &', 'arg0')])
     ## udp-header.h: ns3::UdpHeader::UdpHeader() [constructor]
     cls.add_constructor([])
     ## udp-header.h: void ns3::UdpHeader::EnableChecksums() [member function]
@@ -194,7 +194,7 @@
     ## udp-header.h: void ns3::UdpHeader::Print(std::ostream & os) const [member function]
     cls.add_method('Print', 
                    'void', 
-                   [param('std::ostream&', 'os')], 
+                   [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', 
@@ -220,7 +220,7 @@
 
 def register_Ns3TcpHeader_methods(root_module, cls):
     ## tcp-header.h: ns3::TcpHeader::TcpHeader(ns3::TcpHeader const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::TcpHeader&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::TcpHeader const &', 'arg0')])
     ## tcp-header.h: ns3::TcpHeader::TcpHeader() [constructor]
     cls.add_constructor([])
     ## tcp-header.h: void ns3::TcpHeader::EnableChecksums() [member function]
@@ -316,7 +316,7 @@
     ## tcp-header.h: void ns3::TcpHeader::Print(std::ostream & os) const [member function]
     cls.add_method('Print', 
                    'void', 
-                   [param('std::ostream&', 'os')], 
+                   [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', 
@@ -342,18 +342,18 @@
 
 def register_Ns3Ipv4StaticRouting_methods(root_module, cls):
     ## ipv4-static-routing.h: ns3::Ipv4StaticRouting::Ipv4StaticRouting(ns3::Ipv4StaticRouting const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Ipv4StaticRouting&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Ipv4StaticRouting const &', 'arg0')])
     ## ipv4-static-routing.h: ns3::Ipv4StaticRouting::Ipv4StaticRouting() [constructor]
     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')], 
+                   [param('uint32_t', 'ifIndex'), param('ns3::Ipv4Header const &', 'ipHeader'), 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')], 
+                   [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', 
@@ -431,9 +431,9 @@
 
 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)
+    cls.add_static_attribute('PROT_NUMBER', 'uint16_t const', is_const=True)
     ## ipv4-l3-protocol.h: ns3::Ipv4L3Protocol::Ipv4L3Protocol(ns3::Ipv4L3Protocol const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Ipv4L3Protocol&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Ipv4L3Protocol const &', 'arg0')])
     ## ipv4-l3-protocol.h: static ns3::TypeId ns3::Ipv4L3Protocol::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -456,7 +456,7 @@
     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::Receive(ns3::Ptr<ns3::NetDevice> device, ns3::Ptr<const 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< const 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')])
+                   [param('ns3::Ptr< ns3::NetDevice >', 'device'), param('ns3::Ptr< const ns3::Packet >', 'p'), param('uint16_t', 'protocol'), param('ns3::Address const &', 'from'), param('ns3::Address const &', 'to'), 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', 
@@ -484,7 +484,7 @@
     ## 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')])
+                   [param('ns3::Ipv4Header const &', 'ipHeader'), 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', 
@@ -590,7 +590,7 @@
     ## 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')], 
+                   [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', 
--- a/bindings/python/ns3_module_mobility.py	Sun Aug 31 22:33:23 2008 +0100
+++ b/bindings/python/ns3_module_mobility.py	Tue Sep 02 11:12:42 2008 +0100
@@ -19,10 +19,10 @@
     module.add_class('PositionAllocator', parent=root_module['ns3::Object'])
     ## position-allocator.h: ns3::ListPositionAllocator [class]
     module.add_class('ListPositionAllocator', parent=root_module['ns3::PositionAllocator'])
+    ## position-allocator.h: ns3::RandomRectanglePositionAllocator [class]
+    module.add_class('RandomRectanglePositionAllocator', parent=root_module['ns3::PositionAllocator'])
     ## rectangle.h: ns3::RectangleValue [class]
     module.add_class('RectangleValue', parent=root_module['ns3::AttributeValue'])
-    ## position-allocator.h: ns3::RandomRectanglePositionAllocator [class]
-    module.add_class('RandomRectanglePositionAllocator', parent=root_module['ns3::PositionAllocator'])
     ## vector.h: ns3::VectorValue [class]
     module.add_class('VectorValue', parent=root_module['ns3::AttributeValue'])
     ## position-allocator.h: ns3::RandomDiscPositionAllocator [class]
@@ -96,8 +96,8 @@
     register_Ns3Rectangle_methods(root_module, root_module['ns3::Rectangle'])
     register_Ns3PositionAllocator_methods(root_module, root_module['ns3::PositionAllocator'])
     register_Ns3ListPositionAllocator_methods(root_module, root_module['ns3::ListPositionAllocator'])
+    register_Ns3RandomRectanglePositionAllocator_methods(root_module, root_module['ns3::RandomRectanglePositionAllocator'])
     register_Ns3RectangleValue_methods(root_module, root_module['ns3::RectangleValue'])
-    register_Ns3RandomRectanglePositionAllocator_methods(root_module, root_module['ns3::RandomRectanglePositionAllocator'])
     register_Ns3VectorValue_methods(root_module, root_module['ns3::VectorValue'])
     register_Ns3RandomDiscPositionAllocator_methods(root_module, root_module['ns3::RandomDiscPositionAllocator'])
     register_Ns3MobilityModel_methods(root_module, root_module['ns3::MobilityModel'])
@@ -112,25 +112,25 @@
 
 def register_Ns3StaticSpeedHelper_methods(root_module, cls):
     ## static-speed-helper.h: ns3::StaticSpeedHelper::StaticSpeedHelper(ns3::StaticSpeedHelper const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::StaticSpeedHelper&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::StaticSpeedHelper const &', 'arg0')])
     ## static-speed-helper.h: ns3::StaticSpeedHelper::StaticSpeedHelper() [constructor]
     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)])
+    cls.add_constructor([param('ns3::Vector const &', 'position')])
     ## 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)])
+    cls.add_constructor([param('ns3::Vector const &', 'position'), param('ns3::Vector const &', 'speed')])
     ## 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)])
+                   [param('ns3::Vector const &', 'position')])
     ## 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)])
+                   [param('ns3::Vector const &', 'speed')])
     ## 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)], 
+                   [param('ns3::Rectangle const &', 'bounds')], 
                    is_const=True)
     ## static-speed-helper.h: ns3::Vector ns3::StaticSpeedHelper::GetCurrentPosition() const [member function]
     cls.add_method('GetCurrentPosition', 
@@ -145,7 +145,7 @@
     ## 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)])
+                   [param('ns3::Vector const &', 'speed')])
     ## static-speed-helper.h: void ns3::StaticSpeedHelper::Pause() [member function]
     cls.add_method('Pause', 
                    'void', 
@@ -158,7 +158,7 @@
 
 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)])
+    cls.add_constructor([param('ns3::Vector const &', 'arg0')])
     ## vector.h: ns3::Vector::Vector(double _x, double _y, double _z) [constructor]
     cls.add_constructor([param('double', '_x'), param('double', '_y'), param('double', '_z')])
     ## vector.h: ns3::Vector::Vector() [constructor]
@@ -174,21 +174,21 @@
 
 def register_Ns3VectorChecker_methods(root_module, cls):
     ## vector.h: ns3::VectorChecker::VectorChecker(ns3::VectorChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::VectorChecker&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::VectorChecker const &', 'arg0')])
     ## vector.h: ns3::VectorChecker::VectorChecker() [constructor]
     cls.add_constructor([])
     return
 
 def register_Ns3RectangleChecker_methods(root_module, cls):
     ## rectangle.h: ns3::RectangleChecker::RectangleChecker(ns3::RectangleChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::RectangleChecker&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::RectangleChecker const &', 'arg0')])
     ## rectangle.h: ns3::RectangleChecker::RectangleChecker() [constructor]
     cls.add_constructor([])
     return
 
 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)])
+    cls.add_constructor([param('ns3::Rectangle const &', 'arg0')])
     ## 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')])
     ## rectangle.h: ns3::Rectangle::Rectangle() [constructor]
@@ -196,17 +196,17 @@
     ## 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)], 
+                   [param('ns3::Vector const &', 'current'), param('ns3::Vector const &', 'speed')], 
                    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)], 
+                   [param('ns3::Vector const &', 'position')], 
                    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)], 
+                   [param('ns3::Vector const &', 'position')], 
                    is_const=True)
     ## rectangle.h: ns3::Rectangle::xMax [variable]
     cls.add_instance_attribute('xMax', 'double', is_const=False)
@@ -221,7 +221,7 @@
 
 def register_Ns3PositionAllocator_methods(root_module, cls):
     ## position-allocator.h: ns3::PositionAllocator::PositionAllocator(ns3::PositionAllocator const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::PositionAllocator&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::PositionAllocator const &', 'arg0')])
     ## position-allocator.h: static ns3::TypeId ns3::PositionAllocator::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -238,7 +238,7 @@
 
 def register_Ns3ListPositionAllocator_methods(root_module, cls):
     ## position-allocator.h: ns3::ListPositionAllocator::ListPositionAllocator(ns3::ListPositionAllocator const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::ListPositionAllocator&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::ListPositionAllocator const &', 'arg0')])
     ## position-allocator.h: static ns3::TypeId ns3::ListPositionAllocator::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -257,17 +257,42 @@
                    is_const=True, is_virtual=True)
     return
 
+def register_Ns3RandomRectanglePositionAllocator_methods(root_module, cls):
+    ## position-allocator.h: ns3::RandomRectanglePositionAllocator::RandomRectanglePositionAllocator(ns3::RandomRectanglePositionAllocator const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::RandomRectanglePositionAllocator const &', 'arg0')])
+    ## position-allocator.h: static ns3::TypeId ns3::RandomRectanglePositionAllocator::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## position-allocator.h: ns3::RandomRectanglePositionAllocator::RandomRectanglePositionAllocator() [constructor]
+    cls.add_constructor([])
+    ## position-allocator.h: void ns3::RandomRectanglePositionAllocator::SetX(ns3::RandomVariable x) [member function]
+    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')])
+    ## position-allocator.h: ns3::Vector ns3::RandomRectanglePositionAllocator::GetNext() const [member function]
+    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(ns3::RectangleValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::RectangleValue&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::RectangleValue const &', 'arg0')])
     ## rectangle.h: ns3::RectangleValue::RectangleValue() [constructor]
     cls.add_constructor([])
     ## rectangle.h: ns3::RectangleValue::RectangleValue(ns3::Rectangle const & value) [constructor]
-    cls.add_constructor([param('ns3::Rectangle&', 'value', is_const=True)])
+    cls.add_constructor([param('ns3::Rectangle const &', 'value')])
     ## rectangle.h: void ns3::RectangleValue::Set(ns3::Rectangle const & value) [member function]
     cls.add_method('Set', 
                    'void', 
-                   [param('ns3::Rectangle&', 'value', is_const=True)])
+                   [param('ns3::Rectangle const &', 'value')])
     ## rectangle.h: ns3::Rectangle ns3::RectangleValue::Get() const [member function]
     cls.add_method('Get', 
                    'ns3::Rectangle', 
@@ -290,42 +315,17 @@
                    is_virtual=True)
     return
 
-def register_Ns3RandomRectanglePositionAllocator_methods(root_module, cls):
-    ## position-allocator.h: ns3::RandomRectanglePositionAllocator::RandomRectanglePositionAllocator(ns3::RandomRectanglePositionAllocator const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::RandomRectanglePositionAllocator&', 'arg0', is_const=True)])
-    ## position-allocator.h: static ns3::TypeId ns3::RandomRectanglePositionAllocator::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 
-                   'ns3::TypeId', 
-                   [], 
-                   is_static=True)
-    ## position-allocator.h: ns3::RandomRectanglePositionAllocator::RandomRectanglePositionAllocator() [constructor]
-    cls.add_constructor([])
-    ## position-allocator.h: void ns3::RandomRectanglePositionAllocator::SetX(ns3::RandomVariable x) [member function]
-    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')])
-    ## position-allocator.h: ns3::Vector ns3::RandomRectanglePositionAllocator::GetNext() const [member function]
-    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(ns3::VectorValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::VectorValue&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::VectorValue const &', 'arg0')])
     ## vector.h: ns3::VectorValue::VectorValue() [constructor]
     cls.add_constructor([])
     ## vector.h: ns3::VectorValue::VectorValue(ns3::Vector const & value) [constructor]
-    cls.add_constructor([param('ns3::Vector&', 'value', is_const=True)])
+    cls.add_constructor([param('ns3::Vector const &', 'value')])
     ## vector.h: void ns3::VectorValue::Set(ns3::Vector const & value) [member function]
     cls.add_method('Set', 
                    'void', 
-                   [param('ns3::Vector&', 'value', is_const=True)])
+                   [param('ns3::Vector const &', 'value')])
     ## vector.h: ns3::Vector ns3::VectorValue::Get() const [member function]
     cls.add_method('Get', 
                    'ns3::Vector', 
@@ -350,7 +350,7 @@
 
 def register_Ns3RandomDiscPositionAllocator_methods(root_module, cls):
     ## position-allocator.h: ns3::RandomDiscPositionAllocator::RandomDiscPositionAllocator(ns3::RandomDiscPositionAllocator const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::RandomDiscPositionAllocator&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::RandomDiscPositionAllocator const &', 'arg0')])
     ## position-allocator.h: static ns3::TypeId ns3::RandomDiscPositionAllocator::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -383,7 +383,7 @@
 
 def register_Ns3MobilityModel_methods(root_module, cls):
     ## mobility-model.h: ns3::MobilityModel::MobilityModel(ns3::MobilityModel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::MobilityModel&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::MobilityModel const &', 'arg0')])
     ## mobility-model.h: static ns3::TypeId ns3::MobilityModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -399,7 +399,7 @@
     ## 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)])
+                   [param('ns3::Vector const &', 'position')])
     ## mobility-model.h: ns3::Vector ns3::MobilityModel::GetVelocity() const [member function]
     cls.add_method('GetVelocity', 
                    'ns3::Vector', 
@@ -423,7 +423,7 @@
     ## 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)], 
+                   [param('ns3::Vector const &', 'position')], 
                    is_pure_virtual=True, visibility='private', is_virtual=True)
     ## mobility-model.h: ns3::Vector ns3::MobilityModel::DoGetVelocity() const [member function]
     cls.add_method('DoGetVelocity', 
@@ -434,7 +434,7 @@
 
 def register_Ns3RandomDirection2dMobilityModel_methods(root_module, cls):
     ## random-direction-2d-mobility-model.h: ns3::RandomDirection2dMobilityModel::RandomDirection2dMobilityModel(ns3::RandomDirection2dMobilityModel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::RandomDirection2dMobilityModel&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::RandomDirection2dMobilityModel const &', 'arg0')])
     ## random-direction-2d-mobility-model.h: static ns3::TypeId ns3::RandomDirection2dMobilityModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -455,7 +455,7 @@
     ## 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)], 
+                   [param('ns3::Vector const &', 'position')], 
                    visibility='private', is_virtual=True)
     ## random-direction-2d-mobility-model.h: ns3::Vector ns3::RandomDirection2dMobilityModel::DoGetVelocity() const [member function]
     cls.add_method('DoGetVelocity', 
@@ -466,7 +466,7 @@
 
 def register_Ns3GridPositionAllocator_methods(root_module, cls):
     ## position-allocator.h: ns3::GridPositionAllocator::GridPositionAllocator(ns3::GridPositionAllocator const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::GridPositionAllocator&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::GridPositionAllocator const &', 'arg0')])
     ## position-allocator.h: static ns3::TypeId ns3::GridPositionAllocator::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -537,7 +537,7 @@
 
 def register_Ns3RandomWaypointMobilityModel_methods(root_module, cls):
     ## random-waypoint-mobility-model.h: ns3::RandomWaypointMobilityModel::RandomWaypointMobilityModel(ns3::RandomWaypointMobilityModel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::RandomWaypointMobilityModel&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::RandomWaypointMobilityModel const &', 'arg0')])
     ## random-waypoint-mobility-model.h: static ns3::TypeId ns3::RandomWaypointMobilityModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -553,7 +553,7 @@
     ## 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)], 
+                   [param('ns3::Vector const &', 'position')], 
                    visibility='private', is_virtual=True)
     ## random-waypoint-mobility-model.h: ns3::Vector ns3::RandomWaypointMobilityModel::DoGetVelocity() const [member function]
     cls.add_method('DoGetVelocity', 
@@ -564,7 +564,7 @@
 
 def register_Ns3RandomWalk2dMobilityModel_methods(root_module, cls):
     ## random-walk-2d-mobility-model.h: ns3::RandomWalk2dMobilityModel::RandomWalk2dMobilityModel(ns3::RandomWalk2dMobilityModel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::RandomWalk2dMobilityModel&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::RandomWalk2dMobilityModel const &', 'arg0')])
     ## random-walk-2d-mobility-model.h: static ns3::TypeId ns3::RandomWalk2dMobilityModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -585,7 +585,7 @@
     ## 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)], 
+                   [param('ns3::Vector const &', 'position')], 
                    visibility='private', is_virtual=True)
     ## random-walk-2d-mobility-model.h: ns3::Vector ns3::RandomWalk2dMobilityModel::DoGetVelocity() const [member function]
     cls.add_method('DoGetVelocity', 
@@ -596,7 +596,7 @@
 
 def register_Ns3StaticSpeedMobilityModel_methods(root_module, cls):
     ## static-speed-mobility-model.h: ns3::StaticSpeedMobilityModel::StaticSpeedMobilityModel(ns3::StaticSpeedMobilityModel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::StaticSpeedMobilityModel&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::StaticSpeedMobilityModel const &', 'arg0')])
     ## static-speed-mobility-model.h: static ns3::TypeId ns3::StaticSpeedMobilityModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -607,7 +607,7 @@
     ## 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)])
+                   [param('ns3::Vector const &', 'speed')])
     ## static-speed-mobility-model.h: ns3::Vector ns3::StaticSpeedMobilityModel::DoGetPosition() const [member function]
     cls.add_method('DoGetPosition', 
                    'ns3::Vector', 
@@ -616,7 +616,7 @@
     ## 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)], 
+                   [param('ns3::Vector const &', 'position')], 
                    visibility='private', is_virtual=True)
     ## static-speed-mobility-model.h: ns3::Vector ns3::StaticSpeedMobilityModel::DoGetVelocity() const [member function]
     cls.add_method('DoGetVelocity', 
@@ -627,7 +627,7 @@
 
 def register_Ns3HierarchicalMobilityModel_methods(root_module, cls):
     ## hierarchical-mobility-model.h: ns3::HierarchicalMobilityModel::HierarchicalMobilityModel(ns3::HierarchicalMobilityModel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::HierarchicalMobilityModel&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::HierarchicalMobilityModel const &', 'arg0')])
     ## hierarchical-mobility-model.h: static ns3::TypeId ns3::HierarchicalMobilityModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -653,7 +653,7 @@
     ## 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)], 
+                   [param('ns3::Vector const &', 'position')], 
                    visibility='private', is_virtual=True)
     ## hierarchical-mobility-model.h: ns3::Vector ns3::HierarchicalMobilityModel::DoGetVelocity() const [member function]
     cls.add_method('DoGetVelocity', 
@@ -664,7 +664,7 @@
 
 def register_Ns3StaticMobilityModel_methods(root_module, cls):
     ## static-mobility-model.h: ns3::StaticMobilityModel::StaticMobilityModel(ns3::StaticMobilityModel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::StaticMobilityModel&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::StaticMobilityModel const &', 'arg0')])
     ## static-mobility-model.h: static ns3::TypeId ns3::StaticMobilityModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -680,7 +680,7 @@
     ## 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)], 
+                   [param('ns3::Vector const &', 'position')], 
                    visibility='private', is_virtual=True)
     ## static-mobility-model.h: ns3::Vector ns3::StaticMobilityModel::DoGetVelocity() const [member function]
     cls.add_method('DoGetVelocity', 
@@ -698,7 +698,7 @@
     ## 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)])
+                        [param('ns3::Vector const &', 'a'), param('ns3::Vector const &', 'b')])
     ## vector.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeVectorChecker() [free function]
     module.add_function('MakeVectorChecker', 
                         'ns3::Ptr< ns3::AttributeChecker const >', 
--- a/bindings/python/ns3_module_node.py	Sun Aug 31 22:33:23 2008 +0100
+++ b/bindings/python/ns3_module_node.py	Tue Sep 02 11:12:42 2008 +0100
@@ -193,13 +193,13 @@
 
 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)])
+    cls.add_constructor([param('ns3::Ipv4Mask const &', 'arg0')])
     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask() [constructor]
     cls.add_constructor([])
     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(uint32_t mask) [constructor]
     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)])
+    cls.add_constructor([param('char const *', 'mask')])
     ## ipv4-address.h: uint32_t ns3::Ipv4Mask::Get() const [member function]
     cls.add_method('Get', 
                    'uint32_t', 
@@ -233,7 +233,7 @@
     ## ipv4-address.h: void ns3::Ipv4Mask::Print(std::ostream & os) const [member function]
     cls.add_method('Print', 
                    'void', 
-                   [param('std::ostream&', 'os')], 
+                   [param('std::ostream &', 'os')], 
                    is_const=True)
     ## ipv4-address.h: void ns3::Ipv4Mask::Set(uint32_t mask) [member function]
     cls.add_method('Set', 
@@ -244,7 +244,7 @@
 
 def register_Ns3NodeList_methods(root_module, cls):
     ## node-list.h: ns3::NodeList::NodeList(ns3::NodeList const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::NodeList&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::NodeList const &', 'arg0')])
     ## node-list.h: ns3::NodeList::NodeList() [constructor]
     cls.add_constructor([])
     ## node-list.h: static uint32_t ns3::NodeList::Add(ns3::Ptr<ns3::Node> node) [member function]
@@ -278,9 +278,9 @@
     ## address.h: ns3::Address::Address() [constructor]
     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')])
+    cls.add_constructor([param('uint8_t', 'type'), param('uint8_t const *', 'buffer'), 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)])
+    cls.add_constructor([param('ns3::Address const &', 'address')])
     ## address.h: bool ns3::Address::CheckCompatible(uint8_t type, uint8_t len) const [member function]
     cls.add_method('CheckCompatible', 
                    'bool', 
@@ -289,7 +289,7 @@
     ## 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')])
+                   [param('uint8_t const *', 'buffer'), 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', 
@@ -298,7 +298,7 @@
     ## 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')])
+                   [param('uint8_t const *', 'buffer'), param('uint8_t', 'len')])
     ## address.h: uint32_t ns3::Address::CopyTo(uint8_t * buffer) const [member function]
     cls.add_method('CopyTo', 
                    'uint32_t', 
@@ -343,18 +343,18 @@
 
 def register_Ns3Ipv4AddressChecker_methods(root_module, cls):
     ## ipv4-address.h: ns3::Ipv4AddressChecker::Ipv4AddressChecker(ns3::Ipv4AddressChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Ipv4AddressChecker&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Ipv4AddressChecker const &', 'arg0')])
     ## ipv4-address.h: ns3::Ipv4AddressChecker::Ipv4AddressChecker() [constructor]
     cls.add_constructor([])
     return
 
 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)])
+    cls.add_constructor([param('ns3::Mac48Address const &', 'arg0')])
     ## mac48-address.h: ns3::Mac48Address::Mac48Address() [constructor]
     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)])
+    cls.add_constructor([param('char const *', 'str')])
     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::Allocate() [member function]
     cls.add_method('Allocate', 
                    'ns3::Mac48Address', 
@@ -363,12 +363,12 @@
     ## 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)], 
+                   [param('ns3::Address const &', 'address')], 
                    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)])
+                   [param('uint8_t const *', 'buffer')])
     ## mac48-address.h: void ns3::Mac48Address::CopyTo(uint8_t * buffer) const [member function]
     cls.add_method('CopyTo', 
                    'void', 
@@ -402,7 +402,7 @@
     ## 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)], 
+                   [param('ns3::Address const &', 'address')], 
                    is_static=True)
     ## mac48-address.h: bool ns3::Mac48Address::IsMulticast() const [member function]
     cls.add_method('IsMulticast', 
@@ -414,11 +414,11 @@
 
 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)])
+    cls.add_constructor([param('ns3::Mac64Address const &', 'arg0')])
     ## mac64-address.h: ns3::Mac64Address::Mac64Address() [constructor]
     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)])
+    cls.add_constructor([param('char const *', 'str')])
     ## mac64-address.h: static ns3::Mac64Address ns3::Mac64Address::Allocate() [member function]
     cls.add_method('Allocate', 
                    'ns3::Mac64Address', 
@@ -427,12 +427,12 @@
     ## 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)], 
+                   [param('ns3::Address const &', 'address')], 
                    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)])
+                   [param('uint8_t const *', 'buffer')])
     ## mac64-address.h: void ns3::Mac64Address::CopyTo(uint8_t * buffer) const [member function]
     cls.add_method('CopyTo', 
                    'void', 
@@ -441,45 +441,45 @@
     ## 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)], 
+                   [param('ns3::Address const &', 'address')], 
                    is_static=True)
     cls.add_output_stream_operator()
     return
 
 def register_Ns3Ipv4AddressGenerator_methods(root_module, cls):
     ## ipv4-address-generator.h: ns3::Ipv4AddressGenerator::Ipv4AddressGenerator(ns3::Ipv4AddressGenerator const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Ipv4AddressGenerator&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Ipv4AddressGenerator const &', 'arg0')])
     ## ipv4-address-generator.h: ns3::Ipv4AddressGenerator::Ipv4AddressGenerator() [constructor]
     cls.add_constructor([])
     ## 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)], 
+                   [param('ns3::Ipv4Address const', 'net'), param('ns3::Ipv4Mask const', 'mask'), param('ns3::Ipv4Address const', 'addr', default_value='"0.0.0.1"')], 
                    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)], 
+                   [param('ns3::Ipv4Mask const', 'mask')], 
                    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)], 
+                   [param('ns3::Ipv4Mask const', 'mask')], 
                    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)], 
+                   [param('ns3::Ipv4Address const', 'addr'), param('ns3::Ipv4Mask const', 'mask')], 
                    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)], 
+                   [param('ns3::Ipv4Mask const', 'mask')], 
                    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)], 
+                   [param('ns3::Ipv4Mask const', 'mask')], 
                    is_static=True)
     ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::Reset() [member function]
     cls.add_method('Reset', 
@@ -489,7 +489,7 @@
     ## 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)], 
+                   [param('ns3::Ipv4Address const', 'addr')], 
                    is_static=True)
     ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::TestMode() [member function]
     cls.add_method('TestMode', 
@@ -500,14 +500,14 @@
 
 def register_Ns3Mac48AddressChecker_methods(root_module, cls):
     ## mac48-address.h: ns3::Mac48AddressChecker::Mac48AddressChecker(ns3::Mac48AddressChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Mac48AddressChecker&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Mac48AddressChecker const &', 'arg0')])
     ## mac48-address.h: ns3::Mac48AddressChecker::Mac48AddressChecker() [constructor]
     cls.add_constructor([])
     return
 
 def register_Ns3Ipv4MaskChecker_methods(root_module, cls):
     ## ipv4-address.h: ns3::Ipv4MaskChecker::Ipv4MaskChecker(ns3::Ipv4MaskChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Ipv4MaskChecker&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Ipv4MaskChecker const &', 'arg0')])
     ## ipv4-address.h: ns3::Ipv4MaskChecker::Ipv4MaskChecker() [constructor]
     cls.add_constructor([])
     return
@@ -516,9 +516,9 @@
     ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route() [constructor]
     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)])
+    cls.add_constructor([param('ns3::Ipv4Route const &', 'route')])
     ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route(ns3::Ipv4Route const * route) [constructor]
-    cls.add_constructor([param('ns3::Ipv4Route *', 'route', transfer_ownership=False, is_const=True)])
+    cls.add_constructor([param('ns3::Ipv4Route const *', 'route')])
     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateDefaultRoute(ns3::Ipv4Address nextHop, uint32_t interface) [member function]
     cls.add_method('CreateDefaultRoute', 
                    'ns3::Ipv4Route', 
@@ -596,9 +596,9 @@
     ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute() [constructor]
     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)])
+    cls.add_constructor([param('ns3::Ipv4MulticastRoute const &', 'route')])
     ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute(ns3::Ipv4MulticastRoute const * route) [constructor]
-    cls.add_constructor([param('ns3::Ipv4MulticastRoute *', 'route', transfer_ownership=False, is_const=True)])
+    cls.add_constructor([param('ns3::Ipv4MulticastRoute const *', 'route')])
     ## 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', 
@@ -639,14 +639,14 @@
 
 def register_Ns3AddressChecker_methods(root_module, cls):
     ## address.h: ns3::AddressChecker::AddressChecker(ns3::AddressChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::AddressChecker&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::AddressChecker const &', 'arg0')])
     ## address.h: ns3::AddressChecker::AddressChecker() [constructor]
     cls.add_constructor([])
     return
 
 def register_Ns3PacketSocketAddress_methods(root_module, cls):
     ## packet-socket-address.h: ns3::PacketSocketAddress::PacketSocketAddress(ns3::PacketSocketAddress const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::PacketSocketAddress&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::PacketSocketAddress const &', 'arg0')])
     ## packet-socket-address.h: ns3::PacketSocketAddress::PacketSocketAddress() [constructor]
     cls.add_constructor([])
     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetProtocol(uint16_t protocol) [member function]
@@ -664,7 +664,7 @@
     ## 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)])
+                   [param('ns3::Address const', 'address')])
     ## packet-socket-address.h: uint16_t ns3::PacketSocketAddress::GetProtocol() const [member function]
     cls.add_method('GetProtocol', 
                    'uint16_t', 
@@ -688,26 +688,26 @@
     ## 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)], 
+                   [param('ns3::Address const &', 'address')], 
                    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)], 
+                   [param('ns3::Address const &', 'address')], 
                    is_static=True)
     return
 
 def register_Ns3Ipv4AddressValue_methods(root_module, cls):
     ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4AddressValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Ipv4AddressValue&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Ipv4AddressValue const &', 'arg0')])
     ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue() [constructor]
     cls.add_constructor([])
     ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4Address const & value) [constructor]
-    cls.add_constructor([param('ns3::Ipv4Address&', 'value', is_const=True)])
+    cls.add_constructor([param('ns3::Ipv4Address const &', 'value')])
     ## 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)])
+                   [param('ns3::Ipv4Address const &', 'value')])
     ## ipv4-address.h: ns3::Ipv4Address ns3::Ipv4AddressValue::Get() const [member function]
     cls.add_method('Get', 
                    'ns3::Ipv4Address', 
@@ -732,34 +732,34 @@
 
 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)
+    cls.add_static_attribute('IF_INDEX_ANY', 'uint32_t const', is_const=True)
     ## ipv4.h: ns3::Ipv4RoutingProtocol::Ipv4RoutingProtocol(ns3::Ipv4RoutingProtocol const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Ipv4RoutingProtocol&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Ipv4RoutingProtocol const &', 'arg0')])
     ## ipv4.h: ns3::Ipv4RoutingProtocol::Ipv4RoutingProtocol() [constructor]
     cls.add_constructor([])
     ## 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')], 
+                   [param('uint32_t', 'ifIndex'), param('ns3::Ipv4Header const &', 'ipHeader'), 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')], 
+                   [param('ns3::Ipv4Address', 'destination'), param('uint32_t &', 'ifIndex')], 
                    is_pure_virtual=True, is_virtual=True)
     return
 
 def register_Ns3Mac48AddressValue_methods(root_module, cls):
     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48AddressValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Mac48AddressValue&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Mac48AddressValue const &', 'arg0')])
     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue() [constructor]
     cls.add_constructor([])
     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48Address const & value) [constructor]
-    cls.add_constructor([param('ns3::Mac48Address&', 'value', is_const=True)])
+    cls.add_constructor([param('ns3::Mac48Address const &', 'value')])
     ## 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)])
+                   [param('ns3::Mac48Address const &', 'value')])
     ## mac48-address.h: ns3::Mac48Address ns3::Mac48AddressValue::Get() const [member function]
     cls.add_method('Get', 
                    'ns3::Mac48Address', 
@@ -784,15 +784,15 @@
 
 def register_Ns3Ipv4MaskValue_methods(root_module, cls):
     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4MaskValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Ipv4MaskValue&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Ipv4MaskValue const &', 'arg0')])
     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue() [constructor]
     cls.add_constructor([])
     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4Mask const & value) [constructor]
-    cls.add_constructor([param('ns3::Ipv4Mask&', 'value', is_const=True)])
+    cls.add_constructor([param('ns3::Ipv4Mask const &', 'value')])
     ## 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)])
+                   [param('ns3::Ipv4Mask const &', 'value')])
     ## ipv4-address.h: ns3::Ipv4Mask ns3::Ipv4MaskValue::Get() const [member function]
     cls.add_method('Get', 
                    'ns3::Ipv4Mask', 
@@ -817,7 +817,7 @@
 
 def register_Ns3SocketAddressTag_methods(root_module, cls):
     ## socket.h: ns3::SocketAddressTag::SocketAddressTag(ns3::SocketAddressTag const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::SocketAddressTag&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::SocketAddressTag const &', 'arg0')])
     ## socket.h: ns3::SocketAddressTag::SocketAddressTag() [constructor]
     cls.add_constructor([])
     ## socket.h: void ns3::SocketAddressTag::SetAddress(ns3::Address addr) [member function]
@@ -857,13 +857,13 @@
     ## socket.h: void ns3::SocketAddressTag::Print(std::ostream & os) const [member function]
     cls.add_method('Print', 
                    'void', 
-                   [param('std::ostream&', 'os')], 
+                   [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::InetSocketAddress const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::InetSocketAddress&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::InetSocketAddress const &', 'arg0')])
     ## 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')])
     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(ns3::Ipv4Address ipv4) [constructor]
@@ -871,9 +871,9 @@
     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(uint16_t port) [constructor]
     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')])
+    cls.add_constructor([param('char const *', 'ipv4'), 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)])
+    cls.add_constructor([param('char const *', 'ipv4')])
     ## inet-socket-address.h: uint16_t ns3::InetSocketAddress::GetPort() const [member function]
     cls.add_method('GetPort', 
                    'uint16_t', 
@@ -895,38 +895,38 @@
     ## 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)], 
+                   [param('ns3::Address const &', 'address')], 
                    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)], 
+                   [param('ns3::Address const &', 'address')], 
                    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)])
+    cls.add_constructor([param('ns3::Ipv4Address const &', 'arg0')])
     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address() [constructor]
     cls.add_constructor([])
     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(uint32_t address) [constructor]
     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)])
+    cls.add_constructor([param('char const *', 'address')])
     ## 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)], 
+                   [param('ns3::Ipv4Mask const &', 'mask')], 
                    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)], 
+                   [param('ns3::Address const &', 'address')], 
                    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)], 
+                   [param('uint8_t const *', 'buf')], 
                    is_static=True)
     ## ipv4-address.h: uint32_t ns3::Ipv4Address::Get() const [member function]
     cls.add_method('Get', 
@@ -951,7 +951,7 @@
     ## 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)], 
+                   [param('ns3::Ipv4Mask const &', 'mask')], 
                    is_const=True)
     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetZero() [member function]
     cls.add_method('GetZero', 
@@ -966,12 +966,12 @@
     ## 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)], 
+                   [param('ns3::Ipv4Address const &', 'other')], 
                    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)], 
+                   [param('ns3::Address const &', 'address')], 
                    is_static=True)
     ## ipv4-address.h: bool ns3::Ipv4Address::IsMulticast() const [member function]
     cls.add_method('IsMulticast', 
@@ -981,12 +981,12 @@
     ## 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)], 
+                   [param('ns3::Ipv4Mask const &', 'mask')], 
                    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')], 
+                   [param('std::ostream &', 'os')], 
                    is_const=True)
     ## ipv4-address.h: void ns3::Ipv4Address::Serialize(uint8_t * buf) const [member function]
     cls.add_method('Serialize', 
@@ -1000,13 +1000,13 @@
     ## 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)])
+                   [param('char const *', 'address')])
     cls.add_output_stream_operator()
     return
 
 def register_Ns3Application_methods(root_module, cls):
     ## application.h: ns3::Application::Application(ns3::Application const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Application&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Application const &', 'arg0')])
     ## application.h: static ns3::TypeId ns3::Application::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1017,19 +1017,19 @@
     ## application.h: void ns3::Application::Start(ns3::Time const & startTime) [member function]
     cls.add_method('Start', 
                    'void', 
-                   [param('ns3::Time&', 'startTime', is_const=True)])
+                   [param('ns3::Time const &', 'startTime')])
     ## application.h: void ns3::Application::Start(ns3::RandomVariable const & startVariable) [member function]
     cls.add_method('Start', 
                    'void', 
-                   [param('ns3::RandomVariable&', 'startVariable', is_const=True)])
+                   [param('ns3::RandomVariable const &', 'startVariable')])
     ## application.h: void ns3::Application::Stop(ns3::Time const & stopTime) [member function]
     cls.add_method('Stop', 
                    'void', 
-                   [param('ns3::Time&', 'stopTime', is_const=True)])
+                   [param('ns3::Time const &', 'stopTime')])
     ## application.h: void ns3::Application::Stop(ns3::RandomVariable const & stopVariable) [member function]
     cls.add_method('Stop', 
                    'void', 
-                   [param('ns3::RandomVariable&', 'stopVariable', is_const=True)])
+                   [param('ns3::RandomVariable const &', 'stopVariable')])
     ## application.h: ns3::Ptr<ns3::Node> ns3::Application::GetNode() const [member function]
     cls.add_method('GetNode', 
                    'ns3::Ptr< ns3::Node >', 
@@ -1058,7 +1058,7 @@
 
 def register_Ns3Queue_methods(root_module, cls):
     ## queue.h: ns3::Queue::Queue(ns3::Queue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Queue&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Queue const &', 'arg0')])
     ## queue.h: static ns3::TypeId ns3::Queue::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1146,7 +1146,7 @@
 
 def register_Ns3Socket_methods(root_module, cls):
     ## socket.h: ns3::Socket::Socket(ns3::Socket const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Socket&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Socket const &', 'arg0')])
     ## socket.h: ns3::Socket::Socket() [constructor]
     cls.add_constructor([])
     ## socket.h: static ns3::Ptr<ns3::Socket> ns3::Socket::CreateSocket(ns3::Ptr<ns3::Node> node, ns3::TypeId tid) [member function]
@@ -1187,7 +1187,7 @@
     ## socket.h: int ns3::Socket::Bind(ns3::Address const & address) [member function]
     cls.add_method('Bind', 
                    'int', 
-                   [param('ns3::Address&', 'address', is_const=True)], 
+                   [param('ns3::Address const &', 'address')], 
                    is_pure_virtual=True, is_virtual=True)
     ## socket.h: int ns3::Socket::Bind() [member function]
     cls.add_method('Bind', 
@@ -1212,7 +1212,7 @@
     ## socket.h: int ns3::Socket::Connect(ns3::Address const & address) [member function]
     cls.add_method('Connect', 
                    'int', 
-                   [param('ns3::Address&', 'address', is_const=True)], 
+                   [param('ns3::Address const &', 'address')], 
                    is_pure_virtual=True, is_virtual=True)
     ## socket.h: int ns3::Socket::Listen(uint32_t queueLimit) [member function]
     cls.add_method('Listen', 
@@ -1232,7 +1232,7 @@
     ## socket.h: int ns3::Socket::SendTo(ns3::Ptr<ns3::Packet> p, uint32_t flags, ns3::Address const & toAddress) [member function]
     cls.add_method('SendTo', 
                    'int', 
-                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'flags'), param('ns3::Address&', 'toAddress', is_const=True)], 
+                   [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'flags'), param('ns3::Address const &', 'toAddress')], 
                    is_pure_virtual=True, is_virtual=True)
     ## socket.h: uint32_t ns3::Socket::GetRxAvailable() const [member function]
     cls.add_method('GetRxAvailable', 
@@ -1247,7 +1247,7 @@
     ## socket.h: ns3::Ptr<ns3::Packet> ns3::Socket::RecvFrom(uint32_t maxSize, uint32_t flags, ns3::Address & fromAddress) [member function]
     cls.add_method('RecvFrom', 
                    'ns3::Ptr< ns3::Packet >', 
-                   [param('uint32_t', 'maxSize'), param('uint32_t', 'flags'), param('ns3::Address&', 'fromAddress')], 
+                   [param('uint32_t', 'maxSize'), param('uint32_t', 'flags'), param('ns3::Address &', 'fromAddress')], 
                    is_pure_virtual=True, is_virtual=True)
     ## socket.h: int ns3::Socket::Send(ns3::Ptr<ns3::Packet> p) [member function]
     cls.add_method('Send', 
@@ -1256,11 +1256,11 @@
     ## socket.h: int ns3::Socket::Send(uint8_t const * buf, uint32_t size, uint32_t flags) [member function]
     cls.add_method('Send', 
                    'int', 
-                   [param('uint8_t *', 'buf', transfer_ownership=False, is_const=True), param('uint32_t', 'size'), param('uint32_t', 'flags')])
+                   [param('uint8_t const *', 'buf'), param('uint32_t', 'size'), param('uint32_t', 'flags')])
     ## socket.h: int ns3::Socket::SendTo(uint8_t const * buf, uint32_t size, uint32_t flags, ns3::Address const & address) [member function]
     cls.add_method('SendTo', 
                    'int', 
-                   [param('uint8_t *', 'buf', transfer_ownership=False, is_const=True), param('uint32_t', 'size'), param('uint32_t', 'flags'), param('ns3::Address&', 'address', is_const=True)])
+                   [param('uint8_t const *', 'buf'), param('uint32_t', 'size'), param('uint32_t', 'flags'), param('ns3::Address const &', 'address')])
     ## socket.h: ns3::Ptr<ns3::Packet> ns3::Socket::Recv() [member function]
     cls.add_method('Recv', 
                    'ns3::Ptr< ns3::Packet >', 
@@ -1272,11 +1272,11 @@
     ## socket.h: ns3::Ptr<ns3::Packet> ns3::Socket::RecvFrom(ns3::Address & fromAddress) [member function]
     cls.add_method('RecvFrom', 
                    'ns3::Ptr< ns3::Packet >', 
-                   [param('ns3::Address&', 'fromAddress')])
+                   [param('ns3::Address &', 'fromAddress')])
     ## socket.h: int ns3::Socket::RecvFrom(uint8_t * buf, uint32_t size, uint32_t flags, ns3::Address & fromAddress) [member function]
     cls.add_method('RecvFrom', 
                    'int', 
-                   [param('uint8_t *', 'buf'), param('uint32_t', 'size'), param('uint32_t', 'flags'), param('ns3::Address&', 'fromAddress')])
+                   [param('uint8_t *', 'buf'), param('uint32_t', 'size'), param('uint32_t', 'flags'), param('ns3::Address &', 'fromAddress')])
     ## socket.h: void ns3::Socket::NotifyConnectionSucceeded() [member function]
     cls.add_method('NotifyConnectionSucceeded', 
                    'void', 
@@ -1290,12 +1290,12 @@
     ## socket.h: bool ns3::Socket::NotifyConnectionRequest(ns3::Address const & from) [member function]
     cls.add_method('NotifyConnectionRequest', 
                    'bool', 
-                   [param('ns3::Address&', 'from', is_const=True)], 
+                   [param('ns3::Address const &', 'from')], 
                    visibility='protected')
     ## socket.h: void ns3::Socket::NotifyNewConnectionCreated(ns3::Ptr<ns3::Socket> socket, ns3::Address const & from) [member function]
     cls.add_method('NotifyNewConnectionCreated', 
                    'void', 
-                   [param('ns3::Ptr< ns3::Socket >', 'socket'), param('ns3::Address&', 'from', is_const=True)], 
+                   [param('ns3::Ptr< ns3::Socket >', 'socket'), param('ns3::Address const &', 'from')], 
                    visibility='protected')
     ## socket.h: void ns3::Socket::NotifyDataSent(uint32_t size) [member function]
     cls.add_method('NotifyDataSent', 
@@ -1316,7 +1316,7 @@
 
 def register_Ns3Ipv4Header_methods(root_module, cls):
     ## ipv4-header.h: ns3::Ipv4Header::Ipv4Header(ns3::Ipv4Header const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Ipv4Header&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Ipv4Header const &', 'arg0')])
     ## ipv4-header.h: ns3::Ipv4Header::Ipv4Header() [constructor]
     cls.add_constructor([])
     ## ipv4-header.h: void ns3::Ipv4Header::EnableChecksum() [member function]
@@ -1439,7 +1439,7 @@
     ## ipv4-header.h: void ns3::Ipv4Header::Print(std::ostream & os) const [member function]
     cls.add_method('Print', 
                    'void', 
-                   [param('std::ostream&', 'os')], 
+                   [param('std::ostream &', 'os')], 
                    is_const=True, is_virtual=True)
     ## ipv4-header.h: uint32_t ns3::Ipv4Header::GetSerializedSize() const [member function]
     cls.add_method('GetSerializedSize', 
@@ -1460,7 +1460,7 @@
 
 def register_Ns3UdpSocket_methods(root_module, cls):
     ## udp-socket.h: ns3::UdpSocket::UdpSocket(ns3::UdpSocket const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::UdpSocket&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::UdpSocket const &', 'arg0')])
     ## udp-socket.h: static ns3::TypeId ns3::UdpSocket::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1502,7 +1502,7 @@
 
 def register_Ns3NetDevice_methods(root_module, cls):
     ## net-device.h: ns3::NetDevice::NetDevice(ns3::NetDevice const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::NetDevice&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::NetDevice const &', 'arg0')])
     ## net-device.h: ns3::NetDevice::NetDevice() [constructor]
     cls.add_constructor([])
     ## net-device.h: static ns3::TypeId ns3::NetDevice::GetTypeId() [member function]
@@ -1513,7 +1513,7 @@
     ## net-device.h: void ns3::NetDevice::SetName(std::string const name) [member function]
     cls.add_method('SetName', 
                    'void', 
-                   [param('std::string', 'name', is_const=True)], 
+                   [param('std::string const', 'name')], 
                    is_pure_virtual=True, is_virtual=True)
     ## net-device.h: std::string ns3::NetDevice::GetName() const [member function]
     cls.add_method('GetName', 
@@ -1523,7 +1523,7 @@
     ## net-device.h: void ns3::NetDevice::SetIfIndex(uint32_t const index) [member function]
     cls.add_method('SetIfIndex', 
                    'void', 
-                   [param('uint32_t', 'index', is_const=True)], 
+                   [param('uint32_t const', 'index')], 
                    is_pure_virtual=True, is_virtual=True)
     ## net-device.h: uint32_t ns3::NetDevice::GetIfIndex() const [member function]
     cls.add_method('GetIfIndex', 
@@ -1543,7 +1543,7 @@
     ## net-device.h: bool ns3::NetDevice::SetMtu(uint16_t const mtu) [member function]
     cls.add_method('SetMtu', 
                    'bool', 
-                   [param('uint16_t', 'mtu', is_const=True)], 
+                   [param('uint16_t const', 'mtu')], 
                    is_pure_virtual=True, is_virtual=True)
     ## net-device.h: uint16_t ns3::NetDevice::GetMtu() const [member function]
     cls.add_method('GetMtu', 
@@ -1593,12 +1593,12 @@
     ## net-device.h: bool ns3::NetDevice::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')], 
+                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], 
                    is_pure_virtual=True, is_virtual=True)
     ## net-device.h: bool ns3::NetDevice::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')], 
+                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'source'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], 
                    is_pure_virtual=True, is_virtual=True)
     ## net-device.h: ns3::Ptr<ns3::Node> ns3::NetDevice::GetNode() const [member function]
     cls.add_method('GetNode', 
@@ -1634,7 +1634,7 @@
 
 def register_Ns3DropTailQueue_methods(root_module, cls):
     ## drop-tail-queue.h: ns3::DropTailQueue::DropTailQueue(ns3::DropTailQueue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::DropTailQueue&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::DropTailQueue const &', 'arg0')])
     ## drop-tail-queue.h: static ns3::TypeId ns3::DropTailQueue::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1661,15 +1661,15 @@
 
 def register_Ns3AddressValue_methods(root_module, cls):
     ## address.h: ns3::AddressValue::AddressValue(ns3::AddressValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::AddressValue&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::AddressValue const &', 'arg0')])
     ## address.h: ns3::AddressValue::AddressValue() [constructor]
     cls.add_constructor([])
     ## address.h: ns3::AddressValue::AddressValue(ns3::Address const & value) [constructor]
-    cls.add_constructor([param('ns3::Address&', 'value', is_const=True)])
+    cls.add_constructor([param('ns3::Address const &', 'value')])
     ## address.h: void ns3::AddressValue::Set(ns3::Address const & value) [member function]
     cls.add_method('Set', 
                    'void', 
-                   [param('ns3::Address&', 'value', is_const=True)])
+                   [param('ns3::Address const &', 'value')])
     ## address.h: ns3::Address ns3::AddressValue::Get() const [member function]
     cls.add_method('Get', 
                    'ns3::Address', 
@@ -1694,7 +1694,7 @@
 
 def register_Ns3Node_methods(root_module, cls):
     ## node.h: ns3::Node::Node(ns3::Node const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Node&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Node const &', 'arg0')])
     ## node.h: static ns3::TypeId ns3::Node::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1764,7 +1764,7 @@
 
 def register_Ns3Channel_methods(root_module, cls):
     ## channel.h: ns3::Channel::Channel(ns3::Channel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Channel&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Channel const &', 'arg0')])
     ## channel.h: static ns3::TypeId ns3::Channel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1796,7 +1796,7 @@
 
 def register_Ns3TcpSocket_methods(root_module, cls):
     ## tcp-socket.h: ns3::TcpSocket::TcpSocket(ns3::TcpSocket const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::TcpSocket&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::TcpSocket const &', 'arg0')])
     ## tcp-socket.h: static ns3::TypeId ns3::TcpSocket::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1908,7 +1908,7 @@
 
 def register_Ns3EthernetHeader_methods(root_module, cls):
     ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader(ns3::EthernetHeader const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::EthernetHeader&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::EthernetHeader const &', 'arg0')])
     ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader(bool hasPreamble) [constructor]
     cls.add_constructor([param('bool', 'hasPreamble')])
     ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader() [constructor]
@@ -1972,7 +1972,7 @@
     ## ethernet-header.h: void ns3::EthernetHeader::Print(std::ostream & os) const [member function]
     cls.add_method('Print', 
                    'void', 
-                   [param('std::ostream&', 'os')], 
+                   [param('std::ostream &', 'os')], 
                    is_const=True, is_virtual=True)
     ## ethernet-header.h: uint32_t ns3::EthernetHeader::GetSerializedSize() const [member function]
     cls.add_method('GetSerializedSize', 
@@ -1993,7 +1993,7 @@
 
 def register_Ns3SocketIpTtlTag_methods(root_module, cls):
     ## socket.h: ns3::SocketIpTtlTag::SocketIpTtlTag(ns3::SocketIpTtlTag const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::SocketIpTtlTag&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::SocketIpTtlTag const &', 'arg0')])
     ## socket.h: ns3::SocketIpTtlTag::SocketIpTtlTag() [constructor]
     cls.add_constructor([])
     ## socket.h: void ns3::SocketIpTtlTag::SetTtl(uint8_t ttl) [member function]
@@ -2033,13 +2033,13 @@
     ## socket.h: void ns3::SocketIpTtlTag::Print(std::ostream & os) const [member function]
     cls.add_method('Print', 
                    'void', 
-                   [param('std::ostream&', 'os')], 
+                   [param('std::ostream &', 'os')], 
                    is_const=True, is_virtual=True)
     return
 
 def register_Ns3Ipv4_methods(root_module, cls):
     ## ipv4.h: ns3::Ipv4::Ipv4(ns3::Ipv4 const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Ipv4&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Ipv4 const &', 'arg0')])
     ## ipv4.h: static ns3::TypeId ns3::Ipv4::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2200,7 +2200,7 @@
     ## ipv4.h: bool ns3::Ipv4::GetIfIndexForDestination(ns3::Ipv4Address dest, uint32_t & ifIndex) const [member function]
     cls.add_method('GetIfIndexForDestination', 
                    'bool', 
-                   [param('ns3::Ipv4Address', 'dest'), param('uint32_t&', 'ifIndex')], 
+                   [param('ns3::Ipv4Address', 'dest'), param('uint32_t &', 'ifIndex')], 
                    is_pure_virtual=True, is_const=True, is_virtual=True)
     ## ipv4.h: uint16_t ns3::Ipv4::GetMtu(uint32_t i) const [member function]
     cls.add_method('GetMtu', 
@@ -2231,7 +2231,7 @@
 
 def register_Ns3SocketFactory_methods(root_module, cls):
     ## socket-factory.h: ns3::SocketFactory::SocketFactory(ns3::SocketFactory const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::SocketFactory&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::SocketFactory const &', 'arg0')])
     ## socket-factory.h: static ns3::TypeId ns3::SocketFactory::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2248,7 +2248,7 @@
 
 def register_Ns3EthernetTrailer_methods(root_module, cls):
     ## ethernet-trailer.h: ns3::EthernetTrailer::EthernetTrailer(ns3::EthernetTrailer const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::EthernetTrailer&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::EthernetTrailer const &', 'arg0')])
     ## ethernet-trailer.h: ns3::EthernetTrailer::EthernetTrailer() [constructor]
     cls.add_constructor([])
     ## ethernet-trailer.h: static void ns3::EthernetTrailer::EnableFcs(bool enable) [member function]
@@ -2291,7 +2291,7 @@
     ## ethernet-trailer.h: void ns3::EthernetTrailer::Print(std::ostream & os) const [member function]
     cls.add_method('Print', 
                    'void', 
-                   [param('std::ostream&', 'os')], 
+                   [param('std::ostream &', 'os')], 
                    is_const=True, is_virtual=True)
     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::GetSerializedSize() const [member function]
     cls.add_method('GetSerializedSize', 
@@ -2312,7 +2312,7 @@
 
 def register_Ns3SimpleChannel_methods(root_module, cls):
     ## simple-channel.h: ns3::SimpleChannel::SimpleChannel(ns3::SimpleChannel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::SimpleChannel&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::SimpleChannel const &', 'arg0')])
     ## simple-channel.h: static ns3::TypeId ns3::SimpleChannel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2342,7 +2342,7 @@
 
 def register_Ns3LlcSnapHeader_methods(root_module, cls):
     ## llc-snap-header.h: ns3::LlcSnapHeader::LlcSnapHeader(ns3::LlcSnapHeader const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::LlcSnapHeader&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::LlcSnapHeader const &', 'arg0')])
     ## llc-snap-header.h: ns3::LlcSnapHeader::LlcSnapHeader() [constructor]
     cls.add_constructor([])
     ## llc-snap-header.h: void ns3::LlcSnapHeader::SetType(uint16_t type) [member function]
@@ -2366,7 +2366,7 @@
     ## llc-snap-header.h: void ns3::LlcSnapHeader::Print(std::ostream & os) const [member function]
     cls.add_method('Print', 
                    'void', 
-                   [param('std::ostream&', 'os')], 
+                   [param('std::ostream &', 'os')], 
                    is_const=True, is_virtual=True)
     ## llc-snap-header.h: uint32_t ns3::LlcSnapHeader::GetSerializedSize() const [member function]
     cls.add_method('GetSerializedSize', 
@@ -2387,7 +2387,7 @@
 
 def register_Ns3UdpSocketFactory_methods(root_module, cls):
     ## udp-socket-factory.h: ns3::UdpSocketFactory::UdpSocketFactory(ns3::UdpSocketFactory const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::UdpSocketFactory&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::UdpSocketFactory const &', 'arg0')])
     ## udp-socket-factory.h: ns3::UdpSocketFactory::UdpSocketFactory() [constructor]
     cls.add_constructor([])
     ## udp-socket-factory.h: static ns3::TypeId ns3::UdpSocketFactory::GetTypeId() [member function]
@@ -2399,7 +2399,7 @@
 
 def register_Ns3SimpleNetDevice_methods(root_module, cls):
     ## simple-net-device.h: ns3::SimpleNetDevice::SimpleNetDevice(ns3::SimpleNetDevice const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::SimpleNetDevice&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::SimpleNetDevice const &', 'arg0')])
     ## simple-net-device.h: static ns3::TypeId ns3::SimpleNetDevice::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2422,7 +2422,7 @@
     ## simple-net-device.h: void ns3::SimpleNetDevice::SetName(std::string const name) [member function]
     cls.add_method('SetName', 
                    'void', 
-                   [param('std::string', 'name', is_const=True)], 
+                   [param('std::string const', 'name')], 
                    is_virtual=True)
     ## simple-net-device.h: std::string ns3::SimpleNetDevice::GetName() const [member function]
     cls.add_method('GetName', 
@@ -2432,7 +2432,7 @@
     ## simple-net-device.h: void ns3::SimpleNetDevice::SetIfIndex(uint32_t const index) [member function]
     cls.add_method('SetIfIndex', 
                    'void', 
-                   [param('uint32_t', 'index', is_const=True)], 
+                   [param('uint32_t const', 'index')], 
                    is_virtual=True)
     ## simple-net-device.h: uint32_t ns3::SimpleNetDevice::GetIfIndex() const [member function]
     cls.add_method('GetIfIndex', 
@@ -2452,7 +2452,7 @@
     ## simple-net-device.h: bool ns3::SimpleNetDevice::SetMtu(uint16_t const mtu) [member function]
     cls.add_method('SetMtu', 
                    'bool', 
-                   [param('uint16_t', 'mtu', is_const=True)], 
+                   [param('uint16_t const', 'mtu')], 
                    is_virtual=True)
     ## simple-net-device.h: uint16_t ns3::SimpleNetDevice::GetMtu() const [member function]
     cls.add_method('GetMtu', 
@@ -2502,12 +2502,12 @@
     ## simple-net-device.h: bool ns3::SimpleNetDevice::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')], 
+                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], 
                    is_virtual=True)
     ## simple-net-device.h: bool ns3::SimpleNetDevice::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')], 
+                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'source'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], 
                    is_virtual=True)
     ## simple-net-device.h: ns3::Ptr<ns3::Node> ns3::SimpleNetDevice::GetNode() const [member function]
     cls.add_method('GetNode', 
@@ -2548,7 +2548,7 @@
 
 def register_Ns3TcpSocketFactory_methods(root_module, cls):
     ## tcp-socket-factory.h: ns3::TcpSocketFactory::TcpSocketFactory(ns3::TcpSocketFactory const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::TcpSocketFactory&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::TcpSocketFactory const &', 'arg0')])
     ## tcp-socket-factory.h: ns3::TcpSocketFactory::TcpSocketFactory() [constructor]
     cls.add_constructor([])
     ## tcp-socket-factory.h: static ns3::TypeId ns3::TcpSocketFactory::GetTypeId() [member function]
@@ -2560,7 +2560,7 @@
 
 def register_Ns3PacketSocketFactory_methods(root_module, cls):
     ## packet-socket-factory.h: ns3::PacketSocketFactory::PacketSocketFactory(ns3::PacketSocketFactory const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::PacketSocketFactory&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::PacketSocketFactory const &', 'arg0')])
     ## packet-socket-factory.h: static ns3::TypeId ns3::PacketSocketFactory::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2588,15 +2588,15 @@
     ## address-utils.h: extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Mac48Address ad) [free function]
     module.add_function('WriteTo', 
                         'void', 
-                        [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Mac48Address', 'ad')])
+                        [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Mac48Address', 'ad')])
     ## address-utils.h: extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Address const & ad) [free function]
     module.add_function('WriteTo', 
                         'void', 
-                        [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Address&', 'ad', is_const=True)])
+                        [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Address const &', 'ad')])
     ## address-utils.h: extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Ipv4Address ad) [free function]
     module.add_function('WriteTo', 
                         'void', 
-                        [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Ipv4Address', 'ad')])
+                        [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Ipv4Address', 'ad')])
     ## address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeAddressChecker() [free function]
     module.add_function('MakeAddressChecker', 
                         'ns3::Ptr< ns3::AttributeChecker const >', 
@@ -2608,15 +2608,15 @@
     ## address-utils.h: extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Mac48Address & ad) [free function]
     module.add_function('ReadFrom', 
                         'void', 
-                        [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Mac48Address&', 'ad')])
+                        [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Mac48Address &', 'ad')])
     ## address-utils.h: extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Address & ad, uint32_t len) [free function]
     module.add_function('ReadFrom', 
                         'void', 
-                        [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Address&', 'ad'), param('uint32_t', 'len')])
+                        [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Address &', 'ad'), param('uint32_t', 'len')])
     ## address-utils.h: extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Ipv4Address & ad) [free function]
     module.add_function('ReadFrom', 
                         'void', 
-                        [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Ipv4Address&', 'ad')])
+                        [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Ipv4Address &', 'ad')])
     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_olsr.py	Sun Aug 31 22:33:23 2008 +0100
+++ b/bindings/python/ns3_module_olsr.py	Tue Sep 02 11:12:42 2008 +0100
@@ -78,7 +78,7 @@
 
 def register_Ns3OlsrMessageHeader_methods(root_module, cls):
     ## olsr-header.h: ns3::olsr::MessageHeader::MessageHeader(ns3::olsr::MessageHeader const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::olsr::MessageHeader&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::olsr::MessageHeader const &', 'arg0')])
     ## olsr-header.h: ns3::olsr::MessageHeader::MessageHeader() [constructor]
     cls.add_constructor([])
     ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
@@ -88,20 +88,20 @@
                    is_virtual=True)
     ## olsr-header.h: ns3::olsr::MessageHeader::Hello & ns3::olsr::MessageHeader::GetHello() [member function]
     cls.add_method('GetHello', 
-                   'ns3::olsr::MessageHeader::Hello&', 
+                   'ns3::olsr::MessageHeader::Hello &', 
                    [])
     ## olsr-header.h: ns3::olsr::MessageHeader::Hello const & ns3::olsr::MessageHeader::GetHello() const [member function]
     cls.add_method('GetHello', 
-                   retval('ns3::olsr::MessageHeader::Hello&', is_const=True), 
+                   'ns3::olsr::MessageHeader::Hello const &', 
                    [], 
                    is_const=True)
     ## olsr-header.h: ns3::olsr::MessageHeader::Hna & ns3::olsr::MessageHeader::GetHna() [member function]
     cls.add_method('GetHna', 
-                   'ns3::olsr::MessageHeader::Hna&', 
+                   'ns3::olsr::MessageHeader::Hna &', 
                    [])
     ## olsr-header.h: ns3::olsr::MessageHeader::Hna const & ns3::olsr::MessageHeader::GetHna() const [member function]
     cls.add_method('GetHna', 
-                   retval('ns3::olsr::MessageHeader::Hna&', is_const=True), 
+                   'ns3::olsr::MessageHeader::Hna const &', 
                    [], 
                    is_const=True)
     ## olsr-header.h: uint8_t ns3::olsr::MessageHeader::GetHopCount() const [member function]
@@ -126,11 +126,11 @@
                    is_const=True)
     ## olsr-header.h: ns3::olsr::MessageHeader::Mid & ns3::olsr::MessageHeader::GetMid() [member function]
     cls.add_method('GetMid', 
-                   'ns3::olsr::MessageHeader::Mid&', 
+                   'ns3::olsr::MessageHeader::Mid &', 
                    [])
     ## olsr-header.h: ns3::olsr::MessageHeader::Mid const & ns3::olsr::MessageHeader::GetMid() const [member function]
     cls.add_method('GetMid', 
-                   retval('ns3::olsr::MessageHeader::Mid&', is_const=True), 
+                   'ns3::olsr::MessageHeader::Mid const &', 
                    [], 
                    is_const=True)
     ## olsr-header.h: ns3::Ipv4Address ns3::olsr::MessageHeader::GetOriginatorAddress() const [member function]
@@ -145,11 +145,11 @@
                    is_const=True, is_virtual=True)
     ## olsr-header.h: ns3::olsr::MessageHeader::Tc & ns3::olsr::MessageHeader::GetTc() [member function]
     cls.add_method('GetTc', 
-                   'ns3::olsr::MessageHeader::Tc&', 
+                   'ns3::olsr::MessageHeader::Tc &', 
                    [])
     ## olsr-header.h: ns3::olsr::MessageHeader::Tc const & ns3::olsr::MessageHeader::GetTc() const [member function]
     cls.add_method('GetTc', 
-                   retval('ns3::olsr::MessageHeader::Tc&', is_const=True), 
+                   'ns3::olsr::MessageHeader::Tc const &', 
                    [], 
                    is_const=True)
     ## olsr-header.h: uint8_t ns3::olsr::MessageHeader::GetTimeToLive() const [member function]
@@ -170,7 +170,7 @@
     ## olsr-header.h: void ns3::olsr::MessageHeader::Print(std::ostream & os) const [member function]
     cls.add_method('Print', 
                    'void', 
-                   [param('std::ostream&', 'os')], 
+                   [param('std::ostream &', 'os')], 
                    is_const=True, is_virtual=True)
     ## olsr-header.h: void ns3::olsr::MessageHeader::Serialize(ns3::Buffer::Iterator start) const [member function]
     cls.add_method('Serialize', 
@@ -208,7 +208,7 @@
     ## olsr-header.h: ns3::olsr::MessageHeader::Mid::Mid() [constructor]
     cls.add_constructor([])
     ## olsr-header.h: ns3::olsr::MessageHeader::Mid::Mid(ns3::olsr::MessageHeader::Mid const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::olsr::MessageHeader::Mid&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::olsr::MessageHeader::Mid const &', 'arg0')])
     ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::Mid::Deserialize(ns3::Buffer::Iterator start, uint32_t messageSize) [member function]
     cls.add_method('Deserialize', 
                    'uint32_t', 
@@ -221,7 +221,7 @@
     ## olsr-header.h: void ns3::olsr::MessageHeader::Mid::Print(std::ostream & os) const [member function]
     cls.add_method('Print', 
                    'void', 
-                   [param('std::ostream&', 'os')], 
+                   [param('std::ostream &', 'os')], 
                    is_const=True)
     ## olsr-header.h: void ns3::olsr::MessageHeader::Mid::Serialize(ns3::Buffer::Iterator start) const [member function]
     cls.add_method('Serialize', 
@@ -236,7 +236,7 @@
     ## olsr-header.h: ns3::olsr::MessageHeader::Hello::Hello() [constructor]
     cls.add_constructor([])
     ## olsr-header.h: ns3::olsr::MessageHeader::Hello::Hello(ns3::olsr::MessageHeader::Hello const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::olsr::MessageHeader::Hello&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::olsr::MessageHeader::Hello const &', 'arg0')])
     ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::Hello::Deserialize(ns3::Buffer::Iterator start, uint32_t messageSize) [member function]
     cls.add_method('Deserialize', 
                    'uint32_t', 
@@ -254,7 +254,7 @@
     ## olsr-header.h: void ns3::olsr::MessageHeader::Hello::Print(std::ostream & os) const [member function]
     cls.add_method('Print', 
                    'void', 
-                   [param('std::ostream&', 'os')], 
+                   [param('std::ostream &', 'os')], 
                    is_const=True)
     ## olsr-header.h: void ns3::olsr::MessageHeader::Hello::Serialize(ns3::Buffer::Iterator start) const [member function]
     cls.add_method('Serialize', 
@@ -279,7 +279,7 @@
     ## olsr-header.h: ns3::olsr::MessageHeader::Hello::LinkMessage::neighborInterfaceAddresses [variable]
     cls.add_instance_attribute('neighborInterfaceAddresses', 'std::vector< ns3::Ipv4Address >', is_const=False)
     ## olsr-header.h: ns3::olsr::MessageHeader::Hello::LinkMessage::LinkMessage(ns3::olsr::MessageHeader::Hello::LinkMessage const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::olsr::MessageHeader::Hello::LinkMessage&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::olsr::MessageHeader::Hello::LinkMessage const &', 'arg0')])
     ## olsr-header.h: ns3::olsr::MessageHeader::Hello::LinkMessage::LinkMessage() [constructor]
     cls.add_constructor([])
     return
@@ -288,7 +288,7 @@
     ## olsr-header.h: ns3::olsr::MessageHeader::Tc::Tc() [constructor]
     cls.add_constructor([])
     ## olsr-header.h: ns3::olsr::MessageHeader::Tc::Tc(ns3::olsr::MessageHeader::Tc const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::olsr::MessageHeader::Tc&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::olsr::MessageHeader::Tc const &', 'arg0')])
     ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::Tc::Deserialize(ns3::Buffer::Iterator start, uint32_t messageSize) [member function]
     cls.add_method('Deserialize', 
                    'uint32_t', 
@@ -301,7 +301,7 @@
     ## olsr-header.h: void ns3::olsr::MessageHeader::Tc::Print(std::ostream & os) const [member function]
     cls.add_method('Print', 
                    'void', 
-                   [param('std::ostream&', 'os')], 
+                   [param('std::ostream &', 'os')], 
                    is_const=True)
     ## olsr-header.h: void ns3::olsr::MessageHeader::Tc::Serialize(ns3::Buffer::Iterator start) const [member function]
     cls.add_method('Serialize', 
@@ -318,7 +318,7 @@
     ## olsr-header.h: ns3::olsr::MessageHeader::Hna::Hna() [constructor]
     cls.add_constructor([])
     ## olsr-header.h: ns3::olsr::MessageHeader::Hna::Hna(ns3::olsr::MessageHeader::Hna const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::olsr::MessageHeader::Hna&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::olsr::MessageHeader::Hna const &', 'arg0')])
     ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::Hna::Deserialize(ns3::Buffer::Iterator start, uint32_t messageSize) [member function]
     cls.add_method('Deserialize', 
                    'uint32_t', 
@@ -331,7 +331,7 @@
     ## olsr-header.h: void ns3::olsr::MessageHeader::Hna::Print(std::ostream & os) const [member function]
     cls.add_method('Print', 
                    'void', 
-                   [param('std::ostream&', 'os')], 
+                   [param('std::ostream &', 'os')], 
                    is_const=True)
     ## olsr-header.h: void ns3::olsr::MessageHeader::Hna::Serialize(ns3::Buffer::Iterator start) const [member function]
     cls.add_method('Serialize', 
@@ -348,14 +348,14 @@
     ## olsr-header.h: ns3::olsr::MessageHeader::Hna::Association::mask [variable]
     cls.add_instance_attribute('mask', 'ns3::Ipv4Mask', is_const=False)
     ## olsr-header.h: ns3::olsr::MessageHeader::Hna::Association::Association(ns3::olsr::MessageHeader::Hna::Association const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::olsr::MessageHeader::Hna::Association&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::olsr::MessageHeader::Hna::Association const &', 'arg0')])
     ## olsr-header.h: ns3::olsr::MessageHeader::Hna::Association::Association() [constructor]
     cls.add_constructor([])
     return
 
 def register_Ns3OlsrAgent_methods(root_module, cls):
     ## olsr-agent.h: ns3::olsr::Agent::Agent(ns3::olsr::Agent const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::olsr::Agent&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::olsr::Agent const &', 'arg0')])
     ## olsr-agent.h: ns3::olsr::Agent::Agent() [constructor]
     cls.add_constructor([])
     ## olsr-agent.h: static ns3::TypeId ns3::olsr::Agent::GetTypeId() [member function]
@@ -382,7 +382,7 @@
 
 def register_Ns3OlsrPacketHeader_methods(root_module, cls):
     ## olsr-header.h: ns3::olsr::PacketHeader::PacketHeader(ns3::olsr::PacketHeader const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::olsr::PacketHeader&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::olsr::PacketHeader const &', 'arg0')])
     ## olsr-header.h: ns3::olsr::PacketHeader::PacketHeader() [constructor]
     cls.add_constructor([])
     ## olsr-header.h: uint32_t ns3::olsr::PacketHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
@@ -418,7 +418,7 @@
     ## olsr-header.h: void ns3::olsr::PacketHeader::Print(std::ostream & os) const [member function]
     cls.add_method('Print', 
                    'void', 
-                   [param('std::ostream&', 'os')], 
+                   [param('std::ostream &', 'os')], 
                    is_const=True, is_virtual=True)
     ## olsr-header.h: void ns3::olsr::PacketHeader::Serialize(ns3::Buffer::Iterator start) const [member function]
     cls.add_method('Serialize', 
--- a/bindings/python/ns3_module_onoff.py	Sun Aug 31 22:33:23 2008 +0100
+++ b/bindings/python/ns3_module_onoff.py	Tue Sep 02 11:12:42 2008 +0100
@@ -52,7 +52,7 @@
 
 def register_Ns3OnOffApplication_methods(root_module, cls):
     ## onoff-application.h: ns3::OnOffApplication::OnOffApplication(ns3::OnOffApplication const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::OnOffApplication&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::OnOffApplication const &', 'arg0')])
     ## onoff-application.h: static ns3::TypeId ns3::OnOffApplication::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
--- a/bindings/python/ns3_module_packet_sink.py	Sun Aug 31 22:33:23 2008 +0100
+++ b/bindings/python/ns3_module_packet_sink.py	Tue Sep 02 11:12:42 2008 +0100
@@ -52,7 +52,7 @@
 
 def register_Ns3PacketSink_methods(root_module, cls):
     ## packet-sink.h: ns3::PacketSink::PacketSink(ns3::PacketSink const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::PacketSink&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::PacketSink const &', 'arg0')])
     ## packet-sink.h: static ns3::TypeId ns3::PacketSink::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
--- a/bindings/python/ns3_module_point_to_point.py	Sun Aug 31 22:33:23 2008 +0100
+++ b/bindings/python/ns3_module_point_to_point.py	Tue Sep 02 11:12:42 2008 +0100
@@ -55,7 +55,7 @@
 
 def register_Ns3PointToPointChannel_methods(root_module, cls):
     ## point-to-point-channel.h: ns3::PointToPointChannel::PointToPointChannel(ns3::PointToPointChannel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::PointToPointChannel&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::PointToPointChannel const &', 'arg0')])
     ## point-to-point-channel.h: static ns3::TypeId ns3::PointToPointChannel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -90,7 +90,7 @@
 
 def register_Ns3PointToPointNetDevice_methods(root_module, cls):
     ## point-to-point-net-device.h: ns3::PointToPointNetDevice::PointToPointNetDevice(ns3::PointToPointNetDevice const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::PointToPointNetDevice&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::PointToPointNetDevice const &', 'arg0')])
     ## point-to-point-net-device.h: static ns3::TypeId ns3::PointToPointNetDevice::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -129,7 +129,7 @@
     ## point-to-point-net-device.h: void ns3::PointToPointNetDevice::SetName(std::string const name) [member function]
     cls.add_method('SetName', 
                    'void', 
-                   [param('std::string', 'name', is_const=True)], 
+                   [param('std::string const', 'name')], 
                    is_virtual=True)
     ## point-to-point-net-device.h: std::string ns3::PointToPointNetDevice::GetName() const [member function]
     cls.add_method('GetName', 
@@ -139,7 +139,7 @@
     ## point-to-point-net-device.h: void ns3::PointToPointNetDevice::SetIfIndex(uint32_t const index) [member function]
     cls.add_method('SetIfIndex', 
                    'void', 
-                   [param('uint32_t', 'index', is_const=True)], 
+                   [param('uint32_t const', 'index')], 
                    is_virtual=True)
     ## point-to-point-net-device.h: uint32_t ns3::PointToPointNetDevice::GetIfIndex() const [member function]
     cls.add_method('GetIfIndex', 
@@ -159,7 +159,7 @@
     ## point-to-point-net-device.h: bool ns3::PointToPointNetDevice::SetMtu(uint16_t const mtu) [member function]
     cls.add_method('SetMtu', 
                    'bool', 
-                   [param('uint16_t', 'mtu', is_const=True)], 
+                   [param('uint16_t const', 'mtu')], 
                    is_virtual=True)
     ## point-to-point-net-device.h: uint16_t ns3::PointToPointNetDevice::GetMtu() const [member function]
     cls.add_method('GetMtu', 
@@ -209,12 +209,12 @@
     ## point-to-point-net-device.h: bool ns3::PointToPointNetDevice::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')], 
+                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], 
                    is_virtual=True)
     ## point-to-point-net-device.h: bool ns3::PointToPointNetDevice::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')], 
+                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'source'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], 
                    is_virtual=True)
     ## point-to-point-net-device.h: ns3::Ptr<ns3::Node> ns3::PointToPointNetDevice::GetNode() const [member function]
     cls.add_method('GetNode', 
--- a/bindings/python/ns3_module_simulator.py	Sun Aug 31 22:33:23 2008 +0100
+++ b/bindings/python/ns3_module_simulator.py	Tue Sep 02 11:12:42 2008 +0100
@@ -126,7 +126,7 @@
 
 def register_Ns3Timer_methods(root_module, cls):
     ## timer.h: ns3::Timer::Timer(ns3::Timer const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Timer&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Timer const &', 'arg0')])
     ## timer.h: ns3::Timer::Timer() [constructor]
     cls.add_constructor([])
     ## timer.h: ns3::Timer::Timer(ns3::Timer::DestroyPolicy destroyPolicy) [constructor]
@@ -134,7 +134,7 @@
     ## timer.h: void ns3::Timer::SetDelay(ns3::Time const & delay) [member function]
     cls.add_method('SetDelay', 
                    'void', 
-                   [param('ns3::Time&', 'delay', is_const=True)])
+                   [param('ns3::Time const &', 'delay')])
     ## timer.h: ns3::Time ns3::Timer::GetDelay() const [member function]
     cls.add_method('GetDelay', 
                    'ns3::Time', 
@@ -193,13 +193,13 @@
 
 def register_Ns3TimerImpl_methods(root_module, cls):
     ## timer-impl.h: ns3::TimerImpl::TimerImpl(ns3::TimerImpl const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::TimerImpl&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::TimerImpl const &', 'arg0')])
     ## timer-impl.h: ns3::TimerImpl::TimerImpl() [constructor]
     cls.add_constructor([])
     ## timer-impl.h: ns3::EventId ns3::TimerImpl::Schedule(ns3::Time const & delay) [member function]
     cls.add_method('Schedule', 
                    'ns3::EventId', 
-                   [param('ns3::Time&', 'delay', is_const=True)], 
+                   [param('ns3::Time const &', 'delay')], 
                    is_pure_virtual=True, is_virtual=True)
     ## timer-impl.h: void ns3::TimerImpl::Invoke() [member function]
     cls.add_method('Invoke', 
@@ -210,11 +210,11 @@
 
 def register_Ns3Time_methods(root_module, cls):
     ## nstime.h: ns3::TimeUnit<1>::TimeUnit(std::string const & s) [constructor]
-    cls.add_constructor([param('std::string&', 's', is_const=True)])
+    cls.add_constructor([param('std::string const &', 's')])
     ## nstime.h: ns3::TimeUnit<1>::TimeUnit() [constructor]
     cls.add_constructor([])
     ## nstime.h: ns3::TimeUnit<1>::TimeUnit(ns3::TimeUnit<1> const & o) [copy constructor]
-    cls.add_constructor([param('ns3::Time&', 'o', is_const=True)])
+    cls.add_constructor([param('ns3::TimeUnit< 1 >', 'o')])
     ## nstime.h: ns3::TimeUnit<1>::TimeUnit(ns3::HighPrecision data) [constructor]
     cls.add_constructor([param('ns3::HighPrecision', 'data')])
     ## nstime.h: int64_t ns3::TimeUnit<1>::GetFemtoSeconds() const [member function]
@@ -224,7 +224,7 @@
                    is_const=True)
     ## nstime.h: ns3::HighPrecision const & ns3::TimeUnit<1>::GetHighPrecision() const [member function]
     cls.add_method('GetHighPrecision', 
-                   retval('ns3::HighPrecision&', is_const=True), 
+                   'ns3::HighPrecision const &', 
                    [], 
                    is_const=True)
     ## nstime.h: int64_t ns3::TimeUnit<1>::GetMicroSeconds() const [member function]
@@ -291,6 +291,7 @@
                    'uint64_t', 
                    [param('uint64_t', 'unitValue'), param('uint64_t', 'unitFactor')], 
                    is_static=True)
+    cls.add_copy_constructor()
     cls.add_output_stream_operator()
     return
 
@@ -300,7 +301,7 @@
     ## nstime.h: ns3::TimeUnit<0>::TimeUnit() [constructor]
     cls.add_constructor([])
     ## nstime.h: ns3::TimeUnit<0>::TimeUnit(ns3::TimeUnit<0> const & o) [copy constructor]
-    cls.add_constructor([param('ns3::Scalar&', 'o', is_const=True)])
+    cls.add_constructor([param('ns3::TimeUnit< 0 >', 'o')])
     ## nstime.h: ns3::TimeUnit<0>::TimeUnit(ns3::HighPrecision data) [constructor]
     cls.add_constructor([param('ns3::HighPrecision', 'data')])
     ## nstime.h: double ns3::TimeUnit<0>::GetDouble() const [member function]
@@ -310,7 +311,7 @@
                    is_const=True)
     ## nstime.h: ns3::HighPrecision const & ns3::TimeUnit<0>::GetHighPrecision() const [member function]
     cls.add_method('GetHighPrecision', 
-                   retval('ns3::HighPrecision&', is_const=True), 
+                   'ns3::HighPrecision const &', 
                    [], 
                    is_const=True)
     ## nstime.h: bool ns3::TimeUnit<0>::IsNegative() const [member function]
@@ -342,11 +343,12 @@
     cls.add_method('PeekHighPrecision', 
                    'ns3::HighPrecision *', 
                    [])
+    cls.add_copy_constructor()
     return
 
 def register_Ns3Watchdog_methods(root_module, cls):
     ## watchdog.h: ns3::Watchdog::Watchdog(ns3::Watchdog const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Watchdog&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Watchdog const &', 'arg0')])
     ## watchdog.h: ns3::Watchdog::Watchdog() [constructor]
     cls.add_constructor([])
     ## watchdog.h: void ns3::Watchdog::Ping(ns3::Time delay) [member function]
@@ -357,7 +359,7 @@
 
 def register_Ns3Simulator_methods(root_module, cls):
     ## simulator.h: ns3::Simulator::Simulator(ns3::Simulator const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Simulator&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Simulator const &', 'arg0')])
     ## simulator.h: static void ns3::Simulator::SetImplementation(ns3::Ptr<ns3::SimulatorImpl> impl) [member function]
     cls.add_method('SetImplementation', 
                    'void', 
@@ -371,7 +373,7 @@
     ## simulator.h: static void ns3::Simulator::EnableLogTo(char const * filename) [member function]
     cls.add_method('EnableLogTo', 
                    'void', 
-                   [param('char *', 'filename', transfer_ownership=False, is_const=True)], 
+                   [param('char const *', 'filename')], 
                    is_static=True, deprecated=True)
     ## simulator.h: static void ns3::Simulator::Destroy() [member function]
     cls.add_method('Destroy', 
@@ -406,22 +408,22 @@
     ## simulator.h: static void ns3::Simulator::Stop(ns3::Time const & time) [member function]
     cls.add_method('Stop', 
                    'void', 
-                   [param('ns3::Time&', 'time', is_const=True)], 
+                   [param('ns3::Time const &', 'time')], 
                    is_static=True)
     ## simulator.h: static void ns3::Simulator::Remove(ns3::EventId const & id) [member function]
     cls.add_method('Remove', 
                    'void', 
-                   [param('ns3::EventId&', 'id', is_const=True)], 
+                   [param('ns3::EventId const &', 'id')], 
                    is_static=True)
     ## simulator.h: static void ns3::Simulator::Cancel(ns3::EventId const & id) [member function]
     cls.add_method('Cancel', 
                    'void', 
-                   [param('ns3::EventId&', 'id', is_const=True)], 
+                   [param('ns3::EventId const &', 'id')], 
                    is_static=True)
     ## simulator.h: static bool ns3::Simulator::IsExpired(ns3::EventId const & id) [member function]
     cls.add_method('IsExpired', 
                    'bool', 
-                   [param('ns3::EventId&', 'id', is_const=True)], 
+                   [param('ns3::EventId const &', 'id')], 
                    is_static=True)
     ## simulator.h: static ns3::Time ns3::Simulator::Now() [member function]
     cls.add_method('Now', 
@@ -431,7 +433,7 @@
     ## simulator.h: static ns3::Time ns3::Simulator::GetDelayLeft(ns3::EventId const & id) [member function]
     cls.add_method('GetDelayLeft', 
                    'ns3::Time', 
-                   [param('ns3::EventId&', 'id', is_const=True)], 
+                   [param('ns3::EventId const &', 'id')], 
                    is_static=True)
     ## simulator.h: static ns3::Time ns3::Simulator::GetMaximumSimulationTime() [member function]
     cls.add_method('GetMaximumSimulationTime', 
@@ -442,7 +444,7 @@
 
 def register_Ns3EventLock_methods(root_module, cls):
     ## event-impl.h: ns3::EventLock::EventLock(ns3::EventLock const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::EventLock&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::EventLock const &', 'arg0')])
     ## event-impl.h: ns3::EventLock::EventLock() [constructor]
     cls.add_constructor([])
     ## event-impl.h: void ns3::EventLock::Lock() [member function]
@@ -459,11 +461,11 @@
 
 def register_Ns3EventId_methods(root_module, cls):
     ## event-id.h: ns3::EventId::EventId(ns3::EventId const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::EventId&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::EventId const &', 'arg0')])
     ## event-id.h: ns3::EventId::EventId() [constructor]
     cls.add_constructor([])
     ## event-id.h: ns3::EventId::EventId(ns3::Ptr<ns3::EventImpl> const & impl, uint64_t ts, uint32_t uid) [constructor]
-    cls.add_constructor([param('ns3::Ptr< ns3::EventImpl >&', 'impl', is_const=True), param('uint64_t', 'ts'), param('uint32_t', 'uid')])
+    cls.add_constructor([param('ns3::Ptr< ns3::EventImpl >', 'impl'), param('uint64_t', 'ts'), param('uint32_t', 'uid')])
     ## event-id.h: void ns3::EventId::Cancel() [member function]
     cls.add_method('Cancel', 
                    'void', 
@@ -497,7 +499,7 @@
 
 def register_Ns3EventImpl_methods(root_module, cls):
     ## event-impl.h: ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::EventImpl&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::EventImpl const &', 'arg0')])
     ## event-impl.h: ns3::EventImpl::EventImpl() [constructor]
     cls.add_constructor([])
     ## event-impl.h: void ns3::EventImpl::Ref() const [member function]
@@ -541,7 +543,7 @@
 
 def register_Ns3RealtimeEventLock_methods(root_module, cls):
     ## realtime-simulator-impl.h: ns3::RealtimeEventLock::RealtimeEventLock(ns3::RealtimeEventLock const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::RealtimeEventLock&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::RealtimeEventLock const &', 'arg0')])
     ## realtime-simulator-impl.h: ns3::RealtimeEventLock::RealtimeEventLock() [constructor]
     cls.add_constructor([])
     ## realtime-simulator-impl.h: void ns3::RealtimeEventLock::Lock() [member function]
@@ -558,7 +560,7 @@
 
 def register_Ns3HighPrecision_methods(root_module, cls):
     ## high-precision-128.h: ns3::HighPrecision::HighPrecision(ns3::HighPrecision const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::HighPrecision&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::HighPrecision const &', 'arg0')])
     ## high-precision-128.h: ns3::HighPrecision::HighPrecision() [constructor]
     cls.add_constructor([])
     ## high-precision-128.h: ns3::HighPrecision::HighPrecision(int64_t value, bool dummy) [constructor]
@@ -583,23 +585,23 @@
     ## high-precision-128.h: bool ns3::HighPrecision::Add(ns3::HighPrecision const & o) [member function]
     cls.add_method('Add', 
                    'bool', 
-                   [param('ns3::HighPrecision&', 'o', is_const=True)])
+                   [param('ns3::HighPrecision const &', 'o')])
     ## high-precision-128.h: bool ns3::HighPrecision::Sub(ns3::HighPrecision const & o) [member function]
     cls.add_method('Sub', 
                    'bool', 
-                   [param('ns3::HighPrecision&', 'o', is_const=True)])
+                   [param('ns3::HighPrecision const &', 'o')])
     ## high-precision-128.h: bool ns3::HighPrecision::Mul(ns3::HighPrecision const & o) [member function]
     cls.add_method('Mul', 
                    'bool', 
-                   [param('ns3::HighPrecision&', 'o', is_const=True)])
+                   [param('ns3::HighPrecision const &', 'o')])
     ## high-precision-128.h: bool ns3::HighPrecision::Div(ns3::HighPrecision const & o) [member function]
     cls.add_method('Div', 
                    'bool', 
-                   [param('ns3::HighPrecision&', 'o', is_const=True)])
+                   [param('ns3::HighPrecision const &', 'o')])
     ## high-precision-128.h: int ns3::HighPrecision::Compare(ns3::HighPrecision const & o) const [member function]
     cls.add_method('Compare', 
                    'int', 
-                   [param('ns3::HighPrecision&', 'o', is_const=True)], 
+                   [param('ns3::HighPrecision const &', 'o')], 
                    is_const=True)
     ## high-precision-128.h: static ns3::HighPrecision ns3::HighPrecision::Zero() [member function]
     cls.add_method('Zero', 
@@ -610,14 +612,14 @@
 
 def register_Ns3TimeChecker_methods(root_module, cls):
     ## nstime.h: ns3::TimeChecker::TimeChecker(ns3::TimeChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::TimeChecker&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::TimeChecker const &', 'arg0')])
     ## nstime.h: ns3::TimeChecker::TimeChecker() [constructor]
     cls.add_constructor([])
     return
 
 def register_Ns3Scheduler_methods(root_module, cls):
     ## scheduler.h: ns3::Scheduler::Scheduler(ns3::Scheduler const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Scheduler&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Scheduler const &', 'arg0')])
     ## scheduler.h: ns3::Scheduler::Scheduler() [constructor]
     cls.add_constructor([])
     ## scheduler.h: static ns3::TypeId ns3::Scheduler::GetTypeId() [member function]
@@ -628,7 +630,7 @@
     ## scheduler.h: void ns3::Scheduler::Insert(ns3::EventId const & id) [member function]
     cls.add_method('Insert', 
                    'void', 
-                   [param('ns3::EventId&', 'id', is_const=True)], 
+                   [param('ns3::EventId const &', 'id')], 
                    is_pure_virtual=True, is_virtual=True)
     ## scheduler.h: bool ns3::Scheduler::IsEmpty() const [member function]
     cls.add_method('IsEmpty', 
@@ -648,7 +650,7 @@
     ## scheduler.h: bool ns3::Scheduler::Remove(ns3::EventId const & id) [member function]
     cls.add_method('Remove', 
                    'bool', 
-                   [param('ns3::EventId&', 'id', is_const=True)], 
+                   [param('ns3::EventId const &', 'id')], 
                    is_pure_virtual=True, is_virtual=True)
     return
 
@@ -658,22 +660,22 @@
     ## scheduler.h: ns3::Scheduler::EventKey::m_uid [variable]
     cls.add_instance_attribute('m_uid', 'uint32_t', is_const=False)
     ## scheduler.h: ns3::Scheduler::EventKey::EventKey(ns3::Scheduler::EventKey const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Scheduler::EventKey&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Scheduler::EventKey const &', 'arg0')])
     ## scheduler.h: ns3::Scheduler::EventKey::EventKey() [constructor]
     cls.add_constructor([])
     return
 
 def register_Ns3TimeValue_methods(root_module, cls):
     ## nstime.h: ns3::TimeValue::TimeValue(ns3::TimeValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::TimeValue&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::TimeValue const &', 'arg0')])
     ## nstime.h: ns3::TimeValue::TimeValue() [constructor]
     cls.add_constructor([])
     ## nstime.h: ns3::TimeValue::TimeValue(ns3::Time const & value) [constructor]
-    cls.add_constructor([param('ns3::Time&', 'value', is_const=True)])
+    cls.add_constructor([param('ns3::Time const &', 'value')])
     ## nstime.h: void ns3::TimeValue::Set(ns3::Time const & value) [member function]
     cls.add_method('Set', 
                    'void', 
-                   [param('ns3::Time&', 'value', is_const=True)])
+                   [param('ns3::Time const &', 'value')])
     ## nstime.h: ns3::Time ns3::TimeValue::Get() const [member function]
     cls.add_method('Get', 
                    'ns3::Time', 
@@ -698,7 +700,7 @@
 
 def register_Ns3SimulatorImpl_methods(root_module, cls):
     ## simulator-impl.h: ns3::SimulatorImpl::SimulatorImpl(ns3::SimulatorImpl const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::SimulatorImpl&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::SimulatorImpl const &', 'arg0')])
     ## simulator-impl.h: ns3::SimulatorImpl::SimulatorImpl() [constructor]
     cls.add_constructor([])
     ## simulator-impl.h: void ns3::SimulatorImpl::Destroy() [member function]
@@ -724,37 +726,37 @@
     ## simulator-impl.h: void ns3::SimulatorImpl::Stop(ns3::Time const & time) [member function]
     cls.add_method('Stop', 
                    'void', 
-                   [param('ns3::Time&', 'time', is_const=True)], 
+                   [param('ns3::Time const &', 'time')], 
                    is_pure_virtual=True, is_virtual=True)
     ## simulator-impl.h: ns3::EventId ns3::SimulatorImpl::Schedule(ns3::Time const & time, ns3::Ptr<ns3::EventImpl> const & event) [member function]
     cls.add_method('Schedule', 
                    'ns3::EventId', 
-                   [param('ns3::Time&', 'time', is_const=True), param('ns3::Ptr< ns3::EventImpl >&', 'event', is_const=True)], 
+                   [param('ns3::Time const &', 'time'), param('ns3::Ptr< ns3::EventImpl >', 'event')], 
                    is_pure_virtual=True, is_virtual=True)
     ## simulator-impl.h: ns3::EventId ns3::SimulatorImpl::ScheduleNow(ns3::Ptr<ns3::EventImpl> const & event) [member function]
     cls.add_method('ScheduleNow', 
                    'ns3::EventId', 
-                   [param('ns3::Ptr< ns3::EventImpl >&', 'event', is_const=True)], 
+                   [param('ns3::Ptr< ns3::EventImpl >', 'event')], 
                    is_pure_virtual=True, is_virtual=True)
     ## simulator-impl.h: ns3::EventId ns3::SimulatorImpl::ScheduleDestroy(ns3::Ptr<ns3::EventImpl> const & event) [member function]
     cls.add_method('ScheduleDestroy', 
                    'ns3::EventId', 
-                   [param('ns3::Ptr< ns3::EventImpl >&', 'event', is_const=True)], 
+                   [param('ns3::Ptr< ns3::EventImpl >', 'event')], 
                    is_pure_virtual=True, is_virtual=True)
     ## simulator-impl.h: void ns3::SimulatorImpl::Remove(ns3::EventId const & ev) [member function]
     cls.add_method('Remove', 
                    'void', 
-                   [param('ns3::EventId&', 'ev', is_const=True)], 
+                   [param('ns3::EventId const &', 'ev')], 
                    is_pure_virtual=True, is_virtual=True)
     ## simulator-impl.h: void ns3::SimulatorImpl::Cancel(ns3::EventId const & ev) [member function]
     cls.add_method('Cancel', 
                    'void', 
-                   [param('ns3::EventId&', 'ev', is_const=True)], 
+                   [param('ns3::EventId const &', 'ev')], 
                    is_pure_virtual=True, is_virtual=True)
     ## simulator-impl.h: bool ns3::SimulatorImpl::IsExpired(ns3::EventId const & ev) const [member function]
     cls.add_method('IsExpired', 
                    'bool', 
-                   [param('ns3::EventId&', 'ev', is_const=True)], 
+                   [param('ns3::EventId const &', 'ev')], 
                    is_pure_virtual=True, is_const=True, is_virtual=True)
     ## simulator-impl.h: void ns3::SimulatorImpl::Run() [member function]
     cls.add_method('Run', 
@@ -774,7 +776,7 @@
     ## simulator-impl.h: ns3::Time ns3::SimulatorImpl::GetDelayLeft(ns3::EventId const & id) const [member function]
     cls.add_method('GetDelayLeft', 
                    'ns3::Time', 
-                   [param('ns3::EventId&', 'id', is_const=True)], 
+                   [param('ns3::EventId const &', 'id')], 
                    is_pure_virtual=True, is_const=True, is_virtual=True)
     ## simulator-impl.h: ns3::Time ns3::SimulatorImpl::GetMaximumSimulationTime() const [member function]
     cls.add_method('GetMaximumSimulationTime', 
@@ -795,7 +797,7 @@
 
 def register_Ns3RealtimeSimulatorImpl_methods(root_module, cls):
     ## realtime-simulator-impl.h: ns3::RealtimeSimulatorImpl::RealtimeSimulatorImpl(ns3::RealtimeSimulatorImpl const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::RealtimeSimulatorImpl&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::RealtimeSimulatorImpl const &', 'arg0')])
     ## realtime-simulator-impl.h: static ns3::TypeId ns3::RealtimeSimulatorImpl::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -826,37 +828,37 @@
     ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::Stop(ns3::Time const & time) [member function]
     cls.add_method('Stop', 
                    'void', 
-                   [param('ns3::Time&', 'time', is_const=True)], 
+                   [param('ns3::Time const &', 'time')], 
                    is_virtual=True)
     ## realtime-simulator-impl.h: ns3::EventId ns3::RealtimeSimulatorImpl::Schedule(ns3::Time const & time, ns3::Ptr<ns3::EventImpl> const & event) [member function]
     cls.add_method('Schedule', 
                    'ns3::EventId', 
-                   [param('ns3::Time&', 'time', is_const=True), param('ns3::Ptr< ns3::EventImpl >&', 'event', is_const=True)], 
+                   [param('ns3::Time const &', 'time'), param('ns3::Ptr< ns3::EventImpl >', 'event')], 
                    is_virtual=True)
     ## realtime-simulator-impl.h: ns3::EventId ns3::RealtimeSimulatorImpl::ScheduleNow(ns3::Ptr<ns3::EventImpl> const & event) [member function]
     cls.add_method('ScheduleNow', 
                    'ns3::EventId', 
-                   [param('ns3::Ptr< ns3::EventImpl >&', 'event', is_const=True)], 
+                   [param('ns3::Ptr< ns3::EventImpl >', 'event')], 
                    is_virtual=True)
     ## realtime-simulator-impl.h: ns3::EventId ns3::RealtimeSimulatorImpl::ScheduleDestroy(ns3::Ptr<ns3::EventImpl> const & event) [member function]
     cls.add_method('ScheduleDestroy', 
                    'ns3::EventId', 
-                   [param('ns3::Ptr< ns3::EventImpl >&', 'event', is_const=True)], 
+                   [param('ns3::Ptr< ns3::EventImpl >', 'event')], 
                    is_virtual=True)
     ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::Remove(ns3::EventId const & ev) [member function]
     cls.add_method('Remove', 
                    'void', 
-                   [param('ns3::EventId&', 'ev', is_const=True)], 
+                   [param('ns3::EventId const &', 'ev')], 
                    is_virtual=True)
     ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::Cancel(ns3::EventId const & ev) [member function]
     cls.add_method('Cancel', 
                    'void', 
-                   [param('ns3::EventId&', 'ev', is_const=True)], 
+                   [param('ns3::EventId const &', 'ev')], 
                    is_virtual=True)
     ## realtime-simulator-impl.h: bool ns3::RealtimeSimulatorImpl::IsExpired(ns3::EventId const & ev) const [member function]
     cls.add_method('IsExpired', 
                    'bool', 
-                   [param('ns3::EventId&', 'ev', is_const=True)], 
+                   [param('ns3::EventId const &', 'ev')], 
                    is_const=True, is_virtual=True)
     ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::RunOneEvent() [member function]
     cls.add_method('RunOneEvent', 
@@ -876,7 +878,7 @@
     ## realtime-simulator-impl.h: ns3::Time ns3::RealtimeSimulatorImpl::GetDelayLeft(ns3::EventId const & id) const [member function]
     cls.add_method('GetDelayLeft', 
                    'ns3::Time', 
-                   [param('ns3::EventId&', 'id', is_const=True)], 
+                   [param('ns3::EventId const &', 'id')], 
                    is_const=True, is_virtual=True)
     ## realtime-simulator-impl.h: ns3::Time ns3::RealtimeSimulatorImpl::GetMaximumSimulationTime() const [member function]
     cls.add_method('GetMaximumSimulationTime', 
@@ -915,7 +917,7 @@
 
 def register_Ns3DefaultSimulatorImpl_methods(root_module, cls):
     ## default-simulator-impl.h: ns3::DefaultSimulatorImpl::DefaultSimulatorImpl(ns3::DefaultSimulatorImpl const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::DefaultSimulatorImpl&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::DefaultSimulatorImpl const &', 'arg0')])
     ## default-simulator-impl.h: static ns3::TypeId ns3::DefaultSimulatorImpl::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -946,37 +948,37 @@
     ## default-simulator-impl.h: void ns3::DefaultSimulatorImpl::Stop(ns3::Time const & time) [member function]
     cls.add_method('Stop', 
                    'void', 
-                   [param('ns3::Time&', 'time', is_const=True)], 
+                   [param('ns3::Time const &', 'time')], 
                    is_virtual=True)
     ## default-simulator-impl.h: ns3::EventId ns3::DefaultSimulatorImpl::Schedule(ns3::Time const & time, ns3::Ptr<ns3::EventImpl> const & event) [member function]
     cls.add_method('Schedule', 
                    'ns3::EventId', 
-                   [param('ns3::Time&', 'time', is_const=True), param('ns3::Ptr< ns3::EventImpl >&', 'event', is_const=True)], 
+                   [param('ns3::Time const &', 'time'), param('ns3::Ptr< ns3::EventImpl >', 'event')], 
                    is_virtual=True)
     ## default-simulator-impl.h: ns3::EventId ns3::DefaultSimulatorImpl::ScheduleNow(ns3::Ptr<ns3::EventImpl> const & event) [member function]
     cls.add_method('ScheduleNow', 
                    'ns3::EventId', 
-                   [param('ns3::Ptr< ns3::EventImpl >&', 'event', is_const=True)], 
+                   [param('ns3::Ptr< ns3::EventImpl >', 'event')], 
                    is_virtual=True)
     ## default-simulator-impl.h: ns3::EventId ns3::DefaultSimulatorImpl::ScheduleDestroy(ns3::Ptr<ns3::EventImpl> const & event) [member function]
     cls.add_method('ScheduleDestroy', 
                    'ns3::EventId', 
-                   [param('ns3::Ptr< ns3::EventImpl >&', 'event', is_const=True)], 
+                   [param('ns3::Ptr< ns3::EventImpl >', 'event')], 
                    is_virtual=True)
     ## default-simulator-impl.h: void ns3::DefaultSimulatorImpl::Remove(ns3::EventId const & ev) [member function]
     cls.add_method('Remove', 
                    'void', 
-                   [param('ns3::EventId&', 'ev', is_const=True)], 
+                   [param('ns3::EventId const &', 'ev')], 
                    is_virtual=True)
     ## default-simulator-impl.h: void ns3::DefaultSimulatorImpl::Cancel(ns3::EventId const & ev) [member function]
     cls.add_method('Cancel', 
                    'void', 
-                   [param('ns3::EventId&', 'ev', is_const=True)], 
+                   [param('ns3::EventId const &', 'ev')], 
                    is_virtual=True)
     ## default-simulator-impl.h: bool ns3::DefaultSimulatorImpl::IsExpired(ns3::EventId const & ev) const [member function]
     cls.add_method('IsExpired', 
                    'bool', 
-                   [param('ns3::EventId&', 'ev', is_const=True)], 
+                   [param('ns3::EventId const &', 'ev')], 
                    is_const=True, is_virtual=True)
     ## default-simulator-impl.h: void ns3::DefaultSimulatorImpl::Run() [member function]
     cls.add_method('Run', 
@@ -996,7 +998,7 @@
     ## default-simulator-impl.h: ns3::Time ns3::DefaultSimulatorImpl::GetDelayLeft(ns3::EventId const & id) const [member function]
     cls.add_method('GetDelayLeft', 
                    'ns3::Time', 
-                   [param('ns3::EventId&', 'id', is_const=True)], 
+                   [param('ns3::EventId const &', 'id')], 
                    is_const=True, is_virtual=True)
     ## default-simulator-impl.h: ns3::Time ns3::DefaultSimulatorImpl::GetMaximumSimulationTime() const [member function]
     cls.add_method('GetMaximumSimulationTime', 
@@ -1017,7 +1019,7 @@
 
 def register_Ns3Synchronizer_methods(root_module, cls):
     ## synchronizer.h: ns3::Synchronizer::Synchronizer(ns3::Synchronizer const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Synchronizer&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Synchronizer const &', 'arg0')])
     ## synchronizer.h: static ns3::TypeId ns3::Synchronizer::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1114,13 +1116,13 @@
 
 def register_Ns3HeapScheduler_methods(root_module, cls):
     ## heap-scheduler.h: ns3::HeapScheduler::HeapScheduler(ns3::HeapScheduler const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::HeapScheduler&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::HeapScheduler const &', 'arg0')])
     ## heap-scheduler.h: ns3::HeapScheduler::HeapScheduler() [constructor]
     cls.add_constructor([])
     ## heap-scheduler.h: void ns3::HeapScheduler::Insert(ns3::EventId const & id) [member function]
     cls.add_method('Insert', 
                    'void', 
-                   [param('ns3::EventId&', 'id', is_const=True)], 
+                   [param('ns3::EventId const &', 'id')], 
                    is_virtual=True)
     ## heap-scheduler.h: bool ns3::HeapScheduler::IsEmpty() const [member function]
     cls.add_method('IsEmpty', 
@@ -1140,19 +1142,19 @@
     ## heap-scheduler.h: bool ns3::HeapScheduler::Remove(ns3::EventId const & ev) [member function]
     cls.add_method('Remove', 
                    'bool', 
-                   [param('ns3::EventId&', 'ev', is_const=True)], 
+                   [param('ns3::EventId const &', 'ev')], 
                    is_virtual=True)
     return
 
 def register_Ns3ListScheduler_methods(root_module, cls):
     ## list-scheduler.h: ns3::ListScheduler::ListScheduler(ns3::ListScheduler const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::ListScheduler&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::ListScheduler const &', 'arg0')])
     ## list-scheduler.h: ns3::ListScheduler::ListScheduler() [constructor]
     cls.add_constructor([])
     ## list-scheduler.h: void ns3::ListScheduler::Insert(ns3::EventId const & id) [member function]
     cls.add_method('Insert', 
                    'void', 
-                   [param('ns3::EventId&', 'id', is_const=True)], 
+                   [param('ns3::EventId const &', 'id')], 
                    is_virtual=True)
     ## list-scheduler.h: bool ns3::ListScheduler::IsEmpty() const [member function]
     cls.add_method('IsEmpty', 
@@ -1172,19 +1174,19 @@
     ## list-scheduler.h: bool ns3::ListScheduler::Remove(ns3::EventId const & ev) [member function]
     cls.add_method('Remove', 
                    'bool', 
-                   [param('ns3::EventId&', 'ev', is_const=True)], 
+                   [param('ns3::EventId const &', 'ev')], 
                    is_virtual=True)
     return
 
 def register_Ns3MapScheduler_methods(root_module, cls):
     ## map-scheduler.h: ns3::MapScheduler::MapScheduler(ns3::MapScheduler const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::MapScheduler&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::MapScheduler const &', 'arg0')])
     ## map-scheduler.h: ns3::MapScheduler::MapScheduler() [constructor]
     cls.add_constructor([])
     ## map-scheduler.h: void ns3::MapScheduler::Insert(ns3::EventId const & id) [member function]
     cls.add_method('Insert', 
                    'void', 
-                   [param('ns3::EventId&', 'id', is_const=True)], 
+                   [param('ns3::EventId const &', 'id')], 
                    is_virtual=True)
     ## map-scheduler.h: bool ns3::MapScheduler::IsEmpty() const [member function]
     cls.add_method('IsEmpty', 
@@ -1204,19 +1206,19 @@
     ## map-scheduler.h: bool ns3::MapScheduler::Remove(ns3::EventId const & ev) [member function]
     cls.add_method('Remove', 
                    'bool', 
-                   [param('ns3::EventId&', 'ev', is_const=True)], 
+                   [param('ns3::EventId const &', 'ev')], 
                    is_virtual=True)
     return
 
 def register_Ns3WallClockSynchronizer_methods(root_module, cls):
     ## wall-clock-synchronizer.h: ns3::WallClockSynchronizer::US_PER_NS [variable]
-    cls.add_static_attribute('US_PER_NS', retval('uint64_t', is_const=True), is_const=True)
+    cls.add_static_attribute('US_PER_NS', 'uint64_t const', is_const=True)
     ## wall-clock-synchronizer.h: ns3::WallClockSynchronizer::US_PER_SEC [variable]
-    cls.add_static_attribute('US_PER_SEC', retval('uint64_t', is_const=True), is_const=True)
+    cls.add_static_attribute('US_PER_SEC', 'uint64_t const', is_const=True)
     ## wall-clock-synchronizer.h: ns3::WallClockSynchronizer::NS_PER_SEC [variable]
-    cls.add_static_attribute('NS_PER_SEC', retval('uint64_t', is_const=True), is_const=True)
+    cls.add_static_attribute('NS_PER_SEC', 'uint64_t const', is_const=True)
     ## wall-clock-synchronizer.h: ns3::WallClockSynchronizer::WallClockSynchronizer(ns3::WallClockSynchronizer const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::WallClockSynchronizer&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::WallClockSynchronizer const &', 'arg0')])
     ## wall-clock-synchronizer.h: ns3::WallClockSynchronizer::WallClockSynchronizer() [constructor]
     cls.add_constructor([])
     ## wall-clock-synchronizer.h: bool ns3::WallClockSynchronizer::DoRealtime() [member function]
@@ -1326,7 +1328,7 @@
     ## high-precision.h: extern ns3::HighPrecision ns3::Max(ns3::HighPrecision const & a, ns3::HighPrecision const & b) [free function]
     module.add_function('Max', 
                         'ns3::HighPrecision', 
-                        [param('ns3::HighPrecision&', 'a', is_const=True), param('ns3::HighPrecision&', 'b', is_const=True)])
+                        [param('ns3::HighPrecision const &', 'a'), param('ns3::HighPrecision const &', 'b')])
     ## nstime.h: extern ns3::Time ns3::FemtoSeconds(uint64_t fs) [free function]
     module.add_function('FemtoSeconds', 
                         'ns3::Time', 
@@ -1350,7 +1352,7 @@
     ## high-precision.h: extern ns3::HighPrecision ns3::Abs(ns3::HighPrecision const & value) [free function]
     module.add_function('Abs', 
                         'ns3::HighPrecision', 
-                        [param('ns3::HighPrecision&', 'value', is_const=True)])
+                        [param('ns3::HighPrecision const &', 'value')])
     ## nstime.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeTimeChecker() [free function]
     module.add_function('MakeTimeChecker', 
                         'ns3::Ptr< ns3::AttributeChecker const >', 
@@ -1366,7 +1368,7 @@
     ## high-precision.h: extern ns3::HighPrecision ns3::Min(ns3::HighPrecision const & a, ns3::HighPrecision const & b) [free function]
     module.add_function('Min', 
                         'ns3::HighPrecision', 
-                        [param('ns3::HighPrecision&', 'a', is_const=True), param('ns3::HighPrecision&', 'b', is_const=True)])
+                        [param('ns3::HighPrecision const &', 'a'), param('ns3::HighPrecision const &', 'b')])
     ## nstime.h: extern ns3::Time ns3::TimeStep(uint64_t ts) [free function]
     module.add_function('TimeStep', 
                         'ns3::Time', 
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bindings/python/ns3_module_stats.py	Tue Sep 02 11:12:42 2008 +0100
@@ -0,0 +1,439 @@
+from pybindgen import Module, FileCodeSink, param, retval, cppclass
+
+def register_types(module):
+    root_module = module.get_root()
+    
+    ## data-output-interface.h: ns3::DataOutputCallback [class]
+    module.add_class('DataOutputCallback', allow_subclassing=True)
+    ## data-calculator.h: ns3::DataCalculator [class]
+    module.add_class('DataCalculator', parent=root_module['ns3::Object'])
+    ## basic-data-calculators.h: ns3::CounterCalculator<unsigned int> [class]
+    module.add_class('CounterCalculator', template_parameters=['unsigned int'], parent=root_module['ns3::DataCalculator'])
+    ## data-collector.h: ns3::DataCollector [class]
+    module.add_class('DataCollector', parent=root_module['ns3::Object'])
+    ## time-data-calculators.h: ns3::TimeMinMaxAvgTotalCalculator [class]
+    module.add_class('TimeMinMaxAvgTotalCalculator', parent=root_module['ns3::DataCalculator'])
+    ## basic-data-calculators.h: ns3::MinMaxAvgTotalCalculator<unsigned int> [class]
+    module.add_class('MinMaxAvgTotalCalculator', template_parameters=['unsigned int'], parent=root_module['ns3::DataCalculator'])
+    ## data-output-interface.h: ns3::DataOutputInterface [class]
+    module.add_class('DataOutputInterface', parent=root_module['ns3::Object'])
+    ## packet-data-calculators.h: ns3::PacketCounterCalculator [class]
+    module.add_class('PacketCounterCalculator', parent=root_module['ns3::CounterCalculator< unsigned int >'])
+    ## packet-data-calculators.h: ns3::PacketSizeMinMaxAvgTotalCalculator [class]
+    module.add_class('PacketSizeMinMaxAvgTotalCalculator', parent=root_module['ns3::MinMaxAvgTotalCalculator< unsigned int >'])
+    ## omnet-data-output.h: ns3::OmnetDataOutput [class]
+    module.add_class('OmnetDataOutput', parent=root_module['ns3::DataOutputInterface'])
+    ## sqlite-data-output.h: ns3::SqliteDataOutput [class]
+    module.add_class('SqliteDataOutput', parent=root_module['ns3::DataOutputInterface'])
+    
+    ## 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_Ns3DataOutputCallback_methods(root_module, root_module['ns3::DataOutputCallback'])
+    register_Ns3DataCalculator_methods(root_module, root_module['ns3::DataCalculator'])
+    register_Ns3CounterCalculator__Unsigned_int_methods(root_module, root_module['ns3::CounterCalculator< unsigned int >'])
+    register_Ns3DataCollector_methods(root_module, root_module['ns3::DataCollector'])
+    register_Ns3TimeMinMaxAvgTotalCalculator_methods(root_module, root_module['ns3::TimeMinMaxAvgTotalCalculator'])
+    register_Ns3MinMaxAvgTotalCalculator__Unsigned_int_methods(root_module, root_module['ns3::MinMaxAvgTotalCalculator< unsigned int >'])
+    register_Ns3DataOutputInterface_methods(root_module, root_module['ns3::DataOutputInterface'])
+    register_Ns3PacketCounterCalculator_methods(root_module, root_module['ns3::PacketCounterCalculator'])
+    register_Ns3PacketSizeMinMaxAvgTotalCalculator_methods(root_module, root_module['ns3::PacketSizeMinMaxAvgTotalCalculator'])
+    register_Ns3OmnetDataOutput_methods(root_module, root_module['ns3::OmnetDataOutput'])
+    register_Ns3SqliteDataOutput_methods(root_module, root_module['ns3::SqliteDataOutput'])
+    return
+
+def register_Ns3DataOutputCallback_methods(root_module, cls):
+    ## data-output-interface.h: ns3::DataOutputCallback::DataOutputCallback(ns3::DataOutputCallback const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::DataOutputCallback const &', 'arg0')])
+    ## data-output-interface.h: ns3::DataOutputCallback::DataOutputCallback() [constructor]
+    cls.add_constructor([])
+    ## data-output-interface.h: void ns3::DataOutputCallback::OutputSingleton(std::string key, std::string variable, int val) [member function]
+    cls.add_method('OutputSingleton', 
+                   'void', 
+                   [param('std::string', 'key'), param('std::string', 'variable'), param('int', 'val')], 
+                   is_pure_virtual=True, is_virtual=True)
+    ## data-output-interface.h: void ns3::DataOutputCallback::OutputSingleton(std::string key, std::string variable, uint32_t val) [member function]
+    cls.add_method('OutputSingleton', 
+                   'void', 
+                   [param('std::string', 'key'), param('std::string', 'variable'), param('uint32_t', 'val')], 
+                   is_pure_virtual=True, is_virtual=True)
+    ## data-output-interface.h: void ns3::DataOutputCallback::OutputSingleton(std::string key, std::string variable, double val) [member function]
+    cls.add_method('OutputSingleton', 
+                   'void', 
+                   [param('std::string', 'key'), param('std::string', 'variable'), param('double', 'val')], 
+                   is_pure_virtual=True, is_virtual=True)
+    ## data-output-interface.h: void ns3::DataOutputCallback::OutputSingleton(std::string key, std::string variable, std::string val) [member function]
+    cls.add_method('OutputSingleton', 
+                   'void', 
+                   [param('std::string', 'key'), param('std::string', 'variable'), param('std::string', 'val')], 
+                   is_pure_virtual=True, is_virtual=True)
+    ## data-output-interface.h: void ns3::DataOutputCallback::OutputSingleton(std::string key, std::string variable, ns3::Time val) [member function]
+    cls.add_method('OutputSingleton', 
+                   'void', 
+                   [param('std::string', 'key'), param('std::string', 'variable'), param('ns3::Time', 'val')], 
+                   is_pure_virtual=True, is_virtual=True)
+    return
+
+def register_Ns3DataCalculator_methods(root_module, cls):
+    ## data-calculator.h: ns3::DataCalculator::DataCalculator(ns3::DataCalculator const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::DataCalculator const &', 'arg0')])
+    ## data-calculator.h: ns3::DataCalculator::DataCalculator() [constructor]
+    cls.add_constructor([])
+    ## data-calculator.h: bool ns3::DataCalculator::GetEnabled() const [member function]
+    cls.add_method('GetEnabled', 
+                   'bool', 
+                   [], 
+                   is_const=True)
+    ## data-calculator.h: void ns3::DataCalculator::Enable() [member function]
+    cls.add_method('Enable', 
+                   'void', 
+                   [])
+    ## data-calculator.h: void ns3::DataCalculator::Disable() [member function]
+    cls.add_method('Disable', 
+                   'void', 
+                   [])
+    ## data-calculator.h: void ns3::DataCalculator::SetKey(std::string const key) [member function]
+    cls.add_method('SetKey', 
+                   'void', 
+                   [param('std::string const', 'key')])
+    ## data-calculator.h: std::string const ns3::DataCalculator::GetKey() const [member function]
+    cls.add_method('GetKey', 
+                   'std::string const', 
+                   [], 
+                   is_const=True)
+    ## data-calculator.h: void ns3::DataCalculator::Start(ns3::Time const & startTime) [member function]
+    cls.add_method('Start', 
+                   'void', 
+                   [param('ns3::Time const &', 'startTime')], 
+                   is_virtual=True)
+    ## data-calculator.h: void ns3::DataCalculator::Stop(ns3::Time const & stopTime) [member function]
+    cls.add_method('Stop', 
+                   'void', 
+                   [param('ns3::Time const &', 'stopTime')], 
+                   is_virtual=True)
+    ## data-calculator.h: void ns3::DataCalculator::Output(ns3::DataOutputCallback & callback) const [member function]
+    cls.add_method('Output', 
+                   'void', 
+                   [param('ns3::DataOutputCallback &', 'callback')], 
+                   is_pure_virtual=True, is_const=True, is_virtual=True)
+    ## data-calculator.h: void ns3::DataCalculator::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
+    return
+
+def register_Ns3CounterCalculator__Unsigned_int_methods(root_module, cls):
+    ## basic-data-calculators.h: ns3::CounterCalculator<unsigned int>::CounterCalculator(ns3::CounterCalculator<unsigned int> const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::CounterCalculator< unsigned int >', 'arg0')])
+    ## basic-data-calculators.h: ns3::CounterCalculator<unsigned int>::CounterCalculator() [constructor]
+    cls.add_constructor([])
+    ## basic-data-calculators.h: void ns3::CounterCalculator<unsigned int>::Update() [member function]
+    cls.add_method('Update', 
+                   'void', 
+                   [])
+    ## basic-data-calculators.h: void ns3::CounterCalculator<unsigned int>::Update(unsigned int const i) [member function]
+    cls.add_method('Update', 
+                   'void', 
+                   [param('unsigned int const', 'i')])
+    ## basic-data-calculators.h: unsigned int ns3::CounterCalculator<unsigned int>::GetCount() const [member function]
+    cls.add_method('GetCount', 
+                   'unsigned int', 
+                   [], 
+                   is_const=True)
+    ## basic-data-calculators.h: void ns3::CounterCalculator<unsigned int>::Output(ns3::DataOutputCallback & callback) const [member function]
+    cls.add_method('Output', 
+                   'void', 
+                   [param('ns3::DataOutputCallback &', 'callback')], 
+                   is_const=True, is_virtual=True)
+    ## basic-data-calculators.h: void ns3::CounterCalculator<unsigned int>::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
+    cls.add_copy_constructor()
+    return
+
+def register_Ns3DataCollector_methods(root_module, cls):
+    ## data-collector.h: ns3::DataCollector::DataCollector(ns3::DataCollector const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::DataCollector const &', 'arg0')])
+    ## data-collector.h: ns3::DataCollector::DataCollector() [constructor]
+    cls.add_constructor([])
+    ## data-collector.h: void ns3::DataCollector::DescribeRun(std::string experiment, std::string strategy, std::string input, std::string runID, std::string description="") [member function]
+    cls.add_method('DescribeRun', 
+                   'void', 
+                   [param('std::string', 'experiment'), param('std::string', 'strategy'), param('std::string', 'input'), param('std::string', 'runID'), param('std::string', 'description', default_value='""')])
+    ## data-collector.h: std::string ns3::DataCollector::GetExperimentLabel() const [member function]
+    cls.add_method('GetExperimentLabel', 
+                   'std::string', 
+                   [], 
+                   is_const=True)
+    ## data-collector.h: std::string ns3::DataCollector::GetStrategyLabel() const [member function]
+    cls.add_method('GetStrategyLabel', 
+                   'std::string', 
+                   [], 
+                   is_const=True)
+    ## data-collector.h: std::string ns3::DataCollector::GetInputLabel() const [member function]
+    cls.add_method('GetInputLabel', 
+                   'std::string', 
+                   [], 
+                   is_const=True)
+    ## data-collector.h: std::string ns3::DataCollector::GetRunLabel() const [member function]
+    cls.add_method('GetRunLabel', 
+                   'std::string', 
+                   [], 
+                   is_const=True)
+    ## data-collector.h: std::string ns3::DataCollector::GetDescription() const [member function]
+    cls.add_method('GetDescription', 
+                   'std::string', 
+                   [], 
+                   is_const=True)
+    ## data-collector.h: void ns3::DataCollector::AddMetadata(std::string key, std::string value) [member function]
+    cls.add_method('AddMetadata', 
+                   'void', 
+                   [param('std::string', 'key'), param('std::string', 'value')])
+    ## data-collector.h: void ns3::DataCollector::AddMetadata(std::string key, double value) [member function]
+    cls.add_method('AddMetadata', 
+                   'void', 
+                   [param('std::string', 'key'), param('double', 'value')])
+    ## data-collector.h: void ns3::DataCollector::AddMetadata(std::string key, uint32_t value) [member function]
+    cls.add_method('AddMetadata', 
+                   'void', 
+                   [param('std::string', 'key'), param('uint32_t', 'value')])
+    ## data-collector.h: std::_List_iterator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > ns3::DataCollector::MetadataBegin() [member function]
+    cls.add_method('MetadataBegin', 
+                   'std::_List_iterator< std::pair< std::basic_string< char, std::char_traits< char >, std::allocator< char > >, std::basic_string< char, std::char_traits< char >, std::allocator< char > > > >', 
+                   [])
+    ## data-collector.h: std::_List_iterator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > ns3::DataCollector::MetadataEnd() [member function]
+    cls.add_method('MetadataEnd', 
+                   'std::_List_iterator< std::pair< std::basic_string< char, std::char_traits< char >, std::allocator< char > >, std::basic_string< char, std::char_traits< char >, std::allocator< char > > > >', 
+                   [])
+    ## data-collector.h: void ns3::DataCollector::AddDataCalculator(ns3::Ptr<ns3::DataCalculator> datac) [member function]
+    cls.add_method('AddDataCalculator', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::DataCalculator >', 'datac')])
+    ## data-collector.h: std::_List_iterator<ns3::Ptr<ns3::DataCalculator> > ns3::DataCollector::DataCalculatorBegin() [member function]
+    cls.add_method('DataCalculatorBegin', 
+                   'std::_List_iterator< ns3::Ptr< ns3::DataCalculator > >', 
+                   [])
+    ## data-collector.h: std::_List_iterator<ns3::Ptr<ns3::DataCalculator> > ns3::DataCollector::DataCalculatorEnd() [member function]
+    cls.add_method('DataCalculatorEnd', 
+                   'std::_List_iterator< ns3::Ptr< ns3::DataCalculator > >', 
+                   [])
+    ## data-collector.h: void ns3::DataCollector::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
+    return
+
+def register_Ns3TimeMinMaxAvgTotalCalculator_methods(root_module, cls):
+    ## time-data-calculators.h: ns3::TimeMinMaxAvgTotalCalculator::TimeMinMaxAvgTotalCalculator(ns3::TimeMinMaxAvgTotalCalculator const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::TimeMinMaxAvgTotalCalculator const &', 'arg0')])
+    ## time-data-calculators.h: ns3::TimeMinMaxAvgTotalCalculator::TimeMinMaxAvgTotalCalculator() [constructor]
+    cls.add_constructor([])
+    ## time-data-calculators.h: void ns3::TimeMinMaxAvgTotalCalculator::Update(ns3::Time const i) [member function]
+    cls.add_method('Update', 
+                   'void', 
+                   [param('ns3::Time const', 'i')])
+    ## time-data-calculators.h: void ns3::TimeMinMaxAvgTotalCalculator::Output(ns3::DataOutputCallback & callback) const [member function]
+    cls.add_method('Output', 
+                   'void', 
+                   [param('ns3::DataOutputCallback &', 'callback')], 
+                   is_const=True, is_virtual=True)
+    ## time-data-calculators.h: void ns3::TimeMinMaxAvgTotalCalculator::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
+    return
+
+def register_Ns3MinMaxAvgTotalCalculator__Unsigned_int_methods(root_module, cls):
+    ## basic-data-calculators.h: ns3::MinMaxAvgTotalCalculator<unsigned int>::MinMaxAvgTotalCalculator(ns3::MinMaxAvgTotalCalculator<unsigned int> const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::MinMaxAvgTotalCalculator< unsigned int >', 'arg0')])
+    ## basic-data-calculators.h: ns3::MinMaxAvgTotalCalculator<unsigned int>::MinMaxAvgTotalCalculator() [constructor]
+    cls.add_constructor([])
+    ## basic-data-calculators.h: void ns3::MinMaxAvgTotalCalculator<unsigned int>::Update(unsigned int const i) [member function]
+    cls.add_method('Update', 
+                   'void', 
+                   [param('unsigned int const', 'i')])
+    ## basic-data-calculators.h: void ns3::MinMaxAvgTotalCalculator<unsigned int>::Output(ns3::DataOutputCallback & callback) const [member function]
+    cls.add_method('Output', 
+                   'void', 
+                   [param('ns3::DataOutputCallback &', 'callback')], 
+                   is_const=True, is_virtual=True)
+    ## basic-data-calculators.h: void ns3::MinMaxAvgTotalCalculator<unsigned int>::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
+    cls.add_copy_constructor()
+    return
+
+def register_Ns3DataOutputInterface_methods(root_module, cls):
+    ## data-output-interface.h: ns3::DataOutputInterface::DataOutputInterface(ns3::DataOutputInterface const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::DataOutputInterface const &', 'arg0')])
+    ## data-output-interface.h: ns3::DataOutputInterface::DataOutputInterface() [constructor]
+    cls.add_constructor([])
+    ## data-output-interface.h: void ns3::DataOutputInterface::Output(ns3::DataCollector & dc) [member function]
+    cls.add_method('Output', 
+                   'void', 
+                   [param('ns3::DataCollector &', 'dc')], 
+                   is_pure_virtual=True, is_virtual=True)
+    ## data-output-interface.h: void ns3::DataOutputInterface::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
+    return
+
+def register_Ns3PacketCounterCalculator_methods(root_module, cls):
+    ## packet-data-calculators.h: ns3::PacketCounterCalculator::PacketCounterCalculator(ns3::PacketCounterCalculator const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::PacketCounterCalculator const &', 'arg0')])
+    ## packet-data-calculators.h: ns3::PacketCounterCalculator::PacketCounterCalculator() [constructor]
+    cls.add_constructor([])
+    ## packet-data-calculators.h: void ns3::PacketCounterCalculator::PacketUpdate(std::string path, ns3::Ptr<const ns3::Packet> packet) [member function]
+    cls.add_method('PacketUpdate', 
+                   'void', 
+                   [param('std::string', 'path'), param('ns3::Ptr< const ns3::Packet >', 'packet')])
+    ## packet-data-calculators.h: void ns3::PacketCounterCalculator::FrameUpdate(std::string path, ns3::Ptr<const ns3::Packet> packet, ns3::Mac48Address realto) [member function]
+    cls.add_method('FrameUpdate', 
+                   'void', 
+                   [param('std::string', 'path'), param('ns3::Ptr< const ns3::Packet >', 'packet'), param('ns3::Mac48Address', 'realto')])
+    ## packet-data-calculators.h: void ns3::PacketCounterCalculator::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
+    return
+
+def register_Ns3PacketSizeMinMaxAvgTotalCalculator_methods(root_module, cls):
+    ## packet-data-calculators.h: ns3::PacketSizeMinMaxAvgTotalCalculator::PacketSizeMinMaxAvgTotalCalculator(ns3::PacketSizeMinMaxAvgTotalCalculator const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::PacketSizeMinMaxAvgTotalCalculator const &', 'arg0')])
+    ## packet-data-calculators.h: ns3::PacketSizeMinMaxAvgTotalCalculator::PacketSizeMinMaxAvgTotalCalculator() [constructor]
+    cls.add_constructor([])
+    ## packet-data-calculators.h: void ns3::PacketSizeMinMaxAvgTotalCalculator::PacketUpdate(std::string path, ns3::Ptr<const ns3::Packet> packet) [member function]
+    cls.add_method('PacketUpdate', 
+                   'void', 
+                   [param('std::string', 'path'), param('ns3::Ptr< const ns3::Packet >', 'packet')])
+    ## packet-data-calculators.h: void ns3::PacketSizeMinMaxAvgTotalCalculator::FrameUpdate(std::string path, ns3::Ptr<const ns3::Packet> packet, ns3::Mac48Address realto) [member function]
+    cls.add_method('FrameUpdate', 
+                   'void', 
+                   [param('std::string', 'path'), param('ns3::Ptr< const ns3::Packet >', 'packet'), param('ns3::Mac48Address', 'realto')])
+    ## packet-data-calculators.h: void ns3::PacketSizeMinMaxAvgTotalCalculator::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
+    return
+
+def register_Ns3OmnetDataOutput_methods(root_module, cls):
+    ## omnet-data-output.h: ns3::OmnetDataOutput::OmnetDataOutput(ns3::OmnetDataOutput const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::OmnetDataOutput const &', 'arg0')])
+    ## omnet-data-output.h: ns3::OmnetDataOutput::OmnetDataOutput() [constructor]
+    cls.add_constructor([])
+    ## omnet-data-output.h: void ns3::OmnetDataOutput::Output(ns3::DataCollector & dc) [member function]
+    cls.add_method('Output', 
+                   'void', 
+                   [param('ns3::DataCollector &', 'dc')], 
+                   is_virtual=True)
+    ## omnet-data-output.h: void ns3::OmnetDataOutput::SetFilePrefix(std::string const prefix) [member function]
+    cls.add_method('SetFilePrefix', 
+                   'void', 
+                   [param('std::string const', 'prefix')])
+    ## omnet-data-output.h: std::string ns3::OmnetDataOutput::GetFilePrefix() const [member function]
+    cls.add_method('GetFilePrefix', 
+                   'std::string', 
+                   [], 
+                   is_const=True)
+    ## omnet-data-output.h: void ns3::OmnetDataOutput::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
+    return
+
+def register_Ns3SqliteDataOutput_methods(root_module, cls):
+    ## sqlite-data-output.h: ns3::SqliteDataOutput::SqliteDataOutput(ns3::SqliteDataOutput const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::SqliteDataOutput const &', 'arg0')])
+    ## sqlite-data-output.h: ns3::SqliteDataOutput::SqliteDataOutput() [constructor]
+    cls.add_constructor([])
+    ## sqlite-data-output.h: void ns3::SqliteDataOutput::Output(ns3::DataCollector & dc) [member function]
+    cls.add_method('Output', 
+                   'void', 
+                   [param('ns3::DataCollector &', 'dc')], 
+                   is_virtual=True)
+    ## sqlite-data-output.h: void ns3::SqliteDataOutput::SetDBFile(std::string const file) [member function]
+    cls.add_method('SetDBFile', 
+                   'void', 
+                   [param('std::string const', 'file')])
+    ## sqlite-data-output.h: std::string ns3::SqliteDataOutput::GetDBFile() const [member function]
+    cls.add_method('GetDBFile', 
+                   'std::string', 
+                   [], 
+                   is_const=True)
+    ## sqlite-data-output.h: void ns3::SqliteDataOutput::DoDispose() [member function]
+    cls.add_method('DoDispose', 
+                   'void', 
+                   [], 
+                   visibility='protected', 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_udp_echo.py	Sun Aug 31 22:33:23 2008 +0100
+++ b/bindings/python/ns3_module_udp_echo.py	Tue Sep 02 11:12:42 2008 +0100
@@ -55,7 +55,7 @@
 
 def register_Ns3UdpEchoClient_methods(root_module, cls):
     ## udp-echo-client.h: ns3::UdpEchoClient::UdpEchoClient(ns3::UdpEchoClient const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::UdpEchoClient&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::UdpEchoClient const &', 'arg0')])
     ## udp-echo-client.h: static ns3::TypeId ns3::UdpEchoClient::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -86,7 +86,7 @@
 
 def register_Ns3UdpEchoServer_methods(root_module, cls):
     ## udp-echo-server.h: ns3::UdpEchoServer::UdpEchoServer(ns3::UdpEchoServer const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::UdpEchoServer&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::UdpEchoServer const &', 'arg0')])
     ## udp-echo-server.h: static ns3::TypeId ns3::UdpEchoServer::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
--- a/bindings/python/ns3_module_wifi.py	Sun Aug 31 22:33:23 2008 +0100
+++ b/bindings/python/ns3_module_wifi.py	Tue Sep 02 11:12:42 2008 +0100
@@ -77,10 +77,10 @@
     module.add_class('AdhocWifiMac', parent=root_module['ns3::WifiMac'])
     ## jakes-propagation-loss-model.h: ns3::JakesPropagationLossModel [class]
     module.add_class('JakesPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
+    ## propagation-delay-model.h: ns3::ConstantSpeedPropagationDelayModel [class]
+    module.add_class('ConstantSpeedPropagationDelayModel', parent=root_module['ns3::PropagationDelayModel'])
     ## wifi-net-device.h: ns3::WifiNetDevice [class]
     module.add_class('WifiNetDevice', parent=root_module['ns3::NetDevice'])
-    ## propagation-delay-model.h: ns3::ConstantSpeedPropagationDelayModel [class]
-    module.add_class('ConstantSpeedPropagationDelayModel', parent=root_module['ns3::PropagationDelayModel'])
     ## propagation-loss-model.h: ns3::RandomPropagationLossModel [class]
     module.add_class('RandomPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
     ## propagation-delay-model.h: ns3::RandomPropagationDelayModel [class]
@@ -170,8 +170,8 @@
     register_Ns3PropagationDelayModel_methods(root_module, root_module['ns3::PropagationDelayModel'])
     register_Ns3AdhocWifiMac_methods(root_module, root_module['ns3::AdhocWifiMac'])
     register_Ns3JakesPropagationLossModel_methods(root_module, root_module['ns3::JakesPropagationLossModel'])
+    register_Ns3ConstantSpeedPropagationDelayModel_methods(root_module, root_module['ns3::ConstantSpeedPropagationDelayModel'])
     register_Ns3WifiNetDevice_methods(root_module, root_module['ns3::WifiNetDevice'])
-    register_Ns3ConstantSpeedPropagationDelayModel_methods(root_module, root_module['ns3::ConstantSpeedPropagationDelayModel'])
     register_Ns3RandomPropagationLossModel_methods(root_module, root_module['ns3::RandomPropagationLossModel'])
     register_Ns3RandomPropagationDelayModel_methods(root_module, root_module['ns3::RandomPropagationDelayModel'])
     register_Ns3AmrrWifiManager_methods(root_module, root_module['ns3::AmrrWifiManager'])
@@ -183,7 +183,7 @@
 
 def register_Ns3WifiRemoteStation_methods(root_module, cls):
     ## wifi-remote-station-manager.h: ns3::WifiRemoteStation::WifiRemoteStation(ns3::WifiRemoteStation const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::WifiRemoteStation&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::WifiRemoteStation const &', 'arg0')])
     ## wifi-remote-station-manager.h: static ns3::TypeId ns3::WifiRemoteStation::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -377,7 +377,7 @@
 
 def register_Ns3WifiPhyListener_methods(root_module, cls):
     ## wifi-phy.h: ns3::WifiPhyListener::WifiPhyListener(ns3::WifiPhyListener const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::WifiPhyListener&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::WifiPhyListener const &', 'arg0')])
     ## wifi-phy.h: ns3::WifiPhyListener::WifiPhyListener() [constructor]
     cls.add_constructor([])
     ## wifi-phy.h: void ns3::WifiPhyListener::NotifyRxStart(ns3::Time duration) [member function]
@@ -417,14 +417,14 @@
     ## rraa-wifi-manager.h: ns3::ThresholdsItem::ewnd [variable]
     cls.add_instance_attribute('ewnd', 'uint32_t', is_const=False)
     ## rraa-wifi-manager.h: ns3::ThresholdsItem::ThresholdsItem(ns3::ThresholdsItem const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::ThresholdsItem&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::ThresholdsItem const &', 'arg0')])
     ## rraa-wifi-manager.h: ns3::ThresholdsItem::ThresholdsItem() [constructor]
     cls.add_constructor([])
     return
 
 def register_Ns3SupportedRates_methods(root_module, cls):
     ## supported-rates.h: ns3::SupportedRates::SupportedRates(ns3::SupportedRates const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::SupportedRates&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::SupportedRates const &', 'arg0')])
     ## supported-rates.h: ns3::SupportedRates::SupportedRates() [constructor]
     cls.add_constructor([])
     ## supported-rates.h: void ns3::SupportedRates::AddSupportedRate(uint32_t bs) [member function]
@@ -474,7 +474,7 @@
 
 def register_Ns3IdealWifiRemoteStation_methods(root_module, cls):
     ## ideal-wifi-manager.h: ns3::IdealWifiRemoteStation::IdealWifiRemoteStation(ns3::IdealWifiRemoteStation const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::IdealWifiRemoteStation&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::IdealWifiRemoteStation const &', 'arg0')])
     ## ideal-wifi-manager.h: ns3::IdealWifiRemoteStation::IdealWifiRemoteStation(ns3::Ptr<ns3::IdealWifiManager> stations) [constructor]
     cls.add_constructor([param('ns3::Ptr< ns3::IdealWifiManager >', 'stations')])
     ## ideal-wifi-manager.h: void ns3::IdealWifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function]
@@ -531,14 +531,14 @@
 
 def register_Ns3WifiModeChecker_methods(root_module, cls):
     ## wifi-mode.h: ns3::WifiModeChecker::WifiModeChecker(ns3::WifiModeChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::WifiModeChecker&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::WifiModeChecker const &', 'arg0')])
     ## wifi-mode.h: ns3::WifiModeChecker::WifiModeChecker() [constructor]
     cls.add_constructor([])
     return
 
 def register_Ns3WifiModeFactory_methods(root_module, cls):
     ## wifi-mode.h: ns3::WifiModeFactory::WifiModeFactory(ns3::WifiModeFactory const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::WifiModeFactory&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::WifiModeFactory const &', 'arg0')])
     ## wifi-mode.h: static ns3::WifiMode ns3::WifiModeFactory::CreateBpsk(std::string uniqueName, bool isMandatory, uint32_t bandwidth, uint32_t dataRate, uint32_t phyRate) [member function]
     cls.add_method('CreateBpsk', 
                    'ns3::WifiMode', 
@@ -553,7 +553,7 @@
 
 def register_Ns3OnoeWifiRemoteStation_methods(root_module, cls):
     ## onoe-wifi-manager.h: ns3::OnoeWifiRemoteStation::OnoeWifiRemoteStation(ns3::OnoeWifiRemoteStation const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::OnoeWifiRemoteStation&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::OnoeWifiRemoteStation const &', 'arg0')])
     ## onoe-wifi-manager.h: ns3::OnoeWifiRemoteStation::OnoeWifiRemoteStation(ns3::Ptr<ns3::OnoeWifiManager> stations) [constructor]
     cls.add_constructor([param('ns3::Ptr< ns3::OnoeWifiManager >', 'stations')])
     ## onoe-wifi-manager.h: void ns3::OnoeWifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function]
@@ -610,7 +610,7 @@
 
 def register_Ns3RraaWifiRemoteStation_methods(root_module, cls):
     ## rraa-wifi-manager.h: ns3::RraaWifiRemoteStation::RraaWifiRemoteStation(ns3::RraaWifiRemoteStation const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::RraaWifiRemoteStation&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::RraaWifiRemoteStation const &', 'arg0')])
     ## rraa-wifi-manager.h: ns3::RraaWifiRemoteStation::RraaWifiRemoteStation(ns3::Ptr<ns3::RraaWifiManager> stations) [constructor]
     cls.add_constructor([param('ns3::Ptr< ns3::RraaWifiManager >', 'stations')])
     ## rraa-wifi-manager.h: bool ns3::RraaWifiRemoteStation::NeedRts(ns3::Ptr<const ns3::Packet> packet) [member function]
@@ -672,13 +672,13 @@
 
 def register_Ns3Ssid_methods(root_module, cls):
     ## ssid.h: ns3::Ssid::Ssid(ns3::Ssid const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Ssid&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::Ssid const &', 'arg0')])
     ## ssid.h: ns3::Ssid::Ssid() [constructor]
     cls.add_constructor([])
     ## ssid.h: ns3::Ssid::Ssid(char const * ssid) [constructor]
-    cls.add_constructor([param('char *', 'ssid', transfer_ownership=False, is_const=True)])
+    cls.add_constructor([param('char const *', 'ssid')])
     ## ssid.h: ns3::Ssid::Ssid(char const * ssid, uint8_t length) [constructor]
-    cls.add_constructor([param('char *', 'ssid', transfer_ownership=False, is_const=True), param('uint8_t', 'length')])
+    cls.add_constructor([param('char const *', 'ssid'), param('uint8_t', 'length')])
     ## ssid.h: ns3::Buffer::Iterator ns3::Ssid::Deserialize(ns3::Buffer::Iterator i) [member function]
     cls.add_method('Deserialize', 
                    'ns3::Buffer::Iterator', 
@@ -701,7 +701,7 @@
     ## ssid.h: bool ns3::Ssid::IsEqual(ns3::Ssid const & o) const [member function]
     cls.add_method('IsEqual', 
                    'bool', 
-                   [param('ns3::Ssid&', 'o', is_const=True)], 
+                   [param('ns3::Ssid const &', 'o')], 
                    is_const=True)
     ## ssid.h: char * ns3::Ssid::PeekString() const [member function]
     cls.add_method('PeekString', 
@@ -718,7 +718,7 @@
 
 def register_Ns3WifiMode_methods(root_module, cls):
     ## wifi-mode.h: ns3::WifiMode::WifiMode(ns3::WifiMode const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::WifiMode&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::WifiMode const &', 'arg0')])
     ## wifi-mode.h: ns3::WifiMode::WifiMode() [constructor]
     cls.add_constructor([])
     ## wifi-mode.h: uint32_t ns3::WifiMode::GetBandwidth() const [member function]
@@ -776,15 +776,15 @@
 
 def register_Ns3SsidValue_methods(root_module, cls):
     ## ssid.h: ns3::SsidValue::SsidValue(ns3::SsidValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::SsidValue&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::SsidValue const &', 'arg0')])
     ## ssid.h: ns3::SsidValue::SsidValue() [constructor]
     cls.add_constructor([])
     ## ssid.h: ns3::SsidValue::SsidValue(ns3::Ssid const & value) [constructor]
-    cls.add_constructor([param('ns3::Ssid&', 'value', is_const=True)])
+    cls.add_constructor([param('ns3::Ssid const &', 'value')])
     ## ssid.h: void ns3::SsidValue::Set(ns3::Ssid const & value) [member function]
     cls.add_method('Set', 
                    'void', 
-                   [param('ns3::Ssid&', 'value', is_const=True)])
+                   [param('ns3::Ssid const &', 'value')])
     ## ssid.h: ns3::Ssid ns3::SsidValue::Get() const [member function]
     cls.add_method('Get', 
                    'ns3::Ssid', 
@@ -809,14 +809,14 @@
 
 def register_Ns3SsidChecker_methods(root_module, cls):
     ## ssid.h: ns3::SsidChecker::SsidChecker(ns3::SsidChecker const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::SsidChecker&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::SsidChecker const &', 'arg0')])
     ## ssid.h: ns3::SsidChecker::SsidChecker() [constructor]
     cls.add_constructor([])
     return
 
 def register_Ns3ConstantRateWifiRemoteStation_methods(root_module, cls):
     ## constant-rate-wifi-manager.h: ns3::ConstantRateWifiRemoteStation::ConstantRateWifiRemoteStation(ns3::ConstantRateWifiRemoteStation const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::ConstantRateWifiRemoteStation&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::ConstantRateWifiRemoteStation const &', 'arg0')])
     ## constant-rate-wifi-manager.h: ns3::ConstantRateWifiRemoteStation::ConstantRateWifiRemoteStation(ns3::Ptr<ns3::ConstantRateWifiManager> stations) [constructor]
     cls.add_constructor([param('ns3::Ptr< ns3::ConstantRateWifiManager >', 'stations')])
     ## constant-rate-wifi-manager.h: void ns3::ConstantRateWifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function]
@@ -873,7 +873,7 @@
 
 def register_Ns3PropagationLossModel_methods(root_module, cls):
     ## propagation-loss-model.h: ns3::PropagationLossModel::PropagationLossModel(ns3::PropagationLossModel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::PropagationLossModel&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::PropagationLossModel const &', 'arg0')])
     ## propagation-loss-model.h: ns3::PropagationLossModel::PropagationLossModel() [constructor]
     cls.add_constructor([])
     ## propagation-loss-model.h: static ns3::TypeId ns3::PropagationLossModel::GetTypeId() [member function]
@@ -890,7 +890,7 @@
 
 def register_Ns3ArfWifiRemoteStation_methods(root_module, cls):
     ## arf-wifi-manager.h: ns3::ArfWifiRemoteStation::ArfWifiRemoteStation(ns3::ArfWifiRemoteStation const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::ArfWifiRemoteStation&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::ArfWifiRemoteStation const &', 'arg0')])
     ## arf-wifi-manager.h: ns3::ArfWifiRemoteStation::ArfWifiRemoteStation(ns3::Ptr<ns3::ArfWifiManager> stations, int minTimerTimeout, int minSuccessThreshold) [constructor]
     cls.add_constructor([param('ns3::Ptr< ns3::ArfWifiManager >', 'stations'), param('int', 'minTimerTimeout'), param('int', 'minSuccessThreshold')])
     ## arf-wifi-manager.h: void ns3::ArfWifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function]
@@ -987,7 +987,7 @@
 
 def register_Ns3WifiMac_methods(root_module, cls):
     ## wifi-mac.h: ns3::WifiMac::WifiMac(ns3::WifiMac const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::WifiMac&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::WifiMac const &', 'arg0')])
     ## wifi-mac.h: ns3::WifiMac::WifiMac() [constructor]
     cls.add_constructor([])
     ## wifi-mac.h: static ns3::TypeId ns3::WifiMac::GetTypeId() [member function]
@@ -1243,7 +1243,7 @@
 
 def register_Ns3CompositePropagationLossModel_methods(root_module, cls):
     ## composite-propagation-loss-model.h: ns3::CompositePropagationLossModel::CompositePropagationLossModel(ns3::CompositePropagationLossModel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::CompositePropagationLossModel&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::CompositePropagationLossModel const &', 'arg0')])
     ## composite-propagation-loss-model.h: static ns3::TypeId ns3::CompositePropagationLossModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1269,7 +1269,7 @@
 
 def register_Ns3AmrrWifiRemoteStation_methods(root_module, cls):
     ## amrr-wifi-manager.h: ns3::AmrrWifiRemoteStation::AmrrWifiRemoteStation(ns3::AmrrWifiRemoteStation const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::AmrrWifiRemoteStation&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::AmrrWifiRemoteStation const &', 'arg0')])
     ## amrr-wifi-manager.h: ns3::AmrrWifiRemoteStation::AmrrWifiRemoteStation(ns3::Ptr<ns3::AmrrWifiManager> stations) [constructor]
     cls.add_constructor([param('ns3::Ptr< ns3::AmrrWifiManager >', 'stations')])
     ## amrr-wifi-manager.h: void ns3::AmrrWifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function]
@@ -1326,7 +1326,7 @@
 
 def register_Ns3FriisPropagationLossModel_methods(root_module, cls):
     ## propagation-loss-model.h: ns3::FriisPropagationLossModel::FriisPropagationLossModel(ns3::FriisPropagationLossModel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::FriisPropagationLossModel&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::FriisPropagationLossModel const &', 'arg0')])
     ## propagation-loss-model.h: static ns3::TypeId ns3::FriisPropagationLossModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1490,7 +1490,7 @@
 
 def register_Ns3WifiRemoteStationManager_methods(root_module, cls):
     ## wifi-remote-station-manager.h: ns3::WifiRemoteStationManager::WifiRemoteStationManager(ns3::WifiRemoteStationManager const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::WifiRemoteStationManager&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::WifiRemoteStationManager const &', 'arg0')])
     ## wifi-remote-station-manager.h: static ns3::TypeId ns3::WifiRemoteStationManager::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1599,15 +1599,15 @@
 
 def register_Ns3WifiModeValue_methods(root_module, cls):
     ## wifi-mode.h: ns3::WifiModeValue::WifiModeValue(ns3::WifiModeValue const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::WifiModeValue&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::WifiModeValue const &', 'arg0')])
     ## wifi-mode.h: ns3::WifiModeValue::WifiModeValue() [constructor]
     cls.add_constructor([])
     ## wifi-mode.h: ns3::WifiModeValue::WifiModeValue(ns3::WifiMode const & value) [constructor]
-    cls.add_constructor([param('ns3::WifiMode&', 'value', is_const=True)])
+    cls.add_constructor([param('ns3::WifiMode const &', 'value')])
     ## wifi-mode.h: void ns3::WifiModeValue::Set(ns3::WifiMode const & value) [member function]
     cls.add_method('Set', 
                    'void', 
-                   [param('ns3::WifiMode&', 'value', is_const=True)])
+                   [param('ns3::WifiMode const &', 'value')])
     ## wifi-mode.h: ns3::WifiMode ns3::WifiModeValue::Get() const [member function]
     cls.add_method('Get', 
                    'ns3::WifiMode', 
@@ -1632,7 +1632,7 @@
 
 def register_Ns3OnoeWifiManager_methods(root_module, cls):
     ## onoe-wifi-manager.h: ns3::OnoeWifiManager::OnoeWifiManager(ns3::OnoeWifiManager const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::OnoeWifiManager&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::OnoeWifiManager const &', 'arg0')])
     ## onoe-wifi-manager.h: static ns3::TypeId ns3::OnoeWifiManager::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1813,7 +1813,7 @@
 
 def register_Ns3WifiChannel_methods(root_module, cls):
     ## wifi-channel.h: ns3::WifiChannel::WifiChannel(ns3::WifiChannel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::WifiChannel&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::WifiChannel const &', 'arg0')])
     ## wifi-channel.h: static ns3::TypeId ns3::WifiChannel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1852,7 +1852,7 @@
 
 def register_Ns3LogDistancePropagationLossModel_methods(root_module, cls):
     ## propagation-loss-model.h: ns3::LogDistancePropagationLossModel::LogDistancePropagationLossModel(ns3::LogDistancePropagationLossModel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::LogDistancePropagationLossModel&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::LogDistancePropagationLossModel const &', 'arg0')])
     ## propagation-loss-model.h: static ns3::TypeId ns3::LogDistancePropagationLossModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1886,7 +1886,7 @@
 
 def register_Ns3ConstantRateWifiManager_methods(root_module, cls):
     ## constant-rate-wifi-manager.h: ns3::ConstantRateWifiManager::ConstantRateWifiManager(ns3::ConstantRateWifiManager const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::ConstantRateWifiManager&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::ConstantRateWifiManager const &', 'arg0')])
     ## constant-rate-wifi-manager.h: static ns3::TypeId ns3::ConstantRateWifiManager::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1913,7 +1913,7 @@
 
 def register_Ns3AarfWifiRemoteStation_methods(root_module, cls):
     ## aarf-wifi-manager.h: ns3::AarfWifiRemoteStation::AarfWifiRemoteStation(ns3::AarfWifiRemoteStation const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::AarfWifiRemoteStation&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::AarfWifiRemoteStation const &', 'arg0')])
     ## aarf-wifi-manager.h: ns3::AarfWifiRemoteStation::AarfWifiRemoteStation(ns3::Ptr<ns3::AarfWifiManager> stations, uint32_t minTimerThreshold, uint32_t minSuccessThreshold, double successK, uint32_t maxSuccessThreshold, double timerK) [constructor]
     cls.add_constructor([param('ns3::Ptr< ns3::AarfWifiManager >', 'stations'), param('uint32_t', 'minTimerThreshold'), param('uint32_t', 'minSuccessThreshold'), param('double', 'successK'), param('uint32_t', 'maxSuccessThreshold'), param('double', 'timerK')])
     ## aarf-wifi-manager.h: void ns3::AarfWifiRemoteStation::ReportRecoveryFailure() [member function]
@@ -1930,7 +1930,7 @@
 
 def register_Ns3PropagationDelayModel_methods(root_module, cls):
     ## propagation-delay-model.h: ns3::PropagationDelayModel::PropagationDelayModel(ns3::PropagationDelayModel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::PropagationDelayModel&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::PropagationDelayModel const &', 'arg0')])
     ## propagation-delay-model.h: ns3::PropagationDelayModel::PropagationDelayModel() [constructor]
     cls.add_constructor([])
     ## propagation-delay-model.h: static ns3::TypeId ns3::PropagationDelayModel::GetTypeId() [member function]
@@ -2047,7 +2047,7 @@
 
 def register_Ns3JakesPropagationLossModel_methods(root_module, cls):
     ## jakes-propagation-loss-model.h: ns3::JakesPropagationLossModel::JakesPropagationLossModel(ns3::JakesPropagationLossModel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::JakesPropagationLossModel&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::JakesPropagationLossModel const &', 'arg0')])
     ## jakes-propagation-loss-model.h: static ns3::TypeId ns3::JakesPropagationLossModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2070,9 +2070,35 @@
                    [param('uint8_t', 'nOscillators')])
     return
 
+def register_Ns3ConstantSpeedPropagationDelayModel_methods(root_module, cls):
+    ## propagation-delay-model.h: ns3::ConstantSpeedPropagationDelayModel::ConstantSpeedPropagationDelayModel(ns3::ConstantSpeedPropagationDelayModel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::ConstantSpeedPropagationDelayModel const &', 'arg0')])
+    ## propagation-delay-model.h: static ns3::TypeId ns3::ConstantSpeedPropagationDelayModel::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## propagation-delay-model.h: ns3::ConstantSpeedPropagationDelayModel::ConstantSpeedPropagationDelayModel() [constructor]
+    cls.add_constructor([])
+    ## propagation-delay-model.h: ns3::Time ns3::ConstantSpeedPropagationDelayModel::GetDelay(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+    cls.add_method('GetDelay', 
+                   'ns3::Time', 
+                   [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
+                   is_const=True, is_virtual=True)
+    ## propagation-delay-model.h: void ns3::ConstantSpeedPropagationDelayModel::SetSpeed(double speed) [member function]
+    cls.add_method('SetSpeed', 
+                   'void', 
+                   [param('double', 'speed')])
+    ## propagation-delay-model.h: double ns3::ConstantSpeedPropagationDelayModel::GetSpeed() const [member function]
+    cls.add_method('GetSpeed', 
+                   'double', 
+                   [], 
+                   is_const=True)
+    return
+
 def register_Ns3WifiNetDevice_methods(root_module, cls):
     ## wifi-net-device.h: ns3::WifiNetDevice::WifiNetDevice(ns3::WifiNetDevice const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::WifiNetDevice&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::WifiNetDevice const &', 'arg0')])
     ## wifi-net-device.h: static ns3::TypeId ns3::WifiNetDevice::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2114,7 +2140,7 @@
     ## wifi-net-device.h: void ns3::WifiNetDevice::SetName(std::string const name) [member function]
     cls.add_method('SetName', 
                    'void', 
-                   [param('std::string', 'name', is_const=True)], 
+                   [param('std::string const', 'name')], 
                    is_virtual=True)
     ## wifi-net-device.h: std::string ns3::WifiNetDevice::GetName() const [member function]
     cls.add_method('GetName', 
@@ -2124,7 +2150,7 @@
     ## wifi-net-device.h: void ns3::WifiNetDevice::SetIfIndex(uint32_t const index) [member function]
     cls.add_method('SetIfIndex', 
                    'void', 
-                   [param('uint32_t', 'index', is_const=True)], 
+                   [param('uint32_t const', 'index')], 
                    is_virtual=True)
     ## wifi-net-device.h: uint32_t ns3::WifiNetDevice::GetIfIndex() const [member function]
     cls.add_method('GetIfIndex', 
@@ -2144,7 +2170,7 @@
     ## wifi-net-device.h: bool ns3::WifiNetDevice::SetMtu(uint16_t const mtu) [member function]
     cls.add_method('SetMtu', 
                    'bool', 
-                   [param('uint16_t', 'mtu', is_const=True)], 
+                   [param('uint16_t const', 'mtu')], 
                    is_virtual=True)
     ## wifi-net-device.h: uint16_t ns3::WifiNetDevice::GetMtu() const [member function]
     cls.add_method('GetMtu', 
@@ -2194,7 +2220,7 @@
     ## wifi-net-device.h: bool ns3::WifiNetDevice::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')], 
+                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], 
                    is_virtual=True)
     ## wifi-net-device.h: ns3::Ptr<ns3::Node> ns3::WifiNetDevice::GetNode() const [member function]
     cls.add_method('GetNode', 
@@ -2219,7 +2245,7 @@
     ## wifi-net-device.h: bool ns3::WifiNetDevice::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')], 
+                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'source'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], 
                    is_virtual=True)
     ## wifi-net-device.h: void ns3::WifiNetDevice::SetPromiscReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType> cb) [member function]
     cls.add_method('SetPromiscReceiveCallback', 
@@ -2238,35 +2264,9 @@
                    visibility='private', is_virtual=True)
     return
 
-def register_Ns3ConstantSpeedPropagationDelayModel_methods(root_module, cls):
-    ## propagation-delay-model.h: ns3::ConstantSpeedPropagationDelayModel::ConstantSpeedPropagationDelayModel(ns3::ConstantSpeedPropagationDelayModel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::ConstantSpeedPropagationDelayModel&', 'arg0', is_const=True)])
-    ## propagation-delay-model.h: static ns3::TypeId ns3::ConstantSpeedPropagationDelayModel::GetTypeId() [member function]
-    cls.add_method('GetTypeId', 
-                   'ns3::TypeId', 
-                   [], 
-                   is_static=True)
-    ## propagation-delay-model.h: ns3::ConstantSpeedPropagationDelayModel::ConstantSpeedPropagationDelayModel() [constructor]
-    cls.add_constructor([])
-    ## propagation-delay-model.h: ns3::Time ns3::ConstantSpeedPropagationDelayModel::GetDelay(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
-    cls.add_method('GetDelay', 
-                   'ns3::Time', 
-                   [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
-                   is_const=True, is_virtual=True)
-    ## propagation-delay-model.h: void ns3::ConstantSpeedPropagationDelayModel::SetSpeed(double speed) [member function]
-    cls.add_method('SetSpeed', 
-                   'void', 
-                   [param('double', 'speed')])
-    ## propagation-delay-model.h: double ns3::ConstantSpeedPropagationDelayModel::GetSpeed() const [member function]
-    cls.add_method('GetSpeed', 
-                   'double', 
-                   [], 
-                   is_const=True)
-    return
-
 def register_Ns3RandomPropagationLossModel_methods(root_module, cls):
     ## propagation-loss-model.h: ns3::RandomPropagationLossModel::RandomPropagationLossModel(ns3::RandomPropagationLossModel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::RandomPropagationLossModel&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::RandomPropagationLossModel const &', 'arg0')])
     ## propagation-loss-model.h: static ns3::TypeId ns3::RandomPropagationLossModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2283,7 +2283,7 @@
 
 def register_Ns3RandomPropagationDelayModel_methods(root_module, cls):
     ## propagation-delay-model.h: ns3::RandomPropagationDelayModel::RandomPropagationDelayModel(ns3::RandomPropagationDelayModel const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::RandomPropagationDelayModel&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::RandomPropagationDelayModel const &', 'arg0')])
     ## propagation-delay-model.h: static ns3::TypeId ns3::RandomPropagationDelayModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2300,7 +2300,7 @@
 
 def register_Ns3AmrrWifiManager_methods(root_module, cls):
     ## amrr-wifi-manager.h: ns3::AmrrWifiManager::AmrrWifiManager(ns3::AmrrWifiManager const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::AmrrWifiManager&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::AmrrWifiManager const &', 'arg0')])
     ## amrr-wifi-manager.h: static ns3::TypeId ns3::AmrrWifiManager::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2317,7 +2317,7 @@
 
 def register_Ns3RraaWifiManager_methods(root_module, cls):
     ## rraa-wifi-manager.h: ns3::RraaWifiManager::RraaWifiManager(ns3::RraaWifiManager const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::RraaWifiManager&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::RraaWifiManager const &', 'arg0')])
     ## rraa-wifi-manager.h: static ns3::TypeId ns3::RraaWifiManager::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2348,7 +2348,7 @@
 
 def register_Ns3IdealWifiManager_methods(root_module, cls):
     ## ideal-wifi-manager.h: ns3::IdealWifiManager::IdealWifiManager(ns3::IdealWifiManager const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::IdealWifiManager&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::IdealWifiManager const &', 'arg0')])
     ## ideal-wifi-manager.h: static ns3::TypeId ns3::IdealWifiManager::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2379,7 +2379,7 @@
 
 def register_Ns3ArfWifiManager_methods(root_module, cls):
     ## arf-wifi-manager.h: ns3::ArfWifiManager::ArfWifiManager(ns3::ArfWifiManager const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::ArfWifiManager&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::ArfWifiManager const &', 'arg0')])
     ## arf-wifi-manager.h: static ns3::TypeId ns3::ArfWifiManager::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2396,7 +2396,7 @@
 
 def register_Ns3AarfWifiManager_methods(root_module, cls):
     ## aarf-wifi-manager.h: ns3::AarfWifiManager::AarfWifiManager(ns3::AarfWifiManager const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::AarfWifiManager&', 'arg0', is_const=True)])
+    cls.add_constructor([param('ns3::AarfWifiManager const &', 'arg0')])
     ## aarf-wifi-manager.h: static ns3::TypeId ns3::AarfWifiManager::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
--- a/bindings/python/ns3modulegen_core_customizations.py	Sun Aug 31 22:33:23 2008 +0100
+++ b/bindings/python/ns3modulegen_core_customizations.py	Tue Sep 02 11:12:42 2008 +0100
@@ -60,7 +60,6 @@
         ## fix the ctype, add ns3:: namespace
         orig_ctype, is_const = self._get_untransformed_type_traits(args[0])
         if is_const:
-            kwargs['is_const'] = True
             correct_ctype = 'ns3::Ptr< %s const >' % orig_ctype[:-2]
         else:
             correct_ctype = 'ns3::Ptr< %s >' % orig_ctype[:-2]
@@ -71,7 +70,7 @@
         return handler
 
     def untransform(self, type_handler, declarations, code_block, expression):
-        return 'ns3::PeekPointer (%s)' % (expression,)
+        return 'const_cast<%s> (ns3::PeekPointer (%s))' % (type_handler.untransformed_ctype, expression)
 
     def transform(self, type_handler, declarations, code_block, expression):
         assert type_handler.untransformed_ctype[-1] == '*'
--- a/bindings/python/ns3modulegen_generated.py	Sun Aug 31 22:33:23 2008 +0100
+++ b/bindings/python/ns3modulegen_generated.py	Tue Sep 02 11:12:42 2008 +0100
@@ -19,6 +19,7 @@
 import ns3_module_contrib
 import ns3_module_node
 import ns3_module_point_to_point
+import ns3_module_stats
 import ns3_module_internet_stack
 import ns3_module_wifi
 import ns3_module_csma
@@ -114,6 +115,17 @@
         ns3_module_point_to_point__local.register_types(module)
     
     root_module.end_section('ns3_module_point_to_point')
+    root_module.begin_section('ns3_module_stats')
+    ns3_module_stats.register_types(module)
+    
+    try:
+        import ns3_module_stats__local
+    except ImportError:
+        pass
+    else:
+        ns3_module_stats__local.register_types(module)
+    
+    root_module.end_section('ns3_module_stats')
     root_module.begin_section('ns3_module_internet_stack')
     ns3_module_internet_stack.register_types(module)
     
@@ -343,6 +355,17 @@
         ns3_module_point_to_point__local.register_methods(root_module)
     
     root_module.end_section('ns3_module_point_to_point')
+    root_module.begin_section('ns3_module_stats')
+    ns3_module_stats.register_methods(root_module)
+    
+    try:
+        import ns3_module_stats__local
+    except ImportError:
+        pass
+    else:
+        ns3_module_stats__local.register_methods(root_module)
+    
+    root_module.end_section('ns3_module_stats')
     root_module.begin_section('ns3_module_internet_stack')
     ns3_module_internet_stack.register_methods(root_module)
     
@@ -534,6 +557,17 @@
         ns3_module_point_to_point__local.register_functions(root_module)
     
     root_module.end_section('ns3_module_point_to_point')
+    root_module.begin_section('ns3_module_stats')
+    ns3_module_stats.register_functions(root_module)
+    
+    try:
+        import ns3_module_stats__local
+    except ImportError:
+        pass
+    else:
+        ns3_module_stats__local.register_functions(root_module)
+    
+    root_module.end_section('ns3_module_stats')
     root_module.begin_section('ns3_module_internet_stack')
     ns3_module_internet_stack.register_functions(root_module)
     
--- a/bindings/python/wscript	Sun Aug 31 22:33:23 2008 +0100
+++ b/bindings/python/wscript	Tue Sep 02 11:12:42 2008 +0100
@@ -21,7 +21,7 @@
     os.environ['PYTHONPATH'] = LOCAL_PYBINDGEN_PATH
 
 ## https://launchpad.net/pybindgen/
-REQUIRED_PYBINDGEN_VERSION = (0, 9, 0, 570)
+REQUIRED_PYBINDGEN_VERSION = (0, 9, 0, 572)
 REQUIRED_PYGCCXML_VERSION = (0, 9, 5)