diff -r 352cfe96e593 -r b6804efbe16b bindings/python/ns3_module_node.py
--- 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)