Require new PyBindGen (now ignores the badly scanned anonymous containers that cause problems on cygwin) and rescan API.
authorGustavo J. A. M. Carneiro <gjc@inescporto.pt>
Fri, 29 Aug 2008 14:56:24 +0100
changeset 3567 728eb3f583b3
parent 3566 b96af8dc8abf
child 3569 ff3a7dc79a7e
child 3570 44b0bc6817c6
child 3577 4631eaaf84c4
Require new PyBindGen (now ignores the badly scanned anonymous containers that cause problems on cygwin) and rescan API.
bindings/python/callbacks_list.py
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_udp_echo.py
bindings/python/ns3_module_wifi.py
bindings/python/ns3modulegen_generated.py
bindings/python/wscript
--- a/bindings/python/callbacks_list.py	Fri Aug 29 14:53:38 2008 +0100
+++ b/bindings/python/callbacks_list.py	Fri Aug 29 14:56:24 2008 +0100
@@ -5,9 +5,9 @@
     ['void', 'ns3::Ptr<ns3::Socket>', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['bool', 'ns3::Ptr<ns3::Socket>', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['void', 'ns3::Ptr<ns3::Packet>', 'ns3::Mac48Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
-    ['bool', 'ns3::Ptr<ns3::NetDevice>', 'ns3::Ptr<ns3::Packet>', 'unsigned short', 'ns3::Address const&', 'ns3::Address const&', 'ns3::NetDevice::PacketType'],
-    ['bool', 'ns3::Ptr<ns3::NetDevice>', 'ns3::Ptr<ns3::Packet>', 'unsigned short', 'ns3::Address const&', 'ns3::empty', 'ns3::empty'],
-    ['void', 'ns3::Ptr<ns3::NetDevice>', 'ns3::Ptr<ns3::Packet>', 'unsigned short', 'ns3::Address const&', 'ns3::Address const&', 'ns3::NetDevice::PacketType'],
+    ['bool', 'ns3::Ptr<ns3::NetDevice>', 'ns3::Ptr<ns3::Packet const>', 'unsigned short', 'ns3::Address const&', 'ns3::Address const&', 'ns3::NetDevice::PacketType'],
+    ['bool', 'ns3::Ptr<ns3::NetDevice>', 'ns3::Ptr<ns3::Packet const>', 'unsigned short', 'ns3::Address const&', 'ns3::empty', 'ns3::empty'],
+    ['void', 'ns3::Ptr<ns3::NetDevice>', 'ns3::Ptr<ns3::Packet const>', 'unsigned short', 'ns3::Address const&', 'ns3::Address const&', 'ns3::NetDevice::PacketType'],
     ['void', 'ns3::Ptr<ns3::Packet>', 'double', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
     ['void', 'ns3::Ptr<ns3::Packet>', 'double', 'ns3::WifiMode', 'ns3::WifiPreamble', 'ns3::empty', 'ns3::empty'],
 ]
--- a/bindings/python/ns3_module_bridge.py	Fri Aug 29 14:53:38 2008 +0100
+++ b/bindings/python/ns3_module_bridge.py	Fri Aug 29 14:56:24 2008 +0100
@@ -54,6 +54,8 @@
     return
 
 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)])
     ## bridge-net-device.h: static ns3::TypeId ns3::BridgeNetDevice::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -170,15 +172,15 @@
                    'bool', 
                    [], 
                    is_const=True, is_virtual=True)
-    ## bridge-net-device.h: void ns3::BridgeNetDevice::SetReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> cb) [member function]
+    ## bridge-net-device.h: void ns3::BridgeNetDevice::SetReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> cb) [member function]
     cls.add_method('SetReceiveCallback', 
                    'void', 
-                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr<const ns3::Packet >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], 
+                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], 
                    is_virtual=True)
-    ## bridge-net-device.h: void ns3::BridgeNetDevice::SetPromiscReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType> cb) [member function]
+    ## bridge-net-device.h: void ns3::BridgeNetDevice::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', 
                    'void', 
-                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr<const ns3::Packet >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'cb')], 
+                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'cb')], 
                    is_virtual=True)
     ## bridge-net-device.h: bool ns3::BridgeNetDevice::SupportsPromiscuous() const [member function]
     cls.add_method('SupportsPromiscuous', 
@@ -190,20 +192,20 @@
                    'void', 
                    [], 
                    visibility='protected', is_virtual=True)
-    ## bridge-net-device.h: void ns3::BridgeNetDevice::ReceiveFromDevice(ns3::Ptr<ns3::NetDevice> device, ns3::Ptr<ns3::Packet> packet, uint16_t protocol, ns3::Address const & source, ns3::Address const & destination, ns3::NetDevice::PacketType packetType) [member function]
+    ## 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< 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&', 'source', is_const=True), param('ns3::Address&', 'destination', is_const=True), param('ns3::NetDevice::PacketType', 'packetType')], 
                    visibility='protected')
-    ## bridge-net-device.h: void ns3::BridgeNetDevice::ForwardUnicast(ns3::Ptr<ns3::NetDevice> incomingPort, ns3::Ptr<ns3::Packet> packet, uint16_t protocol, ns3::Mac48Address src, ns3::Mac48Address dst) [member function]
+    ## 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', 
                    'void', 
-                   [param('ns3::Ptr< ns3::NetDevice >', 'incomingPort'), param('ns3::Ptr< ns3::Packet >', 'packet'), param('uint16_t', 'protocol'), param('ns3::Mac48Address', 'src'), param('ns3::Mac48Address', 'dst')], 
+                   [param('ns3::Ptr< ns3::NetDevice >', 'incomingPort'), param('ns3::Ptr< const ns3::Packet >', 'packet'), param('uint16_t', 'protocol'), param('ns3::Mac48Address', 'src'), param('ns3::Mac48Address', 'dst')], 
                    visibility='protected')
-    ## bridge-net-device.h: void ns3::BridgeNetDevice::ForwardBroadcast(ns3::Ptr<ns3::NetDevice> incomingPort, ns3::Ptr<ns3::Packet> packet, uint16_t protocol, ns3::Mac48Address src, ns3::Mac48Address dst) [member function]
+    ## bridge-net-device.h: void ns3::BridgeNetDevice::ForwardBroadcast(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('ForwardBroadcast', 
                    'void', 
-                   [param('ns3::Ptr< ns3::NetDevice >', 'incomingPort'), param('ns3::Ptr< ns3::Packet >', 'packet'), param('uint16_t', 'protocol'), param('ns3::Mac48Address', 'src'), param('ns3::Mac48Address', 'dst')], 
+                   [param('ns3::Ptr< ns3::NetDevice >', 'incomingPort'), param('ns3::Ptr< const ns3::Packet >', 'packet'), param('uint16_t', 'protocol'), param('ns3::Mac48Address', 'src'), param('ns3::Mac48Address', 'dst')], 
                    visibility='protected')
     ## bridge-net-device.h: void ns3::BridgeNetDevice::Learn(ns3::Mac48Address source, ns3::Ptr<ns3::NetDevice> port) [member function]
     cls.add_method('Learn', 
@@ -215,10 +217,11 @@
                    'ns3::Ptr< ns3::NetDevice >', 
                    [param('ns3::Mac48Address', 'source')], 
                    visibility='protected')
-    cls.add_copy_constructor()
     return
 
 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)])
     ## bridge-channel.h: static ns3::TypeId ns3::BridgeChannel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -240,7 +243,6 @@
                    'ns3::Ptr< ns3::NetDevice >', 
                    [param('uint32_t', 'i')], 
                    is_const=True, is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_functions(root_module):
--- a/bindings/python/ns3_module_common.py	Fri Aug 29 14:53:38 2008 +0100
+++ b/bindings/python/ns3_module_common.py	Fri Aug 29 14:56:24 2008 +0100
@@ -158,10 +158,20 @@
     cls.add_method('Deserialize', 
                    'void', 
                    [param('ns3::Buffer', 'buffer')])
+    ## packet.h: static void ns3::Packet::EnableChecking() [member function]
+    cls.add_method('EnableChecking', 
+                   'void', 
+                   [], 
+                   is_static=True)
     ## packet.h: static void ns3::Packet::EnableMetadata() [member function]
     cls.add_method('EnableMetadata', 
                    'void', 
                    [], 
+                   is_static=True, deprecated=True)
+    ## packet.h: static void ns3::Packet::EnablePrinting() [member function]
+    cls.add_method('EnablePrinting', 
+                   'void', 
+                   [], 
                    is_static=True)
     ## packet.h: bool ns3::Packet::FindFirstMatchingTag(ns3::Tag & tag) const [member function]
     cls.add_method('FindFirstMatchingTag', 
@@ -235,6 +245,8 @@
     return
 
 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)])
     ## packet.h: bool ns3::TagIterator::HasNext() const [member function]
     cls.add_method('HasNext', 
                    'bool', 
@@ -247,6 +259,8 @@
     return
 
 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)])
     ## packet.h: ns3::TypeId ns3::TagIterator::Item::GetTypeId() const [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -267,7 +281,6 @@
                    'void', 
                    [param('ns3::Tag&', 'tag')], 
                    is_const=True)
-    cls.add_copy_constructor()
     return
 
 def register_Ns3TagList_methods(root_module, cls):
@@ -303,6 +316,8 @@
     return
 
 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)])
     ## tag-list.h: bool ns3::TagList::Iterator::HasNext() const [member function]
     cls.add_method('HasNext', 
                    'bool', 
@@ -317,7 +332,6 @@
                    'uint32_t', 
                    [], 
                    is_const=True)
-    cls.add_copy_constructor()
     return
 
 def register_Ns3TagListIteratorItem_methods(root_module, cls):
@@ -331,12 +345,15 @@
     cls.add_instance_attribute('end', 'int32_t', is_const=False)
     ## 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)])
     ## tag-list.h: ns3::TagList::Iterator::Item::Item(ns3::TagBuffer buf) [constructor]
     cls.add_constructor([param('ns3::TagBuffer', 'buf')])
-    cls.add_copy_constructor()
     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)])
     ## 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]
@@ -395,7 +412,6 @@
     cls.add_method('Read', 
                    'void', 
                    [param('uint8_t *', 'buffer'), param('uint32_t', 'size')])
-    cls.add_copy_constructor()
     return
 
 def register_Ns3Buffer_methods(root_module, cls):
@@ -468,6 +484,8 @@
     return
 
 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)])
     ## buffer.h: ns3::Buffer::Iterator::Iterator() [constructor]
     cls.add_constructor([])
     ## buffer.h: void ns3::Buffer::Iterator::Next() [member function]
@@ -610,14 +628,13 @@
                    'uint32_t', 
                    [], 
                    is_const=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## chunk.h: ns3::Chunk::Chunk() [constructor]
     cls.add_constructor([])
-    ## chunk.h: ns3::Chunk::Chunk(ns3::Chunk const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Chunk&', 'arg0', is_const=True)])
     ## chunk.h: static ns3::TypeId ns3::Chunk::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -658,6 +675,10 @@
     return
 
 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)])
+    ## tag.h: ns3::Tag::Tag() [constructor]
+    cls.add_constructor([])
     ## tag.h: static ns3::TypeId ns3::Tag::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -683,11 +704,11 @@
                    'void', 
                    [param('std::ostream&', 'os')], 
                    is_pure_virtual=True, is_const=True, is_virtual=True)
-    cls.add_constructor([])
-    cls.add_copy_constructor()
     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)])
     ## pcap-writer.h: ns3::PcapWriter::PcapWriter() [constructor]
     cls.add_constructor([])
     ## pcap-writer.h: void ns3::PcapWriter::Open(std::string const & name) [member function]
@@ -714,15 +735,18 @@
     cls.add_method('WritePacket', 
                    'void', 
                    [param('ns3::Ptr< const ns3::Packet >', 'packet')])
-    cls.add_copy_constructor()
     return
 
 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)])
+    ## data-rate.h: ns3::DataRateChecker::DataRateChecker() [constructor]
     cls.add_constructor([])
-    cls.add_copy_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)])
     ## error-model.h: static ns3::TypeId ns3::ErrorModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -761,7 +785,6 @@
                    'void', 
                    [], 
                    is_pure_virtual=True, visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_Ns3Header_methods(root_module, cls):
@@ -831,6 +854,8 @@
     return
 
 def register_Ns3ListErrorModel_methods(root_module, cls):
+    ## error-model.h: ns3::ListErrorModel::ListErrorModel(ns3::ListErrorModel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::ListErrorModel&', 'arg0', is_const=True)])
     ## error-model.h: static ns3::TypeId ns3::ListErrorModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -840,13 +865,13 @@
     cls.add_constructor([])
     ## error-model.h: std::list<unsigned int, std::allocator<unsigned int> > ns3::ListErrorModel::GetList() const [member function]
     cls.add_method('GetList', 
-                   'std::list< unsigned int, std::allocator< unsigned int > >', 
+                   'std::list< unsigned int >', 
                    [], 
                    is_const=True)
     ## error-model.h: void ns3::ListErrorModel::SetList(std::list<unsigned int, std::allocator<unsigned int> > const & packetlist) [member function]
     cls.add_method('SetList', 
                    'void', 
-                   [param('std::list< unsigned int, std::allocator< unsigned int > >&', 'packetlist', is_const=True)])
+                   [param('std::list< unsigned int >&', 'packetlist', is_const=True)])
     ## error-model.h: bool ns3::ListErrorModel::DoCorrupt(ns3::Ptr<ns3::Packet> p) [member function]
     cls.add_method('DoCorrupt', 
                    'bool', 
@@ -857,10 +882,11 @@
                    'void', 
                    [], 
                    visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## data-rate.h: ns3::DataRateValue::DataRateValue() [constructor]
     cls.add_constructor([])
     ## data-rate.h: ns3::DataRateValue::DataRateValue(ns3::DataRate const & value) [constructor]
@@ -889,10 +915,11 @@
                    'bool', 
                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_Ns3RateErrorModel_methods(root_module, cls):
+    ## error-model.h: ns3::RateErrorModel::RateErrorModel(ns3::RateErrorModel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::RateErrorModel&', 'arg0', is_const=True)])
     ## error-model.h: static ns3::TypeId ns3::RateErrorModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -947,7 +974,6 @@
                    'void', 
                    [], 
                    visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_functions(root_module):
--- a/bindings/python/ns3_module_contrib.py	Fri Aug 29 14:53:38 2008 +0100
+++ b/bindings/python/ns3_module_contrib.py	Fri Aug 29 14:56:24 2008 +0100
@@ -70,6 +70,8 @@
     return
 
 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)])
     ## 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]
@@ -84,20 +86,22 @@
     cls.add_method('GenerateOutput', 
                    'void', 
                    [param('std::ostream&', 'os')])
-    cls.add_copy_constructor()
     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)])
     ## event-garbage-collector.h: ns3::EventGarbageCollector::EventGarbageCollector() [constructor]
     cls.add_constructor([])
     ## event-garbage-collector.h: void ns3::EventGarbageCollector::Track(ns3::EventId event) [member function]
     cls.add_method('Track', 
                    'void', 
                    [param('ns3::EventId', 'event')])
-    cls.add_copy_constructor()
     return
 
 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)])
     ## gnuplot.h: ns3::GnuplotDataset::GnuplotDataset() [constructor]
     cls.add_constructor([])
     ## gnuplot.h: ns3::GnuplotDataset::GnuplotDataset(std::string title) [constructor]
@@ -118,20 +122,22 @@
     cls.add_method('Add', 
                    'void', 
                    [param('double', 'x'), param('double', 'y'), param('double', 'errorDelta')])
-    cls.add_copy_constructor()
     return
 
 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)])
     ## gtk-config-store.h: ns3::GtkConfigStore::GtkConfigStore() [constructor]
     cls.add_constructor([])
     ## gtk-config-store.h: void ns3::GtkConfigStore::Configure() [member function]
     cls.add_method('Configure', 
                    'void', 
                    [])
-    cls.add_copy_constructor()
     return
 
 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)])
     ## config-store.h: static ns3::TypeId ns3::ConfigStore::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -148,10 +154,11 @@
     cls.add_method('Configure', 
                    'void', 
                    [])
-    cls.add_copy_constructor()
     return
 
 def register_Ns3DelayJitterEstimation_methods(root_module, cls):
+    ## delay-jitter-estimation.h: ns3::DelayJitterEstimation::DelayJitterEstimation(ns3::DelayJitterEstimation const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::DelayJitterEstimation&', 'arg0', is_const=True)])
     ## 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]
@@ -173,7 +180,6 @@
                    'ns3::Time', 
                    [], 
                    is_const=True)
-    cls.add_copy_constructor()
     return
 
 def register_functions(root_module):
--- a/bindings/python/ns3_module_core.py	Fri Aug 29 14:53:38 2008 +0100
+++ b/bindings/python/ns3_module_core.py	Fri Aug 29 14:56:24 2008 +0100
@@ -43,8 +43,6 @@
     module.add_class('ParetoVariable', parent=root_module['ns3::RandomVariable'])
     ## random-variable.h: ns3::ConstantVariable [class]
     module.add_class('ConstantVariable', parent=root_module['ns3::RandomVariable'])
-    ## system-thread.h: ns3::SystemThread [class]
-    module.add_class('SystemThread')
     ## random-variable.h: ns3::EmpiricalVariable [class]
     module.add_class('EmpiricalVariable', parent=root_module['ns3::RandomVariable'])
     ## enum.h: ns3::EnumChecker [class]
@@ -99,6 +97,8 @@
     module.add_class('ExponentialVariable', parent=root_module['ns3::RandomVariable'])
     ## random-variable.h: ns3::DeterministicVariable [class]
     module.add_class('DeterministicVariable', parent=root_module['ns3::RandomVariable'])
+    ## system-thread.h: ns3::SystemThread [class]
+    module.add_class('SystemThread')
     ## attribute-list.h: ns3::AttributeList [class]
     module.add_class('AttributeList')
     ## attribute.h: ns3::AttributeValue [class]
@@ -219,7 +219,6 @@
     register_Ns3AttributeAccessor_methods(root_module, root_module['ns3::AttributeAccessor'])
     register_Ns3ParetoVariable_methods(root_module, root_module['ns3::ParetoVariable'])
     register_Ns3ConstantVariable_methods(root_module, root_module['ns3::ConstantVariable'])
-    register_Ns3SystemThread_methods(root_module, root_module['ns3::SystemThread'])
     register_Ns3EmpiricalVariable_methods(root_module, root_module['ns3::EmpiricalVariable'])
     register_Ns3EnumChecker_methods(root_module, root_module['ns3::EnumChecker'])
     register_Ns3Empty_methods(root_module, root_module['ns3::empty'])
@@ -240,6 +239,7 @@
     register_Ns3CallbackBase_methods(root_module, root_module['ns3::CallbackBase'])
     register_Ns3ExponentialVariable_methods(root_module, root_module['ns3::ExponentialVariable'])
     register_Ns3DeterministicVariable_methods(root_module, root_module['ns3::DeterministicVariable'])
+    register_Ns3SystemThread_methods(root_module, root_module['ns3::SystemThread'])
     register_Ns3AttributeList_methods(root_module, root_module['ns3::AttributeList'])
     register_Ns3AttributeValue_methods(root_module, root_module['ns3::AttributeValue'])
     register_Ns3UniformVariable_methods(root_module, root_module['ns3::UniformVariable'])
@@ -307,6 +307,8 @@
     return
 
 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)])
     ## random-variable.h: ns3::TriangularVariable::TriangularVariable() [constructor]
     cls.add_constructor([])
     ## random-variable.h: ns3::TriangularVariable::TriangularVariable(double s, double l, double mean) [constructor]
@@ -316,10 +318,11 @@
                    'double', 
                    [param('double', 's'), param('double', 'l'), param('double', 'mean')], 
                    is_static=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## 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')])
     ## global-value.h: std::string ns3::GlobalValue::GetName() const [member function]
@@ -358,15 +361,14 @@
                    is_static=True)
     ## global-value.h: static __gnu_cxx::__normal_iterator<ns3::GlobalValue* const*,std::vector<ns3::GlobalValue*, std::allocator<ns3::GlobalValue*> > > ns3::GlobalValue::Begin() [member function]
     cls.add_method('Begin', 
-                   '__gnu_cxx::__normal_iterator< ns3::GlobalValue* const*, std::vector< ns3::GlobalValue*, std::allocator< ns3::GlobalValue* > > >', 
+                   '__gnu_cxx::__normal_iterator< ns3::GlobalValue* const*, std::vector< ns3::GlobalValue* > >', 
                    [], 
                    is_static=True)
     ## global-value.h: static __gnu_cxx::__normal_iterator<ns3::GlobalValue* const*,std::vector<ns3::GlobalValue*, std::allocator<ns3::GlobalValue*> > > ns3::GlobalValue::End() [member function]
     cls.add_method('End', 
-                   '__gnu_cxx::__normal_iterator< ns3::GlobalValue* const*, std::vector< ns3::GlobalValue*, std::allocator< ns3::GlobalValue* > > >', 
+                   '__gnu_cxx::__normal_iterator< ns3::GlobalValue* const*, std::vector< ns3::GlobalValue* > >', 
                    [], 
                    is_static=True)
-    cls.add_copy_constructor()
     return
 
 def register_Ns3RefCountBase_methods(root_module, cls):
@@ -558,11 +560,15 @@
     cls.add_instance_attribute('flags', 'uint32_t', is_const=False)
     ## 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)])
+    ## type-id.h: ns3::TypeId::AttributeInfo::AttributeInfo() [constructor]
     cls.add_constructor([])
-    cls.add_copy_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)])
     ## system-wall-clock-ms.h: ns3::SystemWallClockMs::SystemWallClockMs() [constructor]
     cls.add_constructor([])
     ## system-wall-clock-ms.h: void ns3::SystemWallClockMs::Start() [member function]
@@ -573,10 +579,11 @@
     cls.add_method('End', 
                    'long long unsigned int', 
                    [])
-    cls.add_copy_constructor()
     return
 
 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)])
     ## callback.h: ns3::CallbackImplBase::CallbackImplBase() [constructor]
     cls.add_constructor([])
     ## callback.h: bool ns3::CallbackImplBase::IsEqual(ns3::Ptr<ns3::CallbackImplBase const> other) const [member function]
@@ -584,16 +591,18 @@
                    'bool', 
                    [param('ns3::Ptr< ns3::CallbackImplBase const >', 'other')], 
                    is_pure_virtual=True, is_const=True, is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## system-mutex.h: ns3::CriticalSection::CriticalSection(ns3::SystemMutex & mutex) [constructor]
     cls.add_constructor([param('ns3::SystemMutex&', 'mutex')])
-    cls.add_copy_constructor()
     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)])
     ## trace-source-accessor.h: ns3::TraceSourceAccessor::TraceSourceAccessor() [constructor]
     cls.add_constructor([])
     ## trace-source-accessor.h: void ns3::TraceSourceAccessor::Ref() const [member function]
@@ -626,10 +635,11 @@
                    'bool', 
                    [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase&', 'cb', is_const=True)], 
                    is_pure_virtual=True, is_const=True, is_virtual=True)
-    cls.add_copy_constructor()
     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)])
     ## attribute.h: ns3::AttributeChecker::AttributeChecker() [constructor]
     cls.add_constructor([])
     ## attribute.h: bool ns3::AttributeChecker::Check(ns3::AttributeValue const & value) const [member function]
@@ -662,15 +672,18 @@
                    'bool', 
                    [param('ns3::AttributeValue&', 'source', is_const=True), param('ns3::AttributeValue&', 'destination')], 
                    is_pure_virtual=True, is_const=True, is_virtual=True)
-    cls.add_copy_constructor()
     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)])
+    ## random-variable.h: ns3::RandomVariableChecker::RandomVariableChecker() [constructor]
     cls.add_constructor([])
-    cls.add_copy_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)])
     ## system-mutex.h: ns3::SystemMutex::SystemMutex() [constructor]
     cls.add_constructor([])
     ## system-mutex.h: void ns3::SystemMutex::Lock() [member function]
@@ -681,10 +694,11 @@
     cls.add_method('Unlock', 
                    'void', 
                    [])
-    cls.add_copy_constructor()
     return
 
 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)])
     ## random-variable.h: ns3::NormalVariable::NormalVariable() [constructor]
     cls.add_constructor([])
     ## random-variable.h: ns3::NormalVariable::NormalVariable(double m, double v) [constructor]
@@ -701,7 +715,6 @@
                    'double', 
                    [param('double', 'm'), param('double', 'v'), param('double', 'b')], 
                    is_static=True)
-    cls.add_copy_constructor()
     return
 
 def register_Ns3ObjectFactory_methods(root_module, cls):
@@ -739,6 +752,8 @@
     return
 
 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)])
     ## 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]
@@ -761,10 +776,11 @@
                    'bool', 
                    [], 
                    is_pure_virtual=True, is_const=True, is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## random-variable.h: ns3::ParetoVariable::ParetoVariable() [constructor]
     cls.add_constructor([])
     ## random-variable.h: ns3::ParetoVariable::ParetoVariable(double m) [constructor]
@@ -778,10 +794,11 @@
                    'double', 
                    [param('double', 'm'), param('double', 's'), param('double', 'b', default_value='0')], 
                    is_static=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## random-variable.h: ns3::ConstantVariable::ConstantVariable() [constructor]
     cls.add_constructor([])
     ## random-variable.h: ns3::ConstantVariable::ConstantVariable(double c) [constructor]
@@ -790,44 +807,22 @@
     cls.add_method('SetConstant', 
                    'void', 
                    [param('double', 'c')])
-    cls.add_copy_constructor()
-    return
-
-def register_Ns3SystemThread_methods(root_module, cls):
-    ## system-thread.h: ns3::SystemThread::SystemThread(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [constructor]
-    cls.add_constructor([param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')])
-    ## system-thread.h: void ns3::SystemThread::Ref() const [member function]
-    cls.add_method('Ref', 
-                   'void', 
-                   [], 
-                   is_const=True)
-    ## system-thread.h: void ns3::SystemThread::Unref() const [member function]
-    cls.add_method('Unref', 
-                   'void', 
-                   [], 
-                   is_const=True)
-    ## system-thread.h: void ns3::SystemThread::Start() [member function]
-    cls.add_method('Start', 
-                   'void', 
-                   [])
-    ## system-thread.h: void ns3::SystemThread::Join() [member function]
-    cls.add_method('Join', 
-                   'void', 
-                   [])
-    cls.add_copy_constructor()
     return
 
 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)])
     ## random-variable.h: ns3::EmpiricalVariable::EmpiricalVariable() [constructor]
     cls.add_constructor([])
     ## random-variable.h: void ns3::EmpiricalVariable::CDF(double v, double c) [member function]
     cls.add_method('CDF', 
                    'void', 
                    [param('double', 'v'), param('double', 'c')])
-    cls.add_copy_constructor()
     return
 
 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)])
     ## enum.h: ns3::EnumChecker::EnumChecker() [constructor]
     cls.add_constructor([])
     ## enum.h: void ns3::EnumChecker::AddDefault(int v, std::string name) [member function]
@@ -868,19 +863,20 @@
                    'bool', 
                    [param('ns3::AttributeValue&', 'src', is_const=True), param('ns3::AttributeValue&', 'dst')], 
                    is_const=True, is_virtual=True)
-    cls.add_copy_constructor()
     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)])
+    ## empty.h: ns3::empty::empty() [constructor]
     cls.add_constructor([])
-    cls.add_copy_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)])
     ## object-base.h: ns3::ObjectBase::ObjectBase() [constructor]
     cls.add_constructor([])
-    ## object-base.h: ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::ObjectBase&', 'arg0', is_const=True)])
     ## object-base.h: static ns3::TypeId ns3::ObjectBase::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -938,43 +934,59 @@
     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)])
+    ## command-line.h: ns3::CommandLine::CommandLine() [constructor]
     cls.add_constructor([])
-    cls.add_copy_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)])
+    ## 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)])
+    ## 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)])
+    ## 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)])
+    ## 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)])
+    ## 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)])
+    ## 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)])
+    ## int-to-type.h: ns3::IntToType<0>::IntToType() [constructor]
     cls.add_constructor([])
-    cls.add_copy_constructor()
     return
 
 def register_Ns3RngStream_methods(root_module, cls):
@@ -1044,6 +1056,8 @@
     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)])
     ## 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]
@@ -1051,26 +1065,30 @@
                    'double', 
                    [param('double', 'mu'), param('double', 'sigma')], 
                    is_static=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## random-variable.h: ns3::IntEmpiricalVariable::IntEmpiricalVariable() [constructor]
     cls.add_constructor([])
-    cls.add_copy_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)])
+    ## pointer.h: ns3::PointerChecker::PointerChecker() [constructor]
+    cls.add_constructor([])
     ## pointer.h: ns3::TypeId ns3::PointerChecker::GetPointeeTypeId() const [member function]
     cls.add_method('GetPointeeTypeId', 
                    'ns3::TypeId', 
                    [], 
                    is_pure_virtual=True, is_const=True, is_virtual=True)
-    cls.add_constructor([])
-    cls.add_copy_constructor()
     return
 
 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)])
     ## random-variable.h: ns3::WeibullVariable::WeibullVariable() [constructor]
     cls.add_constructor([])
     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(double m) [constructor]
@@ -1084,10 +1102,11 @@
                    'double', 
                    [param('double', 'm'), param('double', 's'), param('double', 'b', default_value='0')], 
                    is_static=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## callback.h: ns3::CallbackBase::CallbackBase() [constructor]
     cls.add_constructor([])
     ## callback.h: ns3::Ptr<ns3::CallbackImplBase> ns3::CallbackBase::GetImpl() const [member function]
@@ -1098,10 +1117,11 @@
     ## callback.h: ns3::CallbackBase::CallbackBase(ns3::Ptr<ns3::CallbackImplBase> impl) [constructor]
     cls.add_constructor([param('ns3::Ptr< ns3::CallbackImplBase >', 'impl')], 
                         visibility='protected')
-    cls.add_copy_constructor()
     return
 
 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)])
     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable() [constructor]
     cls.add_constructor([])
     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable(double m) [constructor]
@@ -1113,13 +1133,38 @@
                    'double', 
                    [param('double', 'm'), param('double', 'b', default_value='0')], 
                    is_static=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## random-variable.h: ns3::DeterministicVariable::DeterministicVariable(double * d, uint32_t c) [constructor]
     cls.add_constructor([param('double *', 'd'), param('uint32_t', 'c')])
-    cls.add_copy_constructor()
+    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)])
+    ## system-thread.h: ns3::SystemThread::SystemThread(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [constructor]
+    cls.add_constructor([param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')])
+    ## system-thread.h: void ns3::SystemThread::Ref() const [member function]
+    cls.add_method('Ref', 
+                   'void', 
+                   [], 
+                   is_const=True)
+    ## system-thread.h: void ns3::SystemThread::Unref() const [member function]
+    cls.add_method('Unref', 
+                   'void', 
+                   [], 
+                   is_const=True)
+    ## system-thread.h: void ns3::SystemThread::Start() [member function]
+    cls.add_method('Start', 
+                   'void', 
+                   [])
+    ## system-thread.h: void ns3::SystemThread::Join() [member function]
+    cls.add_method('Join', 
+                   'void', 
+                   [])
     return
 
 def register_Ns3AttributeList_methods(root_module, cls):
@@ -1182,6 +1227,8 @@
     return
 
 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)])
     ## random-variable.h: ns3::UniformVariable::UniformVariable() [constructor]
     cls.add_constructor([])
     ## random-variable.h: ns3::UniformVariable::UniformVariable(double s, double l) [constructor]
@@ -1191,7 +1238,6 @@
                    'double', 
                    [param('double', 's'), param('double', 'l')], 
                    is_static=True)
-    cls.add_copy_constructor()
     return
 
 def register_Ns3Object_methods(root_module, cls):
@@ -1236,6 +1282,8 @@
     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)])
     ## object.h: ns3::Object::AggregateIterator::AggregateIterator() [constructor]
     cls.add_constructor([])
     ## object.h: bool ns3::Object::AggregateIterator::HasNext() const [member function]
@@ -1247,10 +1295,11 @@
     cls.add_method('Next', 
                    'ns3::Ptr< ns3::Object const >', 
                    [])
-    cls.add_copy_constructor()
     return
 
 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)])
     ## system-condition.h: ns3::SystemCondition::SystemCondition() [constructor]
     cls.add_constructor([])
     ## system-condition.h: void ns3::SystemCondition::SetCondition(bool condition) [member function]
@@ -1277,43 +1326,49 @@
     cls.add_method('TimedWait', 
                    'bool', 
                    [param('uint64_t', 'ns')])
-    cls.add_copy_constructor()
     return
 
 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)])
     ## 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_copy_constructor()
     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)])
+    ## object-vector.h: ns3::ObjectVectorChecker::ObjectVectorChecker() [constructor]
+    cls.add_constructor([])
     ## object-vector.h: ns3::TypeId ns3::ObjectVectorChecker::GetItemTypeId() const [member function]
     cls.add_method('GetItemTypeId', 
                    'ns3::TypeId', 
                    [], 
                    is_pure_virtual=True, is_const=True, is_virtual=True)
-    cls.add_constructor([])
-    cls.add_copy_constructor()
     return
 
 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)])
+    ## string.h: ns3::StringChecker::StringChecker() [constructor]
     cls.add_constructor([])
-    cls.add_copy_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)])
     ## 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]
     cls.add_method('Begin', 
-                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Object >, std::vector< ns3::Ptr< ns3::Object >, std::allocator< ns3::Ptr< ns3::Object > > > >', 
+                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Object >, std::vector< ns3::Ptr< ns3::Object > > >', 
                    [], 
                    is_const=True)
     ## object-vector.h: __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Object>*,std::vector<ns3::Ptr<ns3::Object>, std::allocator<ns3::Ptr<ns3::Object> > > > ns3::ObjectVectorValue::End() const [member function]
     cls.add_method('End', 
-                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Object >, std::vector< ns3::Ptr< ns3::Object >, std::allocator< ns3::Ptr< ns3::Object > > > >', 
+                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Object >, std::vector< ns3::Ptr< ns3::Object > > >', 
                    [], 
                    is_const=True)
     ## object-vector.h: uint32_t ns3::ObjectVectorValue::GetN() const [member function]
@@ -1341,15 +1396,18 @@
                    'bool', 
                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
+    ## boolean.h: ns3::BooleanChecker::BooleanChecker() [constructor]
     cls.add_constructor([])
-    cls.add_copy_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)])
     ## uinteger.h: ns3::UintegerValue::UintegerValue() [constructor]
     cls.add_constructor([])
     ## uinteger.h: ns3::UintegerValue::UintegerValue(uint64_t const & value) [constructor]
@@ -1378,10 +1436,13 @@
                    'bool', 
                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
+    ## 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', 
@@ -1412,8 +1473,6 @@
                    'ns3::Ptr< ns3::Object >', 
                    [param('ns3::ObjectBase *', 'object', transfer_ownership=False, is_const=True), param('uint32_t', 'i')], 
                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
-    cls.add_constructor([])
-    cls.add_copy_constructor()
     return
 
 def register_Ns3PointerValue_methods(root_module, cls):
@@ -1450,16 +1509,22 @@
     return
 
 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)])
+    ## object-factory.h: ns3::ObjectFactoryChecker::ObjectFactoryChecker() [constructor]
     cls.add_constructor([])
-    cls.add_copy_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)])
+    ## type-id.h: ns3::TypeIdChecker::TypeIdChecker() [constructor]
     cls.add_constructor([])
-    cls.add_copy_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)])
     ## double.h: ns3::DoubleValue::DoubleValue() [constructor]
     cls.add_constructor([])
     ## double.h: ns3::DoubleValue::DoubleValue(double const & value) [constructor]
@@ -1488,10 +1553,11 @@
                    'bool', 
                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## type-id.h: ns3::TypeIdValue::TypeIdValue() [constructor]
     cls.add_constructor([])
     ## type-id.h: ns3::TypeIdValue::TypeIdValue(ns3::TypeId const & value) [constructor]
@@ -1520,10 +1586,11 @@
                    'bool', 
                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## enum.h: ns3::EnumValue::EnumValue() [constructor]
     cls.add_constructor([])
     ## enum.h: ns3::EnumValue::EnumValue(int v) [constructor]
@@ -1552,10 +1619,11 @@
                    'bool', 
                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## random-variable.h: ns3::RandomVariableValue::RandomVariableValue() [constructor]
     cls.add_constructor([])
     ## random-variable.h: ns3::RandomVariableValue::RandomVariableValue(ns3::RandomVariable const & value) [constructor]
@@ -1584,10 +1652,11 @@
                    'bool', 
                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## object-factory.h: ns3::ObjectFactoryValue::ObjectFactoryValue() [constructor]
     cls.add_constructor([])
     ## object-factory.h: ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactory const & value) [constructor]
@@ -1616,10 +1685,11 @@
                    'bool', 
                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## integer.h: ns3::IntegerValue::IntegerValue() [constructor]
     cls.add_constructor([])
     ## integer.h: ns3::IntegerValue::IntegerValue(int64_t const & value) [constructor]
@@ -1648,7 +1718,6 @@
                    'bool', 
                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_Ns3BooleanValue_methods(root_module, cls):
@@ -1686,6 +1755,8 @@
     return
 
 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)])
     ## string.h: ns3::StringValue::StringValue() [constructor]
     cls.add_constructor([])
     ## string.h: ns3::StringValue::StringValue(std::string const & value) [constructor]
@@ -1714,7 +1785,6 @@
                    'bool', 
                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_Ns3EmptyAttributeValue_methods(root_module, cls):
--- a/bindings/python/ns3_module_csma.py	Fri Aug 29 14:53:38 2008 +0100
+++ b/bindings/python/ns3_module_csma.py	Fri Aug 29 14:56:24 2008 +0100
@@ -68,6 +68,8 @@
     cls.add_instance_attribute('devicePtr', 'ns3::Ptr< ns3::CsmaNetDevice >', is_const=False)
     ## 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)])
     ## csma-channel.h: ns3::CsmaDeviceRec::CsmaDeviceRec() [constructor]
     cls.add_constructor([])
     ## csma-channel.h: ns3::CsmaDeviceRec::CsmaDeviceRec(ns3::Ptr<ns3::CsmaNetDevice> device) [constructor]
@@ -76,7 +78,6 @@
     cls.add_method('IsActive', 
                    'bool', 
                    [])
-    cls.add_copy_constructor()
     return
 
 def register_Ns3Backoff_methods(root_module, cls):
@@ -90,6 +91,8 @@
     cls.add_instance_attribute('m_maxRetries', 'uint32_t', is_const=False)
     ## 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)])
     ## 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]
@@ -110,10 +113,11 @@
     cls.add_method('IncrNumRetries', 
                    'void', 
                    [])
-    cls.add_copy_constructor()
     return
 
 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)])
     ## csma-channel.h: static ns3::TypeId ns3::CsmaChannel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -198,7 +202,6 @@
                    'ns3::Time', 
                    [], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_Ns3CsmaNetDevice_methods(root_module, cls):
@@ -384,15 +387,15 @@
                    'bool', 
                    [], 
                    is_const=True, is_virtual=True)
-    ## csma-net-device.h: void ns3::CsmaNetDevice::SetReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> cb) [member function]
+    ## csma-net-device.h: void ns3::CsmaNetDevice::SetReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> cb) [member function]
     cls.add_method('SetReceiveCallback', 
                    'void', 
-                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr<const ns3::Packet >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], 
+                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], 
                    is_virtual=True)
-    ## csma-net-device.h: void ns3::CsmaNetDevice::SetPromiscReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType> cb) [member function]
+    ## csma-net-device.h: void ns3::CsmaNetDevice::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', 
                    'void', 
-                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr<const ns3::Packet >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'cb')], 
+                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'cb')], 
                    is_virtual=True)
     ## csma-net-device.h: bool ns3::CsmaNetDevice::SupportsPromiscuous() const [member function]
     cls.add_method('SupportsPromiscuous', 
--- a/bindings/python/ns3_module_global_routing.py	Fri Aug 29 14:53:38 2008 +0100
+++ b/bindings/python/ns3_module_global_routing.py	Fri Aug 29 14:56:24 2008 +0100
@@ -180,6 +180,8 @@
     return
 
 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)])
     ## 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]
@@ -220,7 +222,6 @@
     cls.add_method('SetMetric', 
                    'void', 
                    [param('uint16_t', 'metric')])
-    cls.add_copy_constructor()
     return
 
 def register_Ns3GlobalRouter_methods(root_module, cls):
--- a/bindings/python/ns3_module_helper.py	Fri Aug 29 14:53:38 2008 +0100
+++ b/bindings/python/ns3_module_helper.py	Fri Aug 29 14:56:24 2008 +0100
@@ -105,6 +105,8 @@
     return
 
 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)])
     ## mobility-helper.h: ns3::MobilityHelper::MobilityHelper() [constructor]
     cls.add_constructor([])
     ## mobility-helper.h: void ns3::MobilityHelper::SetPositionAllocator(ns3::Ptr<ns3::PositionAllocator> allocator) [member function]
@@ -155,10 +157,13 @@
                    'void', 
                    [param('std::ostream&', 'os')], 
                    is_static=True)
-    cls.add_copy_constructor()
     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)])
+    ## internet-stack-helper.h: ns3::InternetStackHelper::InternetStackHelper() [constructor]
+    cls.add_constructor([])
     ## internet-stack-helper.h: void ns3::InternetStackHelper::Install(ns3::NodeContainer c) [member function]
     cls.add_method('Install', 
                    'void', 
@@ -168,11 +173,11 @@
                    'void', 
                    [param('std::string', 'filename')], 
                    is_static=True)
-    cls.add_constructor([])
-    cls.add_copy_constructor()
     return
 
 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)])
     ## node-container.h: ns3::NodeContainer::NodeContainer() [constructor]
     cls.add_constructor([])
     ## node-container.h: ns3::NodeContainer::NodeContainer(ns3::Ptr<ns3::Node> node) [constructor]
@@ -185,12 +190,12 @@
     cls.add_constructor([param('ns3::NodeContainer&', 'a', is_const=True), param('ns3::NodeContainer&', 'b', is_const=True), param('ns3::NodeContainer&', 'c', is_const=True), param('ns3::NodeContainer&', 'd', is_const=True)])
     ## node-container.h: __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Node>*,std::vector<ns3::Ptr<ns3::Node>, std::allocator<ns3::Ptr<ns3::Node> > > > ns3::NodeContainer::Begin() const [member function]
     cls.add_method('Begin', 
-                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node >, std::allocator< ns3::Ptr< ns3::Node > > > >', 
+                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node > > >', 
                    [], 
                    is_const=True)
     ## node-container.h: __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Node>*,std::vector<ns3::Ptr<ns3::Node>, std::allocator<ns3::Ptr<ns3::Node> > > > ns3::NodeContainer::End() const [member function]
     cls.add_method('End', 
-                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node >, std::allocator< ns3::Ptr< ns3::Node > > > >', 
+                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node > > >', 
                    [], 
                    is_const=True)
     ## node-container.h: uint32_t ns3::NodeContainer::GetN() const [member function]
@@ -220,10 +225,11 @@
                    'ns3::NodeContainer', 
                    [], 
                    is_static=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## 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]
@@ -296,18 +302,21 @@
     cls.add_method('Install', 
                    'ns3::NetDeviceContainer', 
                    [param('ns3::Ptr< ns3::Node >', 'a'), param('ns3::Ptr< ns3::Node >', 'b')])
-    cls.add_copy_constructor()
     return
 
 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)])
+    ## 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]
     cls.add_method('Begin', 
-                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::NetDevice >, std::vector< ns3::Ptr< ns3::NetDevice >, std::allocator< ns3::Ptr< ns3::NetDevice > > > >', 
+                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::NetDevice >, std::vector< ns3::Ptr< ns3::NetDevice > > >', 
                    [], 
                    is_const=True)
     ## net-device-container.h: __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::NetDevice>*,std::vector<ns3::Ptr<ns3::NetDevice>, std::allocator<ns3::Ptr<ns3::NetDevice> > > > ns3::NetDeviceContainer::End() const [member function]
     cls.add_method('End', 
-                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::NetDevice >, std::vector< ns3::Ptr< ns3::NetDevice >, std::allocator< ns3::Ptr< ns3::NetDevice > > > >', 
+                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::NetDevice >, std::vector< ns3::Ptr< ns3::NetDevice > > >', 
                    [], 
                    is_const=True)
     ## net-device-container.h: uint32_t ns3::NetDeviceContainer::GetN() const [member function]
@@ -328,11 +337,11 @@
     cls.add_method('Add', 
                    'void', 
                    [param('ns3::Ptr< ns3::NetDevice >', 'device')])
-    cls.add_constructor([])
-    cls.add_copy_constructor()
     return
 
 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)])
     ## 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]
@@ -405,10 +414,11 @@
     cls.add_method('Install', 
                    'ns3::NetDeviceContainer', 
                    [param('ns3::NodeContainer&', 'c', is_const=True), param('ns3::Ptr< ns3::CsmaChannel >', 'channel')])
-    cls.add_copy_constructor()
     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)])
     ## 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]
@@ -419,10 +429,11 @@
     cls.add_method('Install', 
                    'ns3::ApplicationContainer', 
                    [param('ns3::NodeContainer', 'c')])
-    cls.add_copy_constructor()
     return
 
 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)])
     ## 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]
@@ -441,19 +452,22 @@
     cls.add_method('InstallAll', 
                    'void', 
                    [])
-    cls.add_copy_constructor()
     return
 
 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)])
+    ## packet-socket-helper.h: ns3::PacketSocketHelper::PacketSocketHelper() [constructor]
+    cls.add_constructor([])
     ## packet-socket-helper.h: void ns3::PacketSocketHelper::Install(ns3::NodeContainer c) [member function]
     cls.add_method('Install', 
                    'void', 
                    [param('ns3::NodeContainer', 'c')])
-    cls.add_constructor([])
-    cls.add_copy_constructor()
     return
 
 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)])
     ## 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]
@@ -464,10 +478,11 @@
     cls.add_method('Install', 
                    'ns3::ApplicationContainer', 
                    [param('ns3::NodeContainer', 'c')])
-    cls.add_copy_constructor()
     return
 
 def register_Ns3UdpEchoClientHelper_methods(root_module, cls):
+    ## udp-echo-helper.h: ns3::UdpEchoClientHelper::UdpEchoClientHelper(ns3::UdpEchoClientHelper const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::UdpEchoClientHelper&', 'arg0', is_const=True)])
     ## 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]
@@ -478,10 +493,11 @@
     cls.add_method('Install', 
                    'ns3::ApplicationContainer', 
                    [param('ns3::NodeContainer', 'c')])
-    cls.add_copy_constructor()
     return
 
 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)])
     ## 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]
@@ -496,10 +512,11 @@
     cls.add_method('JoinMulticastGroup', 
                    'void', 
                    [param('ns3::Ptr< ns3::Node >', 'n'), param('ns3::Ipv4Address', 'source'), param('ns3::Ipv4Address', 'group')])
-    cls.add_copy_constructor()
     return
 
 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)])
     ## ipv4-interface-container.h: ns3::Ipv4InterfaceContainer::Ipv4InterfaceContainer() [constructor]
     cls.add_constructor([])
     ## ipv4-interface-container.h: uint32_t ns3::Ipv4InterfaceContainer::GetN() const [member function]
@@ -520,18 +537,21 @@
     cls.add_method('Add', 
                    'void', 
                    [param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')])
-    cls.add_copy_constructor()
     return
 
 def register_Ns3ApplicationContainer_methods(root_module, cls):
+    ## application-container.h: ns3::ApplicationContainer::ApplicationContainer(ns3::ApplicationContainer const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::ApplicationContainer&', 'arg0', is_const=True)])
+    ## 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]
     cls.add_method('Begin', 
-                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Application >, std::vector< ns3::Ptr< ns3::Application >, std::allocator< ns3::Ptr< ns3::Application > > > >', 
+                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Application >, std::vector< ns3::Ptr< ns3::Application > > >', 
                    [], 
                    is_const=True)
     ## application-container.h: __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Application>*,std::vector<ns3::Ptr<ns3::Application>, std::allocator<ns3::Ptr<ns3::Application> > > > ns3::ApplicationContainer::End() const [member function]
     cls.add_method('End', 
-                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Application >, std::vector< ns3::Ptr< ns3::Application >, std::allocator< ns3::Ptr< ns3::Application > > > >', 
+                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Application >, std::vector< ns3::Ptr< ns3::Application > > >', 
                    [], 
                    is_const=True)
     ## application-container.h: uint32_t ns3::ApplicationContainer::GetN() const [member function]
@@ -560,11 +580,11 @@
     cls.add_method('Stop', 
                    'void', 
                    [param('ns3::Time', 'stop')])
-    cls.add_constructor([])
-    cls.add_copy_constructor()
     return
 
 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)])
     ## 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]
@@ -629,10 +649,11 @@
                    'ns3::NetDeviceContainer', 
                    [param('ns3::NodeContainer', 'c'), param('ns3::Ptr< ns3::WifiChannel >', 'channel')], 
                    is_const=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## 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]
@@ -651,10 +672,11 @@
     cls.add_method('Assign', 
                    'ns3::Ipv4InterfaceContainer', 
                    [param('ns3::NetDeviceContainer&', 'c', is_const=True)])
-    cls.add_copy_constructor()
     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)])
     ## 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]
@@ -665,10 +687,11 @@
     cls.add_method('Install', 
                    'ns3::NetDeviceContainer', 
                    [param('ns3::Ptr< ns3::Node >', 'node'), param('ns3::NetDeviceContainer', 'c')])
-    cls.add_copy_constructor()
     return
 
 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)])
     ## 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]
@@ -679,10 +702,11 @@
     cls.add_method('Install', 
                    'ns3::ApplicationContainer', 
                    [param('ns3::NodeContainer', 'c')])
-    cls.add_copy_constructor()
     return
 
 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)])
     ## 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]
@@ -690,7 +714,6 @@
                    'void', 
                    [], 
                    is_const=True)
-    cls.add_copy_constructor()
     return
 
 def register_functions(root_module):
--- a/bindings/python/ns3_module_internet_stack.py	Fri Aug 29 14:53:38 2008 +0100
+++ b/bindings/python/ns3_module_internet_stack.py	Fri Aug 29 14:56:24 2008 +0100
@@ -65,6 +65,8 @@
     return
 
 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)])
     ## ipv4-interface.h: static ns3::TypeId ns3::Ipv4Interface::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -146,10 +148,11 @@
                    'void', 
                    [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Address', 'dest')], 
                    is_pure_virtual=True, visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## udp-header.h: ns3::UdpHeader::UdpHeader() [constructor]
     cls.add_constructor([])
     ## udp-header.h: void ns3::UdpHeader::EnableChecksums() [member function]
@@ -213,10 +216,11 @@
                    'bool', 
                    [], 
                    is_const=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## tcp-header.h: ns3::TcpHeader::TcpHeader() [constructor]
     cls.add_constructor([])
     ## tcp-header.h: void ns3::TcpHeader::EnableChecksums() [member function]
@@ -334,10 +338,11 @@
                    'bool', 
                    [], 
                    is_const=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## 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]
@@ -389,7 +394,7 @@
     ## ipv4-static-routing.h: void ns3::Ipv4StaticRouting::AddMulticastRoute(ns3::Ipv4Address origin, ns3::Ipv4Address group, uint32_t inputInterface, std::vector<unsigned int, std::allocator<unsigned int> > outputInterfaces) [member function]
     cls.add_method('AddMulticastRoute', 
                    'void', 
-                   [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int, std::allocator< unsigned int > >', 'outputInterfaces')])
+                   [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int >', 'outputInterfaces')])
     ## ipv4-static-routing.h: void ns3::Ipv4StaticRouting::SetDefaultMulticastRoute(uint32_t outputInterface) [member function]
     cls.add_method('SetDefaultMulticastRoute', 
                    'void', 
@@ -422,12 +427,13 @@
                    'void', 
                    [], 
                    visibility='protected', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_Ns3Ipv4L3Protocol_methods(root_module, cls):
     ## ipv4-l3-protocol.h: ns3::Ipv4L3Protocol::PROT_NUMBER [variable]
     cls.add_static_attribute('PROT_NUMBER', retval('uint16_t', is_const=True), is_const=True)
+    ## ipv4-l3-protocol.h: ns3::Ipv4L3Protocol::Ipv4L3Protocol(ns3::Ipv4L3Protocol const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::Ipv4L3Protocol&', 'arg0', is_const=True)])
     ## ipv4-l3-protocol.h: static ns3::TypeId ns3::Ipv4L3Protocol::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -447,10 +453,10 @@
     cls.add_method('FindInterfaceForDevice', 
                    'ns3::Ptr< ns3::Ipv4Interface >', 
                    [param('ns3::Ptr< const ns3::NetDevice >', 'device')])
-    ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::Receive(ns3::Ptr<ns3::NetDevice> device, ns3::Ptr<ns3::Packet> p, uint16_t protocol, ns3::Address const & from, ns3::Address const & to, ns3::NetDevice::PacketType packetType) [member function]
+    ## 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< 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&', 'from', is_const=True), param('ns3::Address&', 'to', is_const=True), param('ns3::NetDevice::PacketType', 'packetType')])
     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::Send(ns3::Ptr<ns3::Packet> packet, ns3::Ipv4Address source, ns3::Ipv4Address destination, uint8_t protocol) [member function]
     cls.add_method('Send', 
                    'void', 
@@ -494,7 +500,7 @@
     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::AddMulticastRoute(ns3::Ipv4Address origin, ns3::Ipv4Address group, uint32_t inputInterface, std::vector<unsigned int, std::allocator<unsigned int> > outputInterfaces) [member function]
     cls.add_method('AddMulticastRoute', 
                    'void', 
-                   [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int, std::allocator< unsigned int > >', 'outputInterfaces')])
+                   [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int >', 'outputInterfaces')])
     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::SetDefaultMulticastRoute(uint32_t onputInterface) [member function]
     cls.add_method('SetDefaultMulticastRoute', 
                    'void', 
@@ -613,7 +619,6 @@
                    'void', 
                    [], 
                    visibility='protected', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_functions(root_module):
--- a/bindings/python/ns3_module_mobility.py	Fri Aug 29 14:53:38 2008 +0100
+++ b/bindings/python/ns3_module_mobility.py	Fri Aug 29 14:56:24 2008 +0100
@@ -111,6 +111,8 @@
     return
 
 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)])
     ## static-speed-helper.h: ns3::StaticSpeedHelper::StaticSpeedHelper() [constructor]
     cls.add_constructor([])
     ## static-speed-helper.h: ns3::StaticSpeedHelper::StaticSpeedHelper(ns3::Vector const & position) [constructor]
@@ -152,7 +154,6 @@
     cls.add_method('Unpause', 
                    'void', 
                    [])
-    cls.add_copy_constructor()
     return
 
 def register_Ns3Vector_methods(root_module, cls):
@@ -172,13 +173,17 @@
     return
 
 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)])
+    ## vector.h: ns3::VectorChecker::VectorChecker() [constructor]
     cls.add_constructor([])
-    cls.add_copy_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)])
+    ## rectangle.h: ns3::RectangleChecker::RectangleChecker() [constructor]
     cls.add_constructor([])
-    cls.add_copy_constructor()
     return
 
 def register_Ns3Rectangle_methods(root_module, cls):
@@ -215,6 +220,8 @@
     return
 
 def register_Ns3PositionAllocator_methods(root_module, cls):
+    ## position-allocator.h: ns3::PositionAllocator::PositionAllocator(ns3::PositionAllocator const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::PositionAllocator&', 'arg0', is_const=True)])
     ## position-allocator.h: static ns3::TypeId ns3::PositionAllocator::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -227,10 +234,11 @@
                    'ns3::Vector', 
                    [], 
                    is_pure_virtual=True, is_const=True, is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## position-allocator.h: static ns3::TypeId ns3::ListPositionAllocator::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -247,10 +255,11 @@
                    'ns3::Vector', 
                    [], 
                    is_const=True, is_virtual=True)
-    cls.add_copy_constructor()
     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)])
     ## rectangle.h: ns3::RectangleValue::RectangleValue() [constructor]
     cls.add_constructor([])
     ## rectangle.h: ns3::RectangleValue::RectangleValue(ns3::Rectangle const & value) [constructor]
@@ -279,10 +288,11 @@
                    'bool', 
                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     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', 
@@ -303,10 +313,11 @@
                    'ns3::Vector', 
                    [], 
                    is_const=True, is_virtual=True)
-    cls.add_copy_constructor()
     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)])
     ## vector.h: ns3::VectorValue::VectorValue() [constructor]
     cls.add_constructor([])
     ## vector.h: ns3::VectorValue::VectorValue(ns3::Vector const & value) [constructor]
@@ -335,10 +346,11 @@
                    'bool', 
                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_Ns3RandomDiscPositionAllocator_methods(root_module, cls):
+    ## position-allocator.h: ns3::RandomDiscPositionAllocator::RandomDiscPositionAllocator(ns3::RandomDiscPositionAllocator const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::RandomDiscPositionAllocator&', 'arg0', is_const=True)])
     ## position-allocator.h: static ns3::TypeId ns3::RandomDiscPositionAllocator::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -367,10 +379,11 @@
                    'ns3::Vector', 
                    [], 
                    is_const=True, is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## mobility-model.h: static ns3::TypeId ns3::MobilityModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -417,10 +430,11 @@
                    'ns3::Vector', 
                    [], 
                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_Ns3RandomDirection2dMobilityModel_methods(root_module, cls):
+    ## random-direction-2d-mobility-model.h: ns3::RandomDirection2dMobilityModel::RandomDirection2dMobilityModel(ns3::RandomDirection2dMobilityModel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::RandomDirection2dMobilityModel&', 'arg0', is_const=True)])
     ## random-direction-2d-mobility-model.h: static ns3::TypeId ns3::RandomDirection2dMobilityModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -448,10 +462,11 @@
                    'ns3::Vector', 
                    [], 
                    is_const=True, visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_Ns3GridPositionAllocator_methods(root_module, cls):
+    ## position-allocator.h: ns3::GridPositionAllocator::GridPositionAllocator(ns3::GridPositionAllocator const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::GridPositionAllocator&', 'arg0', is_const=True)])
     ## position-allocator.h: static ns3::TypeId ns3::GridPositionAllocator::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -518,10 +533,11 @@
                    'ns3::Vector', 
                    [], 
                    is_const=True, is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_Ns3RandomWaypointMobilityModel_methods(root_module, cls):
+    ## random-waypoint-mobility-model.h: ns3::RandomWaypointMobilityModel::RandomWaypointMobilityModel(ns3::RandomWaypointMobilityModel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::RandomWaypointMobilityModel&', 'arg0', is_const=True)])
     ## random-waypoint-mobility-model.h: static ns3::TypeId ns3::RandomWaypointMobilityModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -544,10 +560,11 @@
                    'ns3::Vector', 
                    [], 
                    is_const=True, visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_Ns3RandomWalk2dMobilityModel_methods(root_module, cls):
+    ## random-walk-2d-mobility-model.h: ns3::RandomWalk2dMobilityModel::RandomWalk2dMobilityModel(ns3::RandomWalk2dMobilityModel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::RandomWalk2dMobilityModel&', 'arg0', is_const=True)])
     ## random-walk-2d-mobility-model.h: static ns3::TypeId ns3::RandomWalk2dMobilityModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -575,10 +592,11 @@
                    'ns3::Vector', 
                    [], 
                    is_const=True, visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## static-speed-mobility-model.h: static ns3::TypeId ns3::StaticSpeedMobilityModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -605,10 +623,11 @@
                    'ns3::Vector', 
                    [], 
                    is_const=True, visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_Ns3HierarchicalMobilityModel_methods(root_module, cls):
+    ## hierarchical-mobility-model.h: ns3::HierarchicalMobilityModel::HierarchicalMobilityModel(ns3::HierarchicalMobilityModel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::HierarchicalMobilityModel&', 'arg0', is_const=True)])
     ## hierarchical-mobility-model.h: static ns3::TypeId ns3::HierarchicalMobilityModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -641,10 +660,11 @@
                    'ns3::Vector', 
                    [], 
                    is_const=True, visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## static-mobility-model.h: static ns3::TypeId ns3::StaticMobilityModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -667,7 +687,6 @@
                    'ns3::Vector', 
                    [], 
                    is_const=True, visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_functions(root_module):
--- a/bindings/python/ns3_module_node.py	Fri Aug 29 14:53:38 2008 +0100
+++ b/bindings/python/ns3_module_node.py	Fri Aug 29 14:56:24 2008 +0100
@@ -5,6 +5,8 @@
     
     ## ethernet-header.h: ns3::ethernet_header_t [enumeration]
     module.add_enum('ethernet_header_t', ['LENGTH', 'VLAN', 'QINQ'])
+    ## ipv4-address.h: ns3::Ipv4Mask [class]
+    module.add_class('Ipv4Mask')
     ## node-list.h: ns3::NodeList [class]
     module.add_class('NodeList')
     ## address.h: ns3::Address [class]
@@ -37,8 +39,6 @@
     module.add_class('PacketSocketAddress')
     ## packet-socket-address.h: ns3::PacketSocketAddress [class]
     root_module['ns3::PacketSocketAddress'].implicitly_converts_to(root_module['ns3::Address'])
-    ## ipv4-address.h: ns3::Ipv4Mask [class]
-    module.add_class('Ipv4Mask')
     ## ipv4-address.h: ns3::Ipv4AddressValue [class]
     module.add_class('Ipv4AddressValue', parent=root_module['ns3::AttributeValue'])
     ## ipv4.h: ns3::Ipv4RoutingProtocol [class]
@@ -147,6 +147,7 @@
     
 
 def register_methods(root_module):
+    register_Ns3Ipv4Mask_methods(root_module, root_module['ns3::Ipv4Mask'])
     register_Ns3NodeList_methods(root_module, root_module['ns3::NodeList'])
     register_Ns3Address_methods(root_module, root_module['ns3::Address'])
     register_Ns3Ipv4AddressChecker_methods(root_module, root_module['ns3::Ipv4AddressChecker'])
@@ -159,7 +160,6 @@
     register_Ns3Ipv4MulticastRoute_methods(root_module, root_module['ns3::Ipv4MulticastRoute'])
     register_Ns3AddressChecker_methods(root_module, root_module['ns3::AddressChecker'])
     register_Ns3PacketSocketAddress_methods(root_module, root_module['ns3::PacketSocketAddress'])
-    register_Ns3Ipv4Mask_methods(root_module, root_module['ns3::Ipv4Mask'])
     register_Ns3Ipv4AddressValue_methods(root_module, root_module['ns3::Ipv4AddressValue'])
     register_Ns3Ipv4RoutingProtocol_methods(root_module, root_module['ns3::Ipv4RoutingProtocol'])
     register_Ns3Mac48AddressValue_methods(root_module, root_module['ns3::Mac48AddressValue'])
@@ -191,7 +191,62 @@
     register_Ns3PacketSocketFactory_methods(root_module, root_module['ns3::PacketSocketFactory'])
     return
 
+def register_Ns3Ipv4Mask_methods(root_module, cls):
+    ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::Ipv4Mask&', 'arg0', is_const=True)])
+    ## 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)])
+    ## ipv4-address.h: uint32_t ns3::Ipv4Mask::Get() const [member function]
+    cls.add_method('Get', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
+    ## ipv4-address.h: uint32_t ns3::Ipv4Mask::GetInverse() const [member function]
+    cls.add_method('GetInverse', 
+                   'uint32_t', 
+                   [], 
+                   is_const=True)
+    ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetLoopback() [member function]
+    cls.add_method('GetLoopback', 
+                   'ns3::Ipv4Mask', 
+                   [], 
+                   is_static=True)
+    ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetZero() [member function]
+    cls.add_method('GetZero', 
+                   'ns3::Ipv4Mask', 
+                   [], 
+                   is_static=True)
+    ## ipv4-address.h: bool ns3::Ipv4Mask::IsEqual(ns3::Ipv4Mask other) const [member function]
+    cls.add_method('IsEqual', 
+                   'bool', 
+                   [param('ns3::Ipv4Mask', 'other')], 
+                   is_const=True)
+    ## ipv4-address.h: bool ns3::Ipv4Mask::IsMatch(ns3::Ipv4Address a, ns3::Ipv4Address b) const [member function]
+    cls.add_method('IsMatch', 
+                   'bool', 
+                   [param('ns3::Ipv4Address', 'a'), param('ns3::Ipv4Address', 'b')], 
+                   is_const=True)
+    ## ipv4-address.h: void ns3::Ipv4Mask::Print(std::ostream & os) const [member function]
+    cls.add_method('Print', 
+                   'void', 
+                   [param('std::ostream&', 'os')], 
+                   is_const=True)
+    ## ipv4-address.h: void ns3::Ipv4Mask::Set(uint32_t mask) [member function]
+    cls.add_method('Set', 
+                   'void', 
+                   [param('uint32_t', 'mask')])
+    cls.add_output_stream_operator()
+    return
+
 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)])
+    ## 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]
     cls.add_method('Add', 
                    'uint32_t', 
@@ -199,12 +254,12 @@
                    is_static=True)
     ## node-list.h: static __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Node>*,std::vector<ns3::Ptr<ns3::Node>, std::allocator<ns3::Ptr<ns3::Node> > > > ns3::NodeList::Begin() [member function]
     cls.add_method('Begin', 
-                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node >, std::allocator< ns3::Ptr< ns3::Node > > > >', 
+                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node > > >', 
                    [], 
                    is_static=True)
     ## node-list.h: static __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Node>*,std::vector<ns3::Ptr<ns3::Node>, std::allocator<ns3::Ptr<ns3::Node> > > > ns3::NodeList::End() [member function]
     cls.add_method('End', 
-                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node >, std::allocator< ns3::Ptr< ns3::Node > > > >', 
+                   '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node > > >', 
                    [], 
                    is_static=True)
     ## node-list.h: static ns3::Ptr<ns3::Node> ns3::NodeList::GetNode(uint32_t n) [member function]
@@ -217,8 +272,6 @@
                    'uint32_t', 
                    [], 
                    is_static=True)
-    cls.add_constructor([])
-    cls.add_copy_constructor()
     return
 
 def register_Ns3Address_methods(root_module, cls):
@@ -289,8 +342,10 @@
     return
 
 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)])
+    ## ipv4-address.h: ns3::Ipv4AddressChecker::Ipv4AddressChecker() [constructor]
     cls.add_constructor([])
-    cls.add_copy_constructor()
     return
 
 def register_Ns3Mac48Address_methods(root_module, cls):
@@ -324,11 +379,26 @@
                    'ns3::Mac48Address', 
                    [], 
                    is_static=True)
+    ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::GetMulticast(ns3::Ipv4Address address) [member function]
+    cls.add_method('GetMulticast', 
+                   'ns3::Mac48Address', 
+                   [param('ns3::Ipv4Address', 'address')], 
+                   is_static=True)
+    ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::GetMulticastPrefix() [member function]
+    cls.add_method('GetMulticastPrefix', 
+                   'ns3::Mac48Address', 
+                   [], 
+                   is_static=True)
     ## mac48-address.h: bool ns3::Mac48Address::IsBroadcast() const [member function]
     cls.add_method('IsBroadcast', 
                    'bool', 
                    [], 
                    is_const=True)
+    ## mac48-address.h: bool ns3::Mac48Address::IsGroup() const [member function]
+    cls.add_method('IsGroup', 
+                   'bool', 
+                   [], 
+                   is_const=True)
     ## mac48-address.h: static bool ns3::Mac48Address::IsMatchingType(ns3::Address const & address) [member function]
     cls.add_method('IsMatchingType', 
                    'bool', 
@@ -377,6 +447,10 @@
     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)])
+    ## 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', 
@@ -422,18 +496,20 @@
                    'void', 
                    [], 
                    is_static=True)
-    cls.add_constructor([])
-    cls.add_copy_constructor()
     return
 
 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)])
+    ## mac48-address.h: ns3::Mac48AddressChecker::Mac48AddressChecker() [constructor]
     cls.add_constructor([])
-    cls.add_copy_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)])
+    ## ipv4-address.h: ns3::Ipv4MaskChecker::Ipv4MaskChecker() [constructor]
     cls.add_constructor([])
-    cls.add_copy_constructor()
     return
 
 def register_Ns3Ipv4Route_methods(root_module, cls):
@@ -526,7 +602,7 @@
     ## ipv4-route.h: static ns3::Ipv4MulticastRoute ns3::Ipv4MulticastRoute::CreateMulticastRoute(ns3::Ipv4Address origin, ns3::Ipv4Address group, uint32_t inputInterface, std::vector<unsigned int, std::allocator<unsigned int> > outputInterfaces) [member function]
     cls.add_method('CreateMulticastRoute', 
                    'ns3::Ipv4MulticastRoute', 
-                   [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int, std::allocator< unsigned int > >', 'outputInterfaces')], 
+                   [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int >', 'outputInterfaces')], 
                    is_static=True)
     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4MulticastRoute::GetGroup() const [member function]
     cls.add_method('GetGroup', 
@@ -555,18 +631,22 @@
                    is_const=True)
     ## ipv4-route.h: std::vector<unsigned int, std::allocator<unsigned int> > ns3::Ipv4MulticastRoute::GetOutputInterfaces() const [member function]
     cls.add_method('GetOutputInterfaces', 
-                   'std::vector< unsigned int, std::allocator< unsigned int > >', 
+                   'std::vector< unsigned int >', 
                    [], 
                    is_const=True)
     cls.add_output_stream_operator()
     return
 
 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)])
+    ## address.h: ns3::AddressChecker::AddressChecker() [constructor]
     cls.add_constructor([])
-    cls.add_copy_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)])
     ## packet-socket-address.h: ns3::PacketSocketAddress::PacketSocketAddress() [constructor]
     cls.add_constructor([])
     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetProtocol(uint16_t protocol) [member function]
@@ -615,61 +695,11 @@
                    'bool', 
                    [param('ns3::Address&', 'address', is_const=True)], 
                    is_static=True)
-    cls.add_copy_constructor()
-    return
-
-def register_Ns3Ipv4Mask_methods(root_module, cls):
-    ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [copy constructor]
-    cls.add_constructor([param('ns3::Ipv4Mask&', 'arg0', is_const=True)])
-    ## 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)])
-    ## ipv4-address.h: uint32_t ns3::Ipv4Mask::Get() const [member function]
-    cls.add_method('Get', 
-                   'uint32_t', 
-                   [], 
-                   is_const=True)
-    ## ipv4-address.h: uint32_t ns3::Ipv4Mask::GetInverse() const [member function]
-    cls.add_method('GetInverse', 
-                   'uint32_t', 
-                   [], 
-                   is_const=True)
-    ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetLoopback() [member function]
-    cls.add_method('GetLoopback', 
-                   'ns3::Ipv4Mask', 
-                   [], 
-                   is_static=True)
-    ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetZero() [member function]
-    cls.add_method('GetZero', 
-                   'ns3::Ipv4Mask', 
-                   [], 
-                   is_static=True)
-    ## ipv4-address.h: bool ns3::Ipv4Mask::IsEqual(ns3::Ipv4Mask other) const [member function]
-    cls.add_method('IsEqual', 
-                   'bool', 
-                   [param('ns3::Ipv4Mask', 'other')], 
-                   is_const=True)
-    ## ipv4-address.h: bool ns3::Ipv4Mask::IsMatch(ns3::Ipv4Address a, ns3::Ipv4Address b) const [member function]
-    cls.add_method('IsMatch', 
-                   'bool', 
-                   [param('ns3::Ipv4Address', 'a'), param('ns3::Ipv4Address', 'b')], 
-                   is_const=True)
-    ## ipv4-address.h: void ns3::Ipv4Mask::Print(std::ostream & os) const [member function]
-    cls.add_method('Print', 
-                   'void', 
-                   [param('std::ostream&', 'os')], 
-                   is_const=True)
-    ## ipv4-address.h: void ns3::Ipv4Mask::Set(uint32_t mask) [member function]
-    cls.add_method('Set', 
-                   'void', 
-                   [param('uint32_t', 'mask')])
-    cls.add_output_stream_operator()
     return
 
 def register_Ns3Ipv4AddressValue_methods(root_module, cls):
+    ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4AddressValue const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::Ipv4AddressValue&', 'arg0', is_const=True)])
     ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue() [constructor]
     cls.add_constructor([])
     ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4Address const & value) [constructor]
@@ -698,12 +728,15 @@
                    'bool', 
                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_Ns3Ipv4RoutingProtocol_methods(root_module, cls):
     ## ipv4.h: ns3::Ipv4RoutingProtocol::IF_INDEX_ANY [variable]
     cls.add_static_attribute('IF_INDEX_ANY', retval('uint32_t', is_const=True), is_const=True)
+    ## ipv4.h: ns3::Ipv4RoutingProtocol::Ipv4RoutingProtocol(ns3::Ipv4RoutingProtocol const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::Ipv4RoutingProtocol&', 'arg0', is_const=True)])
+    ## 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', 
@@ -714,11 +747,11 @@
                    'bool', 
                    [param('ns3::Ipv4Address', 'destination'), param('uint32_t&', 'ifIndex')], 
                    is_pure_virtual=True, is_virtual=True)
-    cls.add_constructor([])
-    cls.add_copy_constructor()
     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)])
     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue() [constructor]
     cls.add_constructor([])
     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48Address const & value) [constructor]
@@ -747,10 +780,11 @@
                    'bool', 
                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue() [constructor]
     cls.add_constructor([])
     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4Mask const & value) [constructor]
@@ -779,10 +813,11 @@
                    'bool', 
                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## socket.h: ns3::SocketAddressTag::SocketAddressTag() [constructor]
     cls.add_constructor([])
     ## socket.h: void ns3::SocketAddressTag::SetAddress(ns3::Address addr) [member function]
@@ -824,10 +859,11 @@
                    'void', 
                    [param('std::ostream&', 'os')], 
                    is_const=True, is_virtual=True)
-    cls.add_copy_constructor()
     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)])
     ## 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]
@@ -866,7 +902,6 @@
                    'ns3::InetSocketAddress', 
                    [param('ns3::Address&', 'address', is_const=True)], 
                    is_static=True)
-    cls.add_copy_constructor()
     return
 
 def register_Ns3Ipv4Address_methods(root_module, cls):
@@ -970,6 +1005,8 @@
     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)])
     ## application.h: static ns3::TypeId ns3::Application::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1017,10 +1054,11 @@
                    'void', 
                    [], 
                    visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## queue.h: static ns3::TypeId ns3::Queue::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1104,10 +1142,11 @@
                    'ns3::Ptr< const ns3::Packet >', 
                    [], 
                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_Ns3Socket_methods(root_module, cls):
+    ## socket.h: ns3::Socket::Socket(ns3::Socket const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::Socket&', 'arg0', is_const=True)])
     ## 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]
@@ -1273,10 +1312,11 @@
                    'void', 
                    [], 
                    visibility='protected')
-    cls.add_copy_constructor()
     return
 
 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)])
     ## ipv4-header.h: ns3::Ipv4Header::Ipv4Header() [constructor]
     cls.add_constructor([])
     ## ipv4-header.h: void ns3::Ipv4Header::EnableChecksum() [member function]
@@ -1416,10 +1456,11 @@
                    'uint32_t', 
                    [param('ns3::Buffer::Iterator', 'start')], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## udp-socket.h: static ns3::TypeId ns3::UdpSocket::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1457,10 +1498,13 @@
                    'uint32_t', 
                    [], 
                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
+    ## net-device.h: ns3::NetDevice::NetDevice() [constructor]
+    cls.add_constructor([])
     ## net-device.h: static ns3::TypeId ns3::NetDevice::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1571,26 +1615,26 @@
                    'bool', 
                    [], 
                    is_pure_virtual=True, is_const=True, is_virtual=True)
-    ## net-device.h: void ns3::NetDevice::SetReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> cb) [member function]
+    ## net-device.h: void ns3::NetDevice::SetReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> cb) [member function]
     cls.add_method('SetReceiveCallback', 
                    'void', 
-                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr<const ns3::Packet >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], 
+                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], 
                    is_pure_virtual=True, is_virtual=True)
-    ## net-device.h: void ns3::NetDevice::SetPromiscReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType> cb) [member function]
+    ## net-device.h: void ns3::NetDevice::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', 
                    'void', 
-                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr<const ns3::Packet >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'cb')], 
+                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'cb')], 
                    is_pure_virtual=True, is_virtual=True)
     ## net-device.h: bool ns3::NetDevice::SupportsPromiscuous() const [member function]
     cls.add_method('SupportsPromiscuous', 
                    'bool', 
                    [], 
                    is_pure_virtual=True, is_const=True, is_virtual=True)
-    cls.add_constructor([])
-    cls.add_copy_constructor()
     return
 
 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)])
     ## drop-tail-queue.h: static ns3::TypeId ns3::DropTailQueue::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1613,10 +1657,11 @@
                    'ns3::Ptr< const ns3::Packet >', 
                    [], 
                    is_const=True, visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## address.h: ns3::AddressValue::AddressValue() [constructor]
     cls.add_constructor([])
     ## address.h: ns3::AddressValue::AddressValue(ns3::Address const & value) [constructor]
@@ -1645,10 +1690,11 @@
                    'bool', 
                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## node.h: static ns3::TypeId ns3::Node::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1696,14 +1742,14 @@
                    'uint32_t', 
                    [], 
                    is_const=True)
-    ## node.h: void ns3::Node::RegisterProtocolHandler(ns3::Callback<void, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType> handler, uint16_t protocolType, ns3::Ptr<ns3::NetDevice> device, bool promiscuous=false) [member function]
+    ## node.h: void ns3::Node::RegisterProtocolHandler(ns3::Callback<void, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType> handler, uint16_t protocolType, ns3::Ptr<ns3::NetDevice> device, bool promiscuous=false) [member function]
     cls.add_method('RegisterProtocolHandler', 
                    'void', 
-                   [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr<const ns3::Packet >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'handler'), param('uint16_t', 'protocolType'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'promiscuous', default_value='false')])
-    ## node.h: void ns3::Node::UnregisterProtocolHandler(ns3::Callback<void, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType> handler) [member function]
+                   [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'handler'), param('uint16_t', 'protocolType'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'promiscuous', default_value='false')])
+    ## node.h: void ns3::Node::UnregisterProtocolHandler(ns3::Callback<void, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType> handler) [member function]
     cls.add_method('UnregisterProtocolHandler', 
                    'void', 
-                   [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr<const ns3::Packet >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'handler')])
+                   [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'handler')])
     ## node.h: void ns3::Node::DoDispose() [member function]
     cls.add_method('DoDispose', 
                    'void', 
@@ -1714,10 +1760,11 @@
                    'void', 
                    [param('ns3::Ptr< ns3::NetDevice >', 'device')], 
                    visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## channel.h: static ns3::TypeId ns3::Channel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1745,10 +1792,11 @@
                    'ns3::Ptr< ns3::NetDevice >', 
                    [param('uint32_t', 'i')], 
                    is_pure_virtual=True, is_const=True, is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## tcp-socket.h: static ns3::TypeId ns3::TcpSocket::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1856,10 +1904,11 @@
                    'uint32_t', 
                    [], 
                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader(bool hasPreamble) [constructor]
     cls.add_constructor([param('bool', 'hasPreamble')])
     ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader() [constructor]
@@ -1940,10 +1989,11 @@
                    'uint32_t', 
                    [param('ns3::Buffer::Iterator', 'start')], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## socket.h: ns3::SocketIpTtlTag::SocketIpTtlTag() [constructor]
     cls.add_constructor([])
     ## socket.h: void ns3::SocketIpTtlTag::SetTtl(uint8_t ttl) [member function]
@@ -1985,10 +2035,11 @@
                    'void', 
                    [param('std::ostream&', 'os')], 
                    is_const=True, is_virtual=True)
-    cls.add_copy_constructor()
     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)])
     ## ipv4.h: static ns3::TypeId ns3::Ipv4::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2044,7 +2095,7 @@
     ## ipv4.h: void ns3::Ipv4::AddMulticastRoute(ns3::Ipv4Address origin, ns3::Ipv4Address group, uint32_t inputInterface, std::vector<unsigned int, std::allocator<unsigned int> > outputInterfaces) [member function]
     cls.add_method('AddMulticastRoute', 
                    'void', 
-                   [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int, std::allocator< unsigned int > >', 'outputInterfaces')], 
+                   [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int >', 'outputInterfaces')], 
                    is_pure_virtual=True, is_virtual=True)
     ## ipv4.h: void ns3::Ipv4::RemoveMulticastRoute(ns3::Ipv4Address origin, ns3::Ipv4Address group, uint32_t inputInterface) [member function]
     cls.add_method('RemoveMulticastRoute', 
@@ -2176,10 +2227,11 @@
                    'uint32_t', 
                    [param('ns3::Ipv4Address', 'addr'), param('ns3::Ipv4Mask', 'mask', default_value='ns3::Ipv4Mask(((const char*)"255.255.255.255"))')], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## socket-factory.h: static ns3::TypeId ns3::SocketFactory::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2192,10 +2244,11 @@
                    'ns3::Ptr< ns3::Socket >', 
                    [], 
                    is_pure_virtual=True, is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## ethernet-trailer.h: ns3::EthernetTrailer::EthernetTrailer() [constructor]
     cls.add_constructor([])
     ## ethernet-trailer.h: static void ns3::EthernetTrailer::EnableFcs(bool enable) [member function]
@@ -2255,10 +2308,11 @@
                    'uint32_t', 
                    [param('ns3::Buffer::Iterator', 'end')], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## simple-channel.h: static ns3::TypeId ns3::SimpleChannel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2284,10 +2338,11 @@
                    'ns3::Ptr< ns3::NetDevice >', 
                    [param('uint32_t', 'i')], 
                    is_const=True, is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## llc-snap-header.h: ns3::LlcSnapHeader::LlcSnapHeader() [constructor]
     cls.add_constructor([])
     ## llc-snap-header.h: void ns3::LlcSnapHeader::SetType(uint16_t type) [member function]
@@ -2328,20 +2383,23 @@
                    'uint32_t', 
                    [param('ns3::Buffer::Iterator', 'start')], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
+    ## udp-socket-factory.h: ns3::UdpSocketFactory::UdpSocketFactory() [constructor]
+    cls.add_constructor([])
     ## udp-socket-factory.h: static ns3::TypeId ns3::UdpSocketFactory::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
                    [], 
                    is_static=True)
-    cls.add_constructor([])
-    cls.add_copy_constructor()
     return
 
 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)])
     ## simple-net-device.h: static ns3::TypeId ns3::SimpleNetDevice::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2466,15 +2524,15 @@
                    'bool', 
                    [], 
                    is_const=True, is_virtual=True)
-    ## simple-net-device.h: void ns3::SimpleNetDevice::SetReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> cb) [member function]
+    ## simple-net-device.h: void ns3::SimpleNetDevice::SetReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> cb) [member function]
     cls.add_method('SetReceiveCallback', 
                    'void', 
-                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr<const ns3::Packet >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], 
+                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], 
                    is_virtual=True)
-    ## simple-net-device.h: void ns3::SimpleNetDevice::SetPromiscReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType> cb) [member function]
+    ## simple-net-device.h: void ns3::SimpleNetDevice::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', 
                    'void', 
-                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr<const ns3::Packet >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'cb')], 
+                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'cb')], 
                    is_virtual=True)
     ## simple-net-device.h: bool ns3::SimpleNetDevice::SupportsPromiscuous() const [member function]
     cls.add_method('SupportsPromiscuous', 
@@ -2486,20 +2544,23 @@
                    'void', 
                    [], 
                    visibility='protected', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
+    ## tcp-socket-factory.h: ns3::TcpSocketFactory::TcpSocketFactory() [constructor]
+    cls.add_constructor([])
     ## tcp-socket-factory.h: static ns3::TypeId ns3::TcpSocketFactory::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
                    [], 
                    is_static=True)
-    cls.add_constructor([])
-    cls.add_copy_constructor()
     return
 
 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)])
     ## packet-socket-factory.h: static ns3::TypeId ns3::PacketSocketFactory::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2512,7 +2573,6 @@
                    'ns3::Ptr< ns3::Socket >', 
                    [], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_functions(root_module):
--- a/bindings/python/ns3_module_olsr.py	Fri Aug 29 14:53:38 2008 +0100
+++ b/bindings/python/ns3_module_olsr.py	Fri Aug 29 14:56:24 2008 +0100
@@ -205,6 +205,8 @@
     return
 
 def register_Ns3OlsrMessageHeaderMid_methods(root_module, cls):
+    ## 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)])
     ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::Mid::Deserialize(ns3::Buffer::Iterator start, uint32_t messageSize) [member function]
@@ -227,10 +229,12 @@
                    [param('ns3::Buffer::Iterator', 'start')], 
                    is_const=True)
     ## olsr-header.h: ns3::olsr::MessageHeader::Mid::interfaceAddresses [variable]
-    cls.add_instance_attribute('interfaceAddresses', 'std::vector< ns3::Ipv4Address, std::allocator< ns3::Ipv4Address > >', is_const=False)
+    cls.add_instance_attribute('interfaceAddresses', 'std::vector< ns3::Ipv4Address >', is_const=False)
     return
 
 def register_Ns3OlsrMessageHeaderHello_methods(root_module, cls):
+    ## 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)])
     ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::Hello::Deserialize(ns3::Buffer::Iterator start, uint32_t messageSize) [member function]
@@ -264,7 +268,7 @@
     ## olsr-header.h: ns3::olsr::MessageHeader::Hello::hTime [variable]
     cls.add_instance_attribute('hTime', 'uint8_t', is_const=False)
     ## olsr-header.h: ns3::olsr::MessageHeader::Hello::linkMessages [variable]
-    cls.add_instance_attribute('linkMessages', 'std::vector< ns3::olsr::MessageHeader::Hello::LinkMessage, std::allocator< ns3::olsr::MessageHeader::Hello::LinkMessage > >', is_const=False)
+    cls.add_instance_attribute('linkMessages', 'std::vector< ns3::olsr::MessageHeader::Hello::LinkMessage >', is_const=False)
     ## olsr-header.h: ns3::olsr::MessageHeader::Hello::willingness [variable]
     cls.add_instance_attribute('willingness', 'uint8_t', is_const=False)
     return
@@ -273,12 +277,16 @@
     ## olsr-header.h: ns3::olsr::MessageHeader::Hello::LinkMessage::linkCode [variable]
     cls.add_instance_attribute('linkCode', 'uint8_t', is_const=False)
     ## olsr-header.h: ns3::olsr::MessageHeader::Hello::LinkMessage::neighborInterfaceAddresses [variable]
-    cls.add_instance_attribute('neighborInterfaceAddresses', 'std::vector< ns3::Ipv4Address, std::allocator< ns3::Ipv4Address > >', is_const=False)
+    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)])
+    ## olsr-header.h: ns3::olsr::MessageHeader::Hello::LinkMessage::LinkMessage() [constructor]
     cls.add_constructor([])
-    cls.add_copy_constructor()
     return
 
 def register_Ns3OlsrMessageHeaderTc_methods(root_module, cls):
+    ## 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)])
     ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::Tc::Deserialize(ns3::Buffer::Iterator start, uint32_t messageSize) [member function]
@@ -303,10 +311,12 @@
     ## olsr-header.h: ns3::olsr::MessageHeader::Tc::ansn [variable]
     cls.add_instance_attribute('ansn', 'uint16_t', is_const=False)
     ## olsr-header.h: ns3::olsr::MessageHeader::Tc::neighborAddresses [variable]
-    cls.add_instance_attribute('neighborAddresses', 'std::vector< ns3::Ipv4Address, std::allocator< ns3::Ipv4Address > >', is_const=False)
+    cls.add_instance_attribute('neighborAddresses', 'std::vector< ns3::Ipv4Address >', is_const=False)
     return
 
 def register_Ns3OlsrMessageHeaderHna_methods(root_module, cls):
+    ## 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)])
     ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::Hna::Deserialize(ns3::Buffer::Iterator start, uint32_t messageSize) [member function]
@@ -329,7 +339,7 @@
                    [param('ns3::Buffer::Iterator', 'start')], 
                    is_const=True)
     ## olsr-header.h: ns3::olsr::MessageHeader::Hna::associations [variable]
-    cls.add_instance_attribute('associations', 'std::vector< ns3::olsr::MessageHeader::Hna::Association, std::allocator< ns3::olsr::MessageHeader::Hna::Association > >', is_const=False)
+    cls.add_instance_attribute('associations', 'std::vector< ns3::olsr::MessageHeader::Hna::Association >', is_const=False)
     return
 
 def register_Ns3OlsrMessageHeaderHnaAssociation_methods(root_module, cls):
@@ -337,11 +347,17 @@
     cls.add_instance_attribute('address', 'ns3::Ipv4Address', is_const=False)
     ## 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)])
+    ## olsr-header.h: ns3::olsr::MessageHeader::Hna::Association::Association() [constructor]
     cls.add_constructor([])
-    cls.add_copy_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)])
+    ## olsr-agent.h: ns3::olsr::Agent::Agent() [constructor]
+    cls.add_constructor([])
     ## olsr-agent.h: static ns3::TypeId ns3::olsr::Agent::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -362,8 +378,6 @@
                    'void', 
                    [], 
                    is_pure_virtual=True, is_virtual=True)
-    cls.add_constructor([])
-    cls.add_copy_constructor()
     return
 
 def register_Ns3OlsrPacketHeader_methods(root_module, cls):
--- a/bindings/python/ns3_module_onoff.py	Fri Aug 29 14:53:38 2008 +0100
+++ b/bindings/python/ns3_module_onoff.py	Fri Aug 29 14:56:24 2008 +0100
@@ -51,6 +51,8 @@
     return
 
 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)])
     ## onoff-application.h: static ns3::TypeId ns3::OnOffApplication::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -77,7 +79,6 @@
                    'void', 
                    [], 
                    visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_functions(root_module):
--- a/bindings/python/ns3_module_packet_sink.py	Fri Aug 29 14:53:38 2008 +0100
+++ b/bindings/python/ns3_module_packet_sink.py	Fri Aug 29 14:56:24 2008 +0100
@@ -51,6 +51,8 @@
     return
 
 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)])
     ## packet-sink.h: static ns3::TypeId ns3::PacketSink::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -73,7 +75,6 @@
                    'void', 
                    [], 
                    visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_functions(root_module):
--- a/bindings/python/ns3_module_point_to_point.py	Fri Aug 29 14:53:38 2008 +0100
+++ b/bindings/python/ns3_module_point_to_point.py	Fri Aug 29 14:56:24 2008 +0100
@@ -54,6 +54,8 @@
     return
 
 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)])
     ## point-to-point-channel.h: static ns3::TypeId ns3::PointToPointChannel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -84,10 +86,11 @@
                    'ns3::Ptr< ns3::NetDevice >', 
                    [param('uint32_t', 'i')], 
                    is_const=True, is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## point-to-point-net-device.h: static ns3::TypeId ns3::PointToPointNetDevice::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -228,15 +231,15 @@
                    'bool', 
                    [], 
                    is_const=True, is_virtual=True)
-    ## point-to-point-net-device.h: void ns3::PointToPointNetDevice::SetReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> cb) [member function]
+    ## point-to-point-net-device.h: void ns3::PointToPointNetDevice::SetReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> cb) [member function]
     cls.add_method('SetReceiveCallback', 
                    'void', 
-                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr<const ns3::Packet >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], 
+                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], 
                    is_virtual=True)
-    ## point-to-point-net-device.h: void ns3::PointToPointNetDevice::SetPromiscReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType> cb) [member function]
+    ## point-to-point-net-device.h: void ns3::PointToPointNetDevice::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', 
                    'void', 
-                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr<const ns3::Packet >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'cb')], 
+                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'cb')], 
                    is_virtual=True)
     ## point-to-point-net-device.h: bool ns3::PointToPointNetDevice::SupportsPromiscuous() const [member function]
     cls.add_method('SupportsPromiscuous', 
@@ -248,7 +251,6 @@
                    'void', 
                    [], 
                    visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_functions(root_module):
--- a/bindings/python/ns3_module_simulator.py	Fri Aug 29 14:53:38 2008 +0100
+++ b/bindings/python/ns3_module_simulator.py	Fri Aug 29 14:56:24 2008 +0100
@@ -19,10 +19,14 @@
     module.add_class('Watchdog')
     ## simulator.h: ns3::Simulator [class]
     module.add_class('Simulator', is_singleton=True)
+    ## event-impl.h: ns3::EventLock [class]
+    module.add_class('EventLock', allow_subclassing=True)
     ## event-id.h: ns3::EventId [class]
     module.add_class('EventId')
     ## event-impl.h: ns3::EventImpl [class]
     module.add_class('EventImpl', allow_subclassing=True)
+    ## realtime-simulator-impl.h: ns3::RealtimeEventLock [class]
+    module.add_class('RealtimeEventLock', parent=root_module['ns3::EventLock'])
     ## high-precision-128.h: ns3::HighPrecision [class]
     module.add_class('HighPrecision')
     ## nstime.h: ns3::TimeChecker [class]
@@ -35,14 +39,22 @@
     module.add_class('TimeValue', parent=root_module['ns3::AttributeValue'])
     ## simulator-impl.h: ns3::SimulatorImpl [class]
     module.add_class('SimulatorImpl', parent=root_module['ns3::Object'])
+    ## realtime-simulator-impl.h: ns3::RealtimeSimulatorImpl [class]
+    module.add_class('RealtimeSimulatorImpl', parent=root_module['ns3::SimulatorImpl'])
+    ## realtime-simulator-impl.h: ns3::RealtimeSimulatorImpl::SynchronizationMode [enumeration]
+    module.add_enum('SynchronizationMode', ['SYNC_BEST_EFFORT', 'SYNC_HARD_LIMIT'], outer_class=root_module['ns3::RealtimeSimulatorImpl'])
     ## default-simulator-impl.h: ns3::DefaultSimulatorImpl [class]
     module.add_class('DefaultSimulatorImpl', parent=root_module['ns3::SimulatorImpl'])
+    ## synchronizer.h: ns3::Synchronizer [class]
+    module.add_class('Synchronizer', parent=root_module['ns3::Object'])
     ## heap-scheduler.h: ns3::HeapScheduler [class]
     module.add_class('HeapScheduler', parent=root_module['ns3::Scheduler'])
     ## list-scheduler.h: ns3::ListScheduler [class]
     module.add_class('ListScheduler', parent=root_module['ns3::Scheduler'])
     ## map-scheduler.h: ns3::MapScheduler [class]
     module.add_class('MapScheduler', parent=root_module['ns3::Scheduler'])
+    ## wall-clock-synchronizer.h: ns3::WallClockSynchronizer [class]
+    module.add_class('WallClockSynchronizer', parent=root_module['ns3::Synchronizer'])
     
     ## Register a nested module for the namespace internal
     
@@ -93,21 +105,28 @@
     register_Ns3Scalar_methods(root_module, root_module['ns3::Scalar'])
     register_Ns3Watchdog_methods(root_module, root_module['ns3::Watchdog'])
     register_Ns3Simulator_methods(root_module, root_module['ns3::Simulator'])
+    register_Ns3EventLock_methods(root_module, root_module['ns3::EventLock'])
     register_Ns3EventId_methods(root_module, root_module['ns3::EventId'])
     register_Ns3EventImpl_methods(root_module, root_module['ns3::EventImpl'])
+    register_Ns3RealtimeEventLock_methods(root_module, root_module['ns3::RealtimeEventLock'])
     register_Ns3HighPrecision_methods(root_module, root_module['ns3::HighPrecision'])
     register_Ns3TimeChecker_methods(root_module, root_module['ns3::TimeChecker'])
     register_Ns3Scheduler_methods(root_module, root_module['ns3::Scheduler'])
     register_Ns3SchedulerEventKey_methods(root_module, root_module['ns3::Scheduler::EventKey'])
     register_Ns3TimeValue_methods(root_module, root_module['ns3::TimeValue'])
     register_Ns3SimulatorImpl_methods(root_module, root_module['ns3::SimulatorImpl'])
+    register_Ns3RealtimeSimulatorImpl_methods(root_module, root_module['ns3::RealtimeSimulatorImpl'])
     register_Ns3DefaultSimulatorImpl_methods(root_module, root_module['ns3::DefaultSimulatorImpl'])
+    register_Ns3Synchronizer_methods(root_module, root_module['ns3::Synchronizer'])
     register_Ns3HeapScheduler_methods(root_module, root_module['ns3::HeapScheduler'])
     register_Ns3ListScheduler_methods(root_module, root_module['ns3::ListScheduler'])
     register_Ns3MapScheduler_methods(root_module, root_module['ns3::MapScheduler'])
+    register_Ns3WallClockSynchronizer_methods(root_module, root_module['ns3::WallClockSynchronizer'])
     return
 
 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)])
     ## timer.h: ns3::Timer::Timer() [constructor]
     cls.add_constructor([])
     ## timer.h: ns3::Timer::Timer(ns3::Timer::DestroyPolicy destroyPolicy) [constructor]
@@ -170,10 +189,13 @@
     cls.add_method('Resume', 
                    'void', 
                    [])
-    cls.add_copy_constructor()
     return
 
 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)])
+    ## 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', 
@@ -184,8 +206,6 @@
                    'void', 
                    [], 
                    is_pure_virtual=True, is_virtual=True)
-    cls.add_constructor([])
-    cls.add_copy_constructor()
     return
 
 def register_Ns3Time_methods(root_module, cls):
@@ -325,16 +345,19 @@
     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)])
     ## watchdog.h: ns3::Watchdog::Watchdog() [constructor]
     cls.add_constructor([])
     ## watchdog.h: void ns3::Watchdog::Ping(ns3::Time delay) [member function]
     cls.add_method('Ping', 
                    'void', 
                    [param('ns3::Time', 'delay')])
-    cls.add_copy_constructor()
     return
 
 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)])
     ## simulator.h: static void ns3::Simulator::SetImplementation(ns3::Ptr<ns3::SimulatorImpl> impl) [member function]
     cls.add_method('SetImplementation', 
                    'void', 
@@ -415,7 +438,23 @@
                    'ns3::Time', 
                    [], 
                    is_static=True)
-    cls.add_copy_constructor()
+    return
+
+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)])
+    ## event-impl.h: ns3::EventLock::EventLock() [constructor]
+    cls.add_constructor([])
+    ## event-impl.h: void ns3::EventLock::Lock() [member function]
+    cls.add_method('Lock', 
+                   'void', 
+                   [], 
+                   is_pure_virtual=True, is_virtual=True)
+    ## event-impl.h: void ns3::EventLock::Unlock() [member function]
+    cls.add_method('Unlock', 
+                   'void', 
+                   [], 
+                   is_pure_virtual=True, is_virtual=True)
     return
 
 def register_Ns3EventId_methods(root_module, cls):
@@ -457,6 +496,8 @@
     return
 
 def register_Ns3EventImpl_methods(root_module, cls):
+    ## event-impl.h: ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::EventImpl&', 'arg0', is_const=True)])
     ## event-impl.h: ns3::EventImpl::EventImpl() [constructor]
     cls.add_constructor([])
     ## event-impl.h: void ns3::EventImpl::Ref() const [member function]
@@ -481,12 +522,38 @@
     cls.add_method('IsCancelled', 
                    'bool', 
                    [])
+    ## event-impl.h: static void ns3::EventImpl::SetEventLock(ns3::EventLock * eventLock) [member function]
+    cls.add_method('SetEventLock', 
+                   'void', 
+                   [param('ns3::EventLock *', 'eventLock')], 
+                   is_static=True)
+    ## event-impl.h: static void ns3::EventImpl::SetNoEventLock() [member function]
+    cls.add_method('SetNoEventLock', 
+                   'void', 
+                   [], 
+                   is_static=True)
     ## event-impl.h: void ns3::EventImpl::Notify() [member function]
     cls.add_method('Notify', 
                    'void', 
                    [], 
                    is_pure_virtual=True, visibility='protected', is_virtual=True)
-    cls.add_copy_constructor()
+    return
+
+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)])
+    ## realtime-simulator-impl.h: ns3::RealtimeEventLock::RealtimeEventLock() [constructor]
+    cls.add_constructor([])
+    ## realtime-simulator-impl.h: void ns3::RealtimeEventLock::Lock() [member function]
+    cls.add_method('Lock', 
+                   'void', 
+                   [], 
+                   is_virtual=True)
+    ## realtime-simulator-impl.h: void ns3::RealtimeEventLock::Unlock() [member function]
+    cls.add_method('Unlock', 
+                   'void', 
+                   [], 
+                   is_virtual=True)
     return
 
 def register_Ns3HighPrecision_methods(root_module, cls):
@@ -542,11 +609,17 @@
     return
 
 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)])
+    ## nstime.h: ns3::TimeChecker::TimeChecker() [constructor]
     cls.add_constructor([])
-    cls.add_copy_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)])
+    ## scheduler.h: ns3::Scheduler::Scheduler() [constructor]
+    cls.add_constructor([])
     ## scheduler.h: static ns3::TypeId ns3::Scheduler::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -577,8 +650,6 @@
                    'bool', 
                    [param('ns3::EventId&', 'id', is_const=True)], 
                    is_pure_virtual=True, is_virtual=True)
-    cls.add_constructor([])
-    cls.add_copy_constructor()
     return
 
 def register_Ns3SchedulerEventKey_methods(root_module, cls):
@@ -586,11 +657,15 @@
     cls.add_instance_attribute('m_ts', 'uint64_t', is_const=False)
     ## 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)])
+    ## scheduler.h: ns3::Scheduler::EventKey::EventKey() [constructor]
     cls.add_constructor([])
-    cls.add_copy_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)])
     ## nstime.h: ns3::TimeValue::TimeValue() [constructor]
     cls.add_constructor([])
     ## nstime.h: ns3::TimeValue::TimeValue(ns3::Time const & value) [constructor]
@@ -619,10 +694,13 @@
                    'bool', 
                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
+    ## simulator-impl.h: ns3::SimulatorImpl::SimulatorImpl() [constructor]
+    cls.add_constructor([])
     ## simulator-impl.h: void ns3::SimulatorImpl::Destroy() [member function]
     cls.add_method('Destroy', 
                    'void', 
@@ -713,11 +791,131 @@
                    'ns3::Ptr< ns3::Scheduler >', 
                    [], 
                    is_pure_virtual=True, is_const=True, is_virtual=True)
+    return
+
+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)])
+    ## realtime-simulator-impl.h: static ns3::TypeId ns3::RealtimeSimulatorImpl::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## realtime-simulator-impl.h: ns3::RealtimeSimulatorImpl::RealtimeSimulatorImpl() [constructor]
     cls.add_constructor([])
-    cls.add_copy_constructor()
+    ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::Destroy() [member function]
+    cls.add_method('Destroy', 
+                   'void', 
+                   [], 
+                   is_virtual=True)
+    ## realtime-simulator-impl.h: bool ns3::RealtimeSimulatorImpl::IsFinished() const [member function]
+    cls.add_method('IsFinished', 
+                   'bool', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## realtime-simulator-impl.h: ns3::Time ns3::RealtimeSimulatorImpl::Next() const [member function]
+    cls.add_method('Next', 
+                   'ns3::Time', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::Stop() [member function]
+    cls.add_method('Stop', 
+                   'void', 
+                   [], 
+                   is_virtual=True)
+    ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::Stop(ns3::Time const & time) [member function]
+    cls.add_method('Stop', 
+                   'void', 
+                   [param('ns3::Time&', 'time', is_const=True)], 
+                   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)], 
+                   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)], 
+                   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)], 
+                   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)], 
+                   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)], 
+                   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)], 
+                   is_const=True, is_virtual=True)
+    ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::RunOneEvent() [member function]
+    cls.add_method('RunOneEvent', 
+                   'void', 
+                   [], 
+                   is_virtual=True)
+    ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::Run() [member function]
+    cls.add_method('Run', 
+                   'void', 
+                   [], 
+                   is_virtual=True)
+    ## realtime-simulator-impl.h: ns3::Time ns3::RealtimeSimulatorImpl::Now() const [member function]
+    cls.add_method('Now', 
+                   'ns3::Time', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## realtime-simulator-impl.h: ns3::Time ns3::RealtimeSimulatorImpl::GetDelayLeft(ns3::EventId const & id) const [member function]
+    cls.add_method('GetDelayLeft', 
+                   'ns3::Time', 
+                   [param('ns3::EventId&', 'id', is_const=True)], 
+                   is_const=True, is_virtual=True)
+    ## realtime-simulator-impl.h: ns3::Time ns3::RealtimeSimulatorImpl::GetMaximumSimulationTime() const [member function]
+    cls.add_method('GetMaximumSimulationTime', 
+                   'ns3::Time', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::SetScheduler(ns3::Ptr<ns3::Scheduler> scheduler) [member function]
+    cls.add_method('SetScheduler', 
+                   'void', 
+                   [param('ns3::Ptr< ns3::Scheduler >', 'scheduler')], 
+                   is_virtual=True)
+    ## realtime-simulator-impl.h: ns3::Ptr<ns3::Scheduler> ns3::RealtimeSimulatorImpl::GetScheduler() const [member function]
+    cls.add_method('GetScheduler', 
+                   'ns3::Ptr< ns3::Scheduler >', 
+                   [], 
+                   is_const=True, is_virtual=True)
+    ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::SetSynchronizationMode(ns3::RealtimeSimulatorImpl::SynchronizationMode mode) [member function]
+    cls.add_method('SetSynchronizationMode', 
+                   'void', 
+                   [param('ns3::RealtimeSimulatorImpl::SynchronizationMode', 'mode')])
+    ## realtime-simulator-impl.h: ns3::RealtimeSimulatorImpl::SynchronizationMode ns3::RealtimeSimulatorImpl::GetSynchronizationMode() const [member function]
+    cls.add_method('GetSynchronizationMode', 
+                   'ns3::RealtimeSimulatorImpl::SynchronizationMode', 
+                   [], 
+                   is_const=True)
+    ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::SetHardLimit(ns3::Time limit) [member function]
+    cls.add_method('SetHardLimit', 
+                   'void', 
+                   [param('ns3::Time', 'limit')])
+    ## realtime-simulator-impl.h: ns3::Time ns3::RealtimeSimulatorImpl::GetHardLimit() const [member function]
+    cls.add_method('GetHardLimit', 
+                   'ns3::Time', 
+                   [], 
+                   is_const=True)
     return
 
 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)])
     ## default-simulator-impl.h: static ns3::TypeId ns3::DefaultSimulatorImpl::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -815,10 +1013,108 @@
                    'ns3::Ptr< ns3::Scheduler >', 
                    [], 
                    is_const=True, is_virtual=True)
-    cls.add_copy_constructor()
+    return
+
+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)])
+    ## synchronizer.h: static ns3::TypeId ns3::Synchronizer::GetTypeId() [member function]
+    cls.add_method('GetTypeId', 
+                   'ns3::TypeId', 
+                   [], 
+                   is_static=True)
+    ## synchronizer.h: ns3::Synchronizer::Synchronizer() [constructor]
+    cls.add_constructor([])
+    ## synchronizer.h: bool ns3::Synchronizer::Realtime() [member function]
+    cls.add_method('Realtime', 
+                   'bool', 
+                   [])
+    ## synchronizer.h: uint64_t ns3::Synchronizer::GetCurrentRealtime() [member function]
+    cls.add_method('GetCurrentRealtime', 
+                   'uint64_t', 
+                   [])
+    ## synchronizer.h: void ns3::Synchronizer::SetOrigin(uint64_t ts) [member function]
+    cls.add_method('SetOrigin', 
+                   'void', 
+                   [param('uint64_t', 'ts')])
+    ## synchronizer.h: uint64_t ns3::Synchronizer::GetOrigin() [member function]
+    cls.add_method('GetOrigin', 
+                   'uint64_t', 
+                   [])
+    ## synchronizer.h: int64_t ns3::Synchronizer::GetDrift(uint64_t ts) [member function]
+    cls.add_method('GetDrift', 
+                   'int64_t', 
+                   [param('uint64_t', 'ts')])
+    ## synchronizer.h: bool ns3::Synchronizer::Synchronize(uint64_t tsCurrent, uint64_t tsDelay) [member function]
+    cls.add_method('Synchronize', 
+                   'bool', 
+                   [param('uint64_t', 'tsCurrent'), param('uint64_t', 'tsDelay')])
+    ## synchronizer.h: void ns3::Synchronizer::Signal() [member function]
+    cls.add_method('Signal', 
+                   'void', 
+                   [])
+    ## synchronizer.h: void ns3::Synchronizer::SetCondition(bool arg0) [member function]
+    cls.add_method('SetCondition', 
+                   'void', 
+                   [param('bool', 'arg0')])
+    ## synchronizer.h: void ns3::Synchronizer::EventStart() [member function]
+    cls.add_method('EventStart', 
+                   'void', 
+                   [])
+    ## synchronizer.h: uint64_t ns3::Synchronizer::EventEnd() [member function]
+    cls.add_method('EventEnd', 
+                   'uint64_t', 
+                   [])
+    ## synchronizer.h: void ns3::Synchronizer::DoSetOrigin(uint64_t ns) [member function]
+    cls.add_method('DoSetOrigin', 
+                   'void', 
+                   [param('uint64_t', 'ns')], 
+                   is_pure_virtual=True, visibility='protected', is_virtual=True)
+    ## synchronizer.h: bool ns3::Synchronizer::DoRealtime() [member function]
+    cls.add_method('DoRealtime', 
+                   'bool', 
+                   [], 
+                   is_pure_virtual=True, visibility='protected', is_virtual=True)
+    ## synchronizer.h: uint64_t ns3::Synchronizer::DoGetCurrentRealtime() [member function]
+    cls.add_method('DoGetCurrentRealtime', 
+                   'uint64_t', 
+                   [], 
+                   is_pure_virtual=True, visibility='protected', is_virtual=True)
+    ## synchronizer.h: bool ns3::Synchronizer::DoSynchronize(uint64_t nsCurrent, uint64_t nsDelay) [member function]
+    cls.add_method('DoSynchronize', 
+                   'bool', 
+                   [param('uint64_t', 'nsCurrent'), param('uint64_t', 'nsDelay')], 
+                   is_pure_virtual=True, visibility='protected', is_virtual=True)
+    ## synchronizer.h: void ns3::Synchronizer::DoSignal() [member function]
+    cls.add_method('DoSignal', 
+                   'void', 
+                   [], 
+                   is_pure_virtual=True, visibility='protected', is_virtual=True)
+    ## synchronizer.h: void ns3::Synchronizer::DoSetCondition(bool arg0) [member function]
+    cls.add_method('DoSetCondition', 
+                   'void', 
+                   [param('bool', 'arg0')], 
+                   is_pure_virtual=True, visibility='protected', is_virtual=True)
+    ## synchronizer.h: int64_t ns3::Synchronizer::DoGetDrift(uint64_t ns) [member function]
+    cls.add_method('DoGetDrift', 
+                   'int64_t', 
+                   [param('uint64_t', 'ns')], 
+                   is_pure_virtual=True, visibility='protected', is_virtual=True)
+    ## synchronizer.h: void ns3::Synchronizer::DoEventStart() [member function]
+    cls.add_method('DoEventStart', 
+                   'void', 
+                   [], 
+                   is_pure_virtual=True, visibility='protected', is_virtual=True)
+    ## synchronizer.h: uint64_t ns3::Synchronizer::DoEventEnd() [member function]
+    cls.add_method('DoEventEnd', 
+                   'uint64_t', 
+                   [], 
+                   is_pure_virtual=True, visibility='protected', is_virtual=True)
     return
 
 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)])
     ## heap-scheduler.h: ns3::HeapScheduler::HeapScheduler() [constructor]
     cls.add_constructor([])
     ## heap-scheduler.h: void ns3::HeapScheduler::Insert(ns3::EventId const & id) [member function]
@@ -846,10 +1142,11 @@
                    'bool', 
                    [param('ns3::EventId&', 'ev', is_const=True)], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     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)])
     ## list-scheduler.h: ns3::ListScheduler::ListScheduler() [constructor]
     cls.add_constructor([])
     ## list-scheduler.h: void ns3::ListScheduler::Insert(ns3::EventId const & id) [member function]
@@ -877,10 +1174,11 @@
                    'bool', 
                    [param('ns3::EventId&', 'ev', is_const=True)], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     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)])
     ## map-scheduler.h: ns3::MapScheduler::MapScheduler() [constructor]
     cls.add_constructor([])
     ## map-scheduler.h: void ns3::MapScheduler::Insert(ns3::EventId const & id) [member function]
@@ -908,7 +1206,119 @@
                    'bool', 
                    [param('ns3::EventId&', 'ev', is_const=True)], 
                    is_virtual=True)
-    cls.add_copy_constructor()
+    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)
+    ## 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)
+    ## 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)
+    ## wall-clock-synchronizer.h: ns3::WallClockSynchronizer::WallClockSynchronizer(ns3::WallClockSynchronizer const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::WallClockSynchronizer&', 'arg0', is_const=True)])
+    ## wall-clock-synchronizer.h: ns3::WallClockSynchronizer::WallClockSynchronizer() [constructor]
+    cls.add_constructor([])
+    ## wall-clock-synchronizer.h: bool ns3::WallClockSynchronizer::DoRealtime() [member function]
+    cls.add_method('DoRealtime', 
+                   'bool', 
+                   [], 
+                   visibility='protected', is_virtual=True)
+    ## wall-clock-synchronizer.h: uint64_t ns3::WallClockSynchronizer::DoGetCurrentRealtime() [member function]
+    cls.add_method('DoGetCurrentRealtime', 
+                   'uint64_t', 
+                   [], 
+                   visibility='protected', is_virtual=True)
+    ## wall-clock-synchronizer.h: void ns3::WallClockSynchronizer::DoSetOrigin(uint64_t ns) [member function]
+    cls.add_method('DoSetOrigin', 
+                   'void', 
+                   [param('uint64_t', 'ns')], 
+                   visibility='protected', is_virtual=True)
+    ## wall-clock-synchronizer.h: int64_t ns3::WallClockSynchronizer::DoGetDrift(uint64_t ns) [member function]
+    cls.add_method('DoGetDrift', 
+                   'int64_t', 
+                   [param('uint64_t', 'ns')], 
+                   visibility='protected', is_virtual=True)
+    ## wall-clock-synchronizer.h: bool ns3::WallClockSynchronizer::DoSynchronize(uint64_t nsCurrent, uint64_t nsDelay) [member function]
+    cls.add_method('DoSynchronize', 
+                   'bool', 
+                   [param('uint64_t', 'nsCurrent'), param('uint64_t', 'nsDelay')], 
+                   visibility='protected', is_virtual=True)
+    ## wall-clock-synchronizer.h: void ns3::WallClockSynchronizer::DoSignal() [member function]
+    cls.add_method('DoSignal', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
+    ## wall-clock-synchronizer.h: void ns3::WallClockSynchronizer::DoSetCondition(bool cond) [member function]
+    cls.add_method('DoSetCondition', 
+                   'void', 
+                   [param('bool', 'cond')], 
+                   visibility='protected', is_virtual=True)
+    ## wall-clock-synchronizer.h: void ns3::WallClockSynchronizer::DoEventStart() [member function]
+    cls.add_method('DoEventStart', 
+                   'void', 
+                   [], 
+                   visibility='protected', is_virtual=True)
+    ## wall-clock-synchronizer.h: uint64_t ns3::WallClockSynchronizer::DoEventEnd() [member function]
+    cls.add_method('DoEventEnd', 
+                   'uint64_t', 
+                   [], 
+                   visibility='protected', is_virtual=True)
+    ## wall-clock-synchronizer.h: bool ns3::WallClockSynchronizer::SpinWait(uint64_t arg0) [member function]
+    cls.add_method('SpinWait', 
+                   'bool', 
+                   [param('uint64_t', 'arg0')], 
+                   visibility='protected')
+    ## wall-clock-synchronizer.h: bool ns3::WallClockSynchronizer::SleepWait(uint64_t arg0) [member function]
+    cls.add_method('SleepWait', 
+                   'bool', 
+                   [param('uint64_t', 'arg0')], 
+                   visibility='protected')
+    ## wall-clock-synchronizer.h: uint64_t ns3::WallClockSynchronizer::DriftCorrect(uint64_t nsNow, uint64_t nsDelay) [member function]
+    cls.add_method('DriftCorrect', 
+                   'uint64_t', 
+                   [param('uint64_t', 'nsNow'), param('uint64_t', 'nsDelay')], 
+                   visibility='protected')
+    ## wall-clock-synchronizer.h: uint64_t ns3::WallClockSynchronizer::GetRealtime() [member function]
+    cls.add_method('GetRealtime', 
+                   'uint64_t', 
+                   [], 
+                   visibility='protected')
+    ## wall-clock-synchronizer.h: uint64_t ns3::WallClockSynchronizer::GetNormalizedRealtime() [member function]
+    cls.add_method('GetNormalizedRealtime', 
+                   'uint64_t', 
+                   [], 
+                   visibility='protected')
+    ## wall-clock-synchronizer.h: void ns3::WallClockSynchronizer::NsToTimespec(int64_t ns, timespec * ts) [member function]
+    cls.add_method('NsToTimespec', 
+                   'void', 
+                   [param('int64_t', 'ns'), param('timespec *', 'ts')], 
+                   visibility='protected')
+    ## wall-clock-synchronizer.h: void ns3::WallClockSynchronizer::NsToTimeval(int64_t ns, timeval * tv) [member function]
+    cls.add_method('NsToTimeval', 
+                   'void', 
+                   [param('int64_t', 'ns'), param('timeval *', 'tv')], 
+                   visibility='protected')
+    ## wall-clock-synchronizer.h: uint64_t ns3::WallClockSynchronizer::TimespecToNs(timespec * ts) [member function]
+    cls.add_method('TimespecToNs', 
+                   'uint64_t', 
+                   [param('timespec *', 'ts')], 
+                   visibility='protected')
+    ## wall-clock-synchronizer.h: uint64_t ns3::WallClockSynchronizer::TimevalToNs(timeval * tv) [member function]
+    cls.add_method('TimevalToNs', 
+                   'uint64_t', 
+                   [param('timeval *', 'tv')], 
+                   visibility='protected')
+    ## wall-clock-synchronizer.h: void ns3::WallClockSynchronizer::TimespecAdd(timespec * ts1, timespec * ts2, timespec * result) [member function]
+    cls.add_method('TimespecAdd', 
+                   'void', 
+                   [param('timespec *', 'ts1'), param('timespec *', 'ts2'), param('timespec *', 'result')], 
+                   visibility='protected')
+    ## wall-clock-synchronizer.h: void ns3::WallClockSynchronizer::TimevalAdd(timeval * tv1, timeval * tv2, timeval * result) [member function]
+    cls.add_method('TimevalAdd', 
+                   'void', 
+                   [param('timeval *', 'tv1'), param('timeval *', 'tv2'), param('timeval *', 'result')], 
+                   visibility='protected')
     return
 
 def register_functions(root_module):
--- a/bindings/python/ns3_module_udp_echo.py	Fri Aug 29 14:53:38 2008 +0100
+++ b/bindings/python/ns3_module_udp_echo.py	Fri Aug 29 14:56:24 2008 +0100
@@ -54,6 +54,8 @@
     return
 
 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)])
     ## udp-echo-client.h: static ns3::TypeId ns3::UdpEchoClient::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -80,10 +82,11 @@
                    'void', 
                    [], 
                    visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## udp-echo-server.h: static ns3::TypeId ns3::UdpEchoServer::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -106,7 +109,6 @@
                    'void', 
                    [], 
                    visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_functions(root_module):
--- a/bindings/python/ns3_module_wifi.py	Fri Aug 29 14:53:38 2008 +0100
+++ b/bindings/python/ns3_module_wifi.py	Fri Aug 29 14:56:24 2008 +0100
@@ -182,6 +182,8 @@
     return
 
 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)])
     ## wifi-remote-station-manager.h: static ns3::TypeId ns3::WifiRemoteStation::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -371,10 +373,13 @@
                    'ns3::WifiMode', 
                    [], 
                    is_pure_virtual=True, visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
+    ## wifi-phy.h: ns3::WifiPhyListener::WifiPhyListener() [constructor]
+    cls.add_constructor([])
     ## wifi-phy.h: void ns3::WifiPhyListener::NotifyRxStart(ns3::Time duration) [member function]
     cls.add_method('NotifyRxStart', 
                    'void', 
@@ -400,8 +405,6 @@
                    'void', 
                    [param('ns3::Time', 'duration')], 
                    is_pure_virtual=True, is_virtual=True)
-    cls.add_constructor([])
-    cls.add_copy_constructor()
     return
 
 def register_Ns3ThresholdsItem_methods(root_module, cls):
@@ -413,8 +416,10 @@
     cls.add_instance_attribute('pmtl', 'double', is_const=False)
     ## 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)])
+    ## rraa-wifi-manager.h: ns3::ThresholdsItem::ThresholdsItem() [constructor]
     cls.add_constructor([])
-    cls.add_copy_constructor()
     return
 
 def register_Ns3SupportedRates_methods(root_module, cls):
@@ -468,6 +473,8 @@
     return
 
 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)])
     ## 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]
@@ -520,15 +527,18 @@
                    'ns3::WifiMode', 
                    [], 
                    visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
+    ## wifi-mode.h: ns3::WifiModeChecker::WifiModeChecker() [constructor]
     cls.add_constructor([])
-    cls.add_copy_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)])
     ## 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', 
@@ -539,10 +549,11 @@
                    'ns3::WifiMode', 
                    [param('std::string', 'uniqueName'), param('bool', 'isMandatory'), param('uint32_t', 'bandwidth'), param('uint32_t', 'dataRate'), param('uint32_t', 'phyRate'), param('uint8_t', 'constellationSize')], 
                    is_static=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## 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]
@@ -595,10 +606,11 @@
                    'ns3::WifiMode', 
                    [], 
                    visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## 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]
@@ -656,7 +668,6 @@
                    'ns3::WifiMode', 
                    [], 
                    visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_Ns3Ssid_methods(root_module, cls):
@@ -764,6 +775,8 @@
     return
 
 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)])
     ## ssid.h: ns3::SsidValue::SsidValue() [constructor]
     cls.add_constructor([])
     ## ssid.h: ns3::SsidValue::SsidValue(ns3::Ssid const & value) [constructor]
@@ -792,15 +805,18 @@
                    'bool', 
                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
+    ## ssid.h: ns3::SsidChecker::SsidChecker() [constructor]
     cls.add_constructor([])
-    cls.add_copy_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)])
     ## 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]
@@ -853,10 +869,13 @@
                    'ns3::WifiMode', 
                    [], 
                    visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
+    ## propagation-loss-model.h: ns3::PropagationLossModel::PropagationLossModel() [constructor]
+    cls.add_constructor([])
     ## propagation-loss-model.h: static ns3::TypeId ns3::PropagationLossModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -867,11 +886,11 @@
                    'double', 
                    [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
                    is_pure_virtual=True, is_const=True, is_virtual=True)
-    cls.add_constructor([])
-    cls.add_copy_constructor()
     return
 
 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)])
     ## 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]
@@ -964,10 +983,13 @@
                    'void', 
                    [], 
                    visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
+    ## wifi-mac.h: ns3::WifiMac::WifiMac() [constructor]
+    cls.add_constructor([])
     ## wifi-mac.h: static ns3::TypeId ns3::WifiMac::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1104,8 +1126,6 @@
                    'void', 
                    [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'linkDown')], 
                    is_pure_virtual=True, visibility='private', is_virtual=True)
-    cls.add_constructor([])
-    cls.add_copy_constructor()
     return
 
 def register_Ns3NqapWifiMac_methods(root_module, cls):
@@ -1222,6 +1242,8 @@
     return
 
 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)])
     ## composite-propagation-loss-model.h: static ns3::TypeId ns3::CompositePropagationLossModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1243,10 +1265,11 @@
                    'void', 
                    [], 
                    visibility='protected', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## 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]
@@ -1299,10 +1322,11 @@
                    'ns3::WifiMode', 
                    [], 
                    visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## propagation-loss-model.h: static ns3::TypeId ns3::FriisPropagationLossModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1346,7 +1370,6 @@
                    'double', 
                    [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
                    is_const=True, is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_Ns3NqstaWifiMac_methods(root_module, cls):
@@ -1466,6 +1489,8 @@
     return
 
 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)])
     ## wifi-remote-station-manager.h: static ns3::TypeId ns3::WifiRemoteStationManager::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1539,12 +1564,12 @@
                    is_const=True)
     ## wifi-remote-station-manager.h: __gnu_cxx::__normal_iterator<const ns3::WifiMode*,std::vector<ns3::WifiMode, std::allocator<ns3::WifiMode> > > ns3::WifiRemoteStationManager::BeginBasicModes() const [member function]
     cls.add_method('BeginBasicModes', 
-                   '__gnu_cxx::__normal_iterator< const ns3::WifiMode*, std::vector< ns3::WifiMode, std::allocator< ns3::WifiMode > > >', 
+                   '__gnu_cxx::__normal_iterator< const ns3::WifiMode*, std::vector< ns3::WifiMode > >', 
                    [], 
                    is_const=True)
     ## wifi-remote-station-manager.h: __gnu_cxx::__normal_iterator<const ns3::WifiMode*,std::vector<ns3::WifiMode, std::allocator<ns3::WifiMode> > > ns3::WifiRemoteStationManager::EndBasicModes() const [member function]
     cls.add_method('EndBasicModes', 
-                   '__gnu_cxx::__normal_iterator< const ns3::WifiMode*, std::vector< ns3::WifiMode, std::allocator< ns3::WifiMode > > >', 
+                   '__gnu_cxx::__normal_iterator< const ns3::WifiMode*, std::vector< ns3::WifiMode > >', 
                    [], 
                    is_const=True)
     ## wifi-remote-station-manager.h: bool ns3::WifiRemoteStationManager::IsLowLatency() const [member function]
@@ -1570,10 +1595,11 @@
                    'ns3::WifiRemoteStation *', 
                    [], 
                    is_pure_virtual=True, visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## wifi-mode.h: ns3::WifiModeValue::WifiModeValue() [constructor]
     cls.add_constructor([])
     ## wifi-mode.h: ns3::WifiModeValue::WifiModeValue(ns3::WifiMode const & value) [constructor]
@@ -1602,10 +1628,11 @@
                    'bool', 
                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
                    is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## onoe-wifi-manager.h: static ns3::TypeId ns3::OnoeWifiManager::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1618,7 +1645,6 @@
                    'ns3::WifiRemoteStation *', 
                    [], 
                    visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_Ns3WifiPhy_methods(root_module, cls):
@@ -1786,6 +1812,8 @@
     return
 
 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)])
     ## wifi-channel.h: static ns3::TypeId ns3::WifiChannel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1820,10 +1848,11 @@
                    'void', 
                    [param('ns3::Ptr< ns3::WifiPhy >', 'sender'), param('ns3::Ptr< const ns3::Packet >', 'packet'), param('double', 'txPowerDbm'), param('ns3::WifiMode', 'wifiMode'), param('ns3::WifiPreamble', 'preamble')], 
                    is_const=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## propagation-loss-model.h: static ns3::TypeId ns3::LogDistancePropagationLossModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1853,10 +1882,11 @@
                    'double', 
                    [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
                    is_const=True, is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## constant-rate-wifi-manager.h: static ns3::TypeId ns3::ConstantRateWifiManager::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1879,10 +1909,11 @@
                    'ns3::WifiRemoteStation *', 
                    [], 
                    visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## 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]
@@ -1895,10 +1926,13 @@
                    'void', 
                    [], 
                    visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
+    ## propagation-delay-model.h: ns3::PropagationDelayModel::PropagationDelayModel() [constructor]
+    cls.add_constructor([])
     ## propagation-delay-model.h: static ns3::TypeId ns3::PropagationDelayModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -1909,8 +1943,6 @@
                    'ns3::Time', 
                    [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
                    is_pure_virtual=True, is_const=True, is_virtual=True)
-    cls.add_constructor([])
-    cls.add_copy_constructor()
     return
 
 def register_Ns3AdhocWifiMac_methods(root_module, cls):
@@ -2014,6 +2046,8 @@
     return
 
 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)])
     ## jakes-propagation-loss-model.h: static ns3::TypeId ns3::JakesPropagationLossModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2034,10 +2068,11 @@
     cls.add_method('SetNOscillators', 
                    'void', 
                    [param('uint8_t', 'nOscillators')])
-    cls.add_copy_constructor()
     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)])
     ## wifi-net-device.h: static ns3::TypeId ns3::WifiNetDevice::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2176,20 +2211,20 @@
                    'bool', 
                    [], 
                    is_const=True, is_virtual=True)
-    ## wifi-net-device.h: void ns3::WifiNetDevice::SetReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> cb) [member function]
+    ## wifi-net-device.h: void ns3::WifiNetDevice::SetReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> cb) [member function]
     cls.add_method('SetReceiveCallback', 
                    'void', 
-                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr<const ns3::Packet >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], 
+                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], 
                    is_virtual=True)
     ## 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')], 
                    is_virtual=True)
-    ## wifi-net-device.h: void ns3::WifiNetDevice::SetPromiscReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType> cb) [member function]
+    ## 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', 
                    'void', 
-                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr<const ns3::Packet >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'cb')], 
+                   [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'cb')], 
                    is_virtual=True)
     ## wifi-net-device.h: bool ns3::WifiNetDevice::SupportsPromiscuous() const [member function]
     cls.add_method('SupportsPromiscuous', 
@@ -2201,10 +2236,11 @@
                    'void', 
                    [], 
                    visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     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', 
@@ -2226,10 +2262,11 @@
                    'double', 
                    [], 
                    is_const=True)
-    cls.add_copy_constructor()
     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)])
     ## propagation-loss-model.h: static ns3::TypeId ns3::RandomPropagationLossModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2242,10 +2279,11 @@
                    'double', 
                    [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
                    is_const=True, is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_Ns3RandomPropagationDelayModel_methods(root_module, cls):
+    ## propagation-delay-model.h: ns3::RandomPropagationDelayModel::RandomPropagationDelayModel(ns3::RandomPropagationDelayModel const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::RandomPropagationDelayModel&', 'arg0', is_const=True)])
     ## propagation-delay-model.h: static ns3::TypeId ns3::RandomPropagationDelayModel::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2258,10 +2296,11 @@
                    'ns3::Time', 
                    [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
                    is_const=True, is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## amrr-wifi-manager.h: static ns3::TypeId ns3::AmrrWifiManager::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2274,10 +2313,11 @@
                    'ns3::WifiRemoteStation *', 
                    [], 
                    visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## rraa-wifi-manager.h: static ns3::TypeId ns3::RraaWifiManager::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2304,10 +2344,11 @@
                    'ns3::WifiRemoteStation *', 
                    [], 
                    visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## ideal-wifi-manager.h: static ns3::TypeId ns3::IdealWifiManager::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2334,10 +2375,11 @@
                    'ns3::WifiRemoteStation *', 
                    [], 
                    visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## arf-wifi-manager.h: static ns3::TypeId ns3::ArfWifiManager::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2350,10 +2392,11 @@
                    'ns3::WifiRemoteStation *', 
                    [], 
                    visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 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)])
     ## aarf-wifi-manager.h: static ns3::TypeId ns3::AarfWifiManager::GetTypeId() [member function]
     cls.add_method('GetTypeId', 
                    'ns3::TypeId', 
@@ -2366,7 +2409,6 @@
                    'ns3::WifiRemoteStation *', 
                    [], 
                    visibility='private', is_virtual=True)
-    cls.add_copy_constructor()
     return
 
 def register_functions(root_module):
--- a/bindings/python/ns3modulegen_generated.py	Fri Aug 29 14:53:38 2008 +0100
+++ b/bindings/python/ns3modulegen_generated.py	Fri Aug 29 14:56:24 2008 +0100
@@ -224,8 +224,6 @@
         ns3_module_helper__local.register_types(module)
     
     root_module.end_section('ns3_module_helper')
-    module.add_container('std::vector< unsigned int, std::allocator< unsigned int > >', 'unsigned int')
-    module.add_container('std::list< unsigned int, std::allocator< unsigned int > >', 'unsigned int')
     
     ## Register a nested module for the namespace internal
     
--- a/bindings/python/wscript	Fri Aug 29 14:53:38 2008 +0100
+++ b/bindings/python/wscript	Fri Aug 29 14:56:24 2008 +0100
@@ -21,7 +21,7 @@
     os.environ['PYTHONPATH'] = LOCAL_PYBINDGEN_PATH
 
 ## https://launchpad.net/pybindgen/
-REQUIRED_PYBINDGEN_VERSION = (0, 9, 0, 564)
+REQUIRED_PYBINDGEN_VERSION = (0, 9, 0, 570)
 REQUIRED_PYGCCXML_VERSION = (0, 9, 5)