bindings/python/ns3_module_node.py
changeset 3544 3685ab98e4b2
parent 3539 427638d49248
child 3552 b822851cb95d
equal deleted inserted replaced
3543:04315a10b9c1 3544:3685ab98e4b2
   216     cls.add_method('GetNNodes', 
   216     cls.add_method('GetNNodes', 
   217                    'uint32_t', 
   217                    'uint32_t', 
   218                    [], 
   218                    [], 
   219                    is_static=True)
   219                    is_static=True)
   220     cls.add_constructor([])
   220     cls.add_constructor([])
       
   221     cls.add_copy_constructor()
   221     return
   222     return
   222 
   223 
   223 def register_Ns3Address_methods(root_module, cls):
   224 def register_Ns3Address_methods(root_module, cls):
   224     ## address.h: ns3::Address::Address() [constructor]
   225     ## address.h: ns3::Address::Address() [constructor]
   225     cls.add_constructor([])
   226     cls.add_constructor([])
   287     cls.add_output_stream_operator()
   288     cls.add_output_stream_operator()
   288     return
   289     return
   289 
   290 
   290 def register_Ns3Ipv4AddressChecker_methods(root_module, cls):
   291 def register_Ns3Ipv4AddressChecker_methods(root_module, cls):
   291     cls.add_constructor([])
   292     cls.add_constructor([])
       
   293     cls.add_copy_constructor()
   292     return
   294     return
   293 
   295 
   294 def register_Ns3Mac48Address_methods(root_module, cls):
   296 def register_Ns3Mac48Address_methods(root_module, cls):
   295     ## mac48-address.h: ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [copy constructor]
   297     ## mac48-address.h: ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [copy constructor]
   296     cls.add_constructor([param('ns3::Mac48Address&', 'arg0', is_const=True)])
   298     cls.add_constructor([param('ns3::Mac48Address&', 'arg0', is_const=True)])
   419     cls.add_method('TestMode', 
   421     cls.add_method('TestMode', 
   420                    'void', 
   422                    'void', 
   421                    [], 
   423                    [], 
   422                    is_static=True)
   424                    is_static=True)
   423     cls.add_constructor([])
   425     cls.add_constructor([])
       
   426     cls.add_copy_constructor()
   424     return
   427     return
   425 
   428 
   426 def register_Ns3Mac48AddressChecker_methods(root_module, cls):
   429 def register_Ns3Mac48AddressChecker_methods(root_module, cls):
   427     cls.add_constructor([])
   430     cls.add_constructor([])
       
   431     cls.add_copy_constructor()
   428     return
   432     return
   429 
   433 
   430 def register_Ns3Ipv4MaskChecker_methods(root_module, cls):
   434 def register_Ns3Ipv4MaskChecker_methods(root_module, cls):
   431     cls.add_constructor([])
   435     cls.add_constructor([])
       
   436     cls.add_copy_constructor()
   432     return
   437     return
   433 
   438 
   434 def register_Ns3Ipv4Route_methods(root_module, cls):
   439 def register_Ns3Ipv4Route_methods(root_module, cls):
   435     ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route() [constructor]
   440     ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route() [constructor]
   436     cls.add_constructor([])
   441     cls.add_constructor([])
   556     cls.add_output_stream_operator()
   561     cls.add_output_stream_operator()
   557     return
   562     return
   558 
   563 
   559 def register_Ns3AddressChecker_methods(root_module, cls):
   564 def register_Ns3AddressChecker_methods(root_module, cls):
   560     cls.add_constructor([])
   565     cls.add_constructor([])
       
   566     cls.add_copy_constructor()
   561     return
   567     return
   562 
   568 
   563 def register_Ns3PacketSocketAddress_methods(root_module, cls):
   569 def register_Ns3PacketSocketAddress_methods(root_module, cls):
   564     ## packet-socket-address.h: ns3::PacketSocketAddress::PacketSocketAddress() [constructor]
   570     ## packet-socket-address.h: ns3::PacketSocketAddress::PacketSocketAddress() [constructor]
   565     cls.add_constructor([])
   571     cls.add_constructor([])
   607     ## packet-socket-address.h: static bool ns3::PacketSocketAddress::IsMatchingType(ns3::Address const & address) [member function]
   613     ## packet-socket-address.h: static bool ns3::PacketSocketAddress::IsMatchingType(ns3::Address const & address) [member function]
   608     cls.add_method('IsMatchingType', 
   614     cls.add_method('IsMatchingType', 
   609                    'bool', 
   615                    'bool', 
   610                    [param('ns3::Address&', 'address', is_const=True)], 
   616                    [param('ns3::Address&', 'address', is_const=True)], 
   611                    is_static=True)
   617                    is_static=True)
       
   618     cls.add_copy_constructor()
   612     return
   619     return
   613 
   620 
   614 def register_Ns3Ipv4Mask_methods(root_module, cls):
   621 def register_Ns3Ipv4Mask_methods(root_module, cls):
   615     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [copy constructor]
   622     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [copy constructor]
   616     cls.add_constructor([param('ns3::Ipv4Mask&', 'arg0', is_const=True)])
   623     cls.add_constructor([param('ns3::Ipv4Mask&', 'arg0', is_const=True)])
   689     ## ipv4-address.h: bool ns3::Ipv4AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   696     ## ipv4-address.h: bool ns3::Ipv4AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   690     cls.add_method('DeserializeFromString', 
   697     cls.add_method('DeserializeFromString', 
   691                    'bool', 
   698                    'bool', 
   692                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
   699                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
   693                    is_virtual=True)
   700                    is_virtual=True)
       
   701     cls.add_copy_constructor()
   694     return
   702     return
   695 
   703 
   696 def register_Ns3Ipv4RoutingProtocol_methods(root_module, cls):
   704 def register_Ns3Ipv4RoutingProtocol_methods(root_module, cls):
   697     ## ipv4.h: ns3::Ipv4RoutingProtocol::IF_INDEX_ANY [variable]
   705     ## ipv4.h: ns3::Ipv4RoutingProtocol::IF_INDEX_ANY [variable]
   698     cls.add_static_attribute('IF_INDEX_ANY', retval('uint32_t', is_const=True), is_const=True)
   706     cls.add_static_attribute('IF_INDEX_ANY', retval('uint32_t', is_const=True), is_const=True)
   705     cls.add_method('RequestIfIndex', 
   713     cls.add_method('RequestIfIndex', 
   706                    'bool', 
   714                    'bool', 
   707                    [param('ns3::Ipv4Address', 'destination'), param('uint32_t&', 'ifIndex')], 
   715                    [param('ns3::Ipv4Address', 'destination'), param('uint32_t&', 'ifIndex')], 
   708                    is_pure_virtual=True, is_virtual=True)
   716                    is_pure_virtual=True, is_virtual=True)
   709     cls.add_constructor([])
   717     cls.add_constructor([])
       
   718     cls.add_copy_constructor()
   710     return
   719     return
   711 
   720 
   712 def register_Ns3Mac48AddressValue_methods(root_module, cls):
   721 def register_Ns3Mac48AddressValue_methods(root_module, cls):
   713     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue() [constructor]
   722     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue() [constructor]
   714     cls.add_constructor([])
   723     cls.add_constructor([])
   736     ## mac48-address.h: bool ns3::Mac48AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   745     ## mac48-address.h: bool ns3::Mac48AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   737     cls.add_method('DeserializeFromString', 
   746     cls.add_method('DeserializeFromString', 
   738                    'bool', 
   747                    'bool', 
   739                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
   748                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
   740                    is_virtual=True)
   749                    is_virtual=True)
       
   750     cls.add_copy_constructor()
   741     return
   751     return
   742 
   752 
   743 def register_Ns3Ipv4MaskValue_methods(root_module, cls):
   753 def register_Ns3Ipv4MaskValue_methods(root_module, cls):
   744     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue() [constructor]
   754     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue() [constructor]
   745     cls.add_constructor([])
   755     cls.add_constructor([])
   767     ## ipv4-address.h: bool ns3::Ipv4MaskValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   777     ## ipv4-address.h: bool ns3::Ipv4MaskValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   768     cls.add_method('DeserializeFromString', 
   778     cls.add_method('DeserializeFromString', 
   769                    'bool', 
   779                    'bool', 
   770                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
   780                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
   771                    is_virtual=True)
   781                    is_virtual=True)
       
   782     cls.add_copy_constructor()
   772     return
   783     return
   773 
   784 
   774 def register_Ns3SocketAddressTag_methods(root_module, cls):
   785 def register_Ns3SocketAddressTag_methods(root_module, cls):
   775     ## socket.h: ns3::SocketAddressTag::SocketAddressTag() [constructor]
   786     ## socket.h: ns3::SocketAddressTag::SocketAddressTag() [constructor]
   776     cls.add_constructor([])
   787     cls.add_constructor([])
   811     ## socket.h: void ns3::SocketAddressTag::Print(std::ostream & os) const [member function]
   822     ## socket.h: void ns3::SocketAddressTag::Print(std::ostream & os) const [member function]
   812     cls.add_method('Print', 
   823     cls.add_method('Print', 
   813                    'void', 
   824                    'void', 
   814                    [param('std::ostream&', 'os')], 
   825                    [param('std::ostream&', 'os')], 
   815                    is_const=True, is_virtual=True)
   826                    is_const=True, is_virtual=True)
       
   827     cls.add_copy_constructor()
   816     return
   828     return
   817 
   829 
   818 def register_Ns3InetSocketAddress_methods(root_module, cls):
   830 def register_Ns3InetSocketAddress_methods(root_module, cls):
   819     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(ns3::Ipv4Address ipv4, uint16_t port) [constructor]
   831     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(ns3::Ipv4Address ipv4, uint16_t port) [constructor]
   820     cls.add_constructor([param('ns3::Ipv4Address', 'ipv4'), param('uint16_t', 'port')])
   832     cls.add_constructor([param('ns3::Ipv4Address', 'ipv4'), param('uint16_t', 'port')])
   852     ## inet-socket-address.h: static ns3::InetSocketAddress ns3::InetSocketAddress::ConvertFrom(ns3::Address const & address) [member function]
   864     ## inet-socket-address.h: static ns3::InetSocketAddress ns3::InetSocketAddress::ConvertFrom(ns3::Address const & address) [member function]
   853     cls.add_method('ConvertFrom', 
   865     cls.add_method('ConvertFrom', 
   854                    'ns3::InetSocketAddress', 
   866                    'ns3::InetSocketAddress', 
   855                    [param('ns3::Address&', 'address', is_const=True)], 
   867                    [param('ns3::Address&', 'address', is_const=True)], 
   856                    is_static=True)
   868                    is_static=True)
       
   869     cls.add_copy_constructor()
   857     return
   870     return
   858 
   871 
   859 def register_Ns3Ipv4Address_methods(root_module, cls):
   872 def register_Ns3Ipv4Address_methods(root_module, cls):
   860     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [copy constructor]
   873     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [copy constructor]
   861     cls.add_constructor([param('ns3::Ipv4Address&', 'arg0', is_const=True)])
   874     cls.add_constructor([param('ns3::Ipv4Address&', 'arg0', is_const=True)])
  1002     ## application.h: void ns3::Application::StopApplication() [member function]
  1015     ## application.h: void ns3::Application::StopApplication() [member function]
  1003     cls.add_method('StopApplication', 
  1016     cls.add_method('StopApplication', 
  1004                    'void', 
  1017                    'void', 
  1005                    [], 
  1018                    [], 
  1006                    visibility='private', is_virtual=True)
  1019                    visibility='private', is_virtual=True)
       
  1020     cls.add_copy_constructor()
  1007     return
  1021     return
  1008 
  1022 
  1009 def register_Ns3Queue_methods(root_module, cls):
  1023 def register_Ns3Queue_methods(root_module, cls):
  1010     ## queue.h: static ns3::TypeId ns3::Queue::GetTypeId() [member function]
  1024     ## queue.h: static ns3::TypeId ns3::Queue::GetTypeId() [member function]
  1011     cls.add_method('GetTypeId', 
  1025     cls.add_method('GetTypeId', 
  1088     ## queue.h: ns3::Ptr<const ns3::Packet> ns3::Queue::DoPeek() const [member function]
  1102     ## queue.h: ns3::Ptr<const ns3::Packet> ns3::Queue::DoPeek() const [member function]
  1089     cls.add_method('DoPeek', 
  1103     cls.add_method('DoPeek', 
  1090                    'ns3::Ptr< const ns3::Packet >', 
  1104                    'ns3::Ptr< const ns3::Packet >', 
  1091                    [], 
  1105                    [], 
  1092                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1106                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1107     cls.add_copy_constructor()
  1093     return
  1108     return
  1094 
  1109 
  1095 def register_Ns3Socket_methods(root_module, cls):
  1110 def register_Ns3Socket_methods(root_module, cls):
  1096     ## socket.h: ns3::Socket::Socket() [constructor]
  1111     ## socket.h: ns3::Socket::Socket() [constructor]
  1097     cls.add_constructor([])
  1112     cls.add_constructor([])
  1256     ## socket.h: void ns3::Socket::NotifyDataRecv() [member function]
  1271     ## socket.h: void ns3::Socket::NotifyDataRecv() [member function]
  1257     cls.add_method('NotifyDataRecv', 
  1272     cls.add_method('NotifyDataRecv', 
  1258                    'void', 
  1273                    'void', 
  1259                    [], 
  1274                    [], 
  1260                    visibility='protected')
  1275                    visibility='protected')
       
  1276     cls.add_copy_constructor()
  1261     return
  1277     return
  1262 
  1278 
  1263 def register_Ns3Ipv4Header_methods(root_module, cls):
  1279 def register_Ns3Ipv4Header_methods(root_module, cls):
  1264     ## ipv4-header.h: ns3::Ipv4Header::Ipv4Header() [constructor]
  1280     ## ipv4-header.h: ns3::Ipv4Header::Ipv4Header() [constructor]
  1265     cls.add_constructor([])
  1281     cls.add_constructor([])
  1398     ## ipv4-header.h: uint32_t ns3::Ipv4Header::Deserialize(ns3::Buffer::Iterator start) [member function]
  1414     ## ipv4-header.h: uint32_t ns3::Ipv4Header::Deserialize(ns3::Buffer::Iterator start) [member function]
  1399     cls.add_method('Deserialize', 
  1415     cls.add_method('Deserialize', 
  1400                    'uint32_t', 
  1416                    'uint32_t', 
  1401                    [param('ns3::Buffer::Iterator', 'start')], 
  1417                    [param('ns3::Buffer::Iterator', 'start')], 
  1402                    is_virtual=True)
  1418                    is_virtual=True)
       
  1419     cls.add_copy_constructor()
  1403     return
  1420     return
  1404 
  1421 
  1405 def register_Ns3UdpSocket_methods(root_module, cls):
  1422 def register_Ns3UdpSocket_methods(root_module, cls):
  1406     ## udp-socket.h: static ns3::TypeId ns3::UdpSocket::GetTypeId() [member function]
  1423     ## udp-socket.h: static ns3::TypeId ns3::UdpSocket::GetTypeId() [member function]
  1407     cls.add_method('GetTypeId', 
  1424     cls.add_method('GetTypeId', 
  1438     ## udp-socket.h: uint32_t ns3::UdpSocket::GetIpMulticastTtl() const [member function]
  1455     ## udp-socket.h: uint32_t ns3::UdpSocket::GetIpMulticastTtl() const [member function]
  1439     cls.add_method('GetIpMulticastTtl', 
  1456     cls.add_method('GetIpMulticastTtl', 
  1440                    'uint32_t', 
  1457                    'uint32_t', 
  1441                    [], 
  1458                    [], 
  1442                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1459                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1460     cls.add_copy_constructor()
  1443     return
  1461     return
  1444 
  1462 
  1445 def register_Ns3NetDevice_methods(root_module, cls):
  1463 def register_Ns3NetDevice_methods(root_module, cls):
  1446     ## net-device.h: static ns3::TypeId ns3::NetDevice::GetTypeId() [member function]
  1464     ## net-device.h: static ns3::TypeId ns3::NetDevice::GetTypeId() [member function]
  1447     cls.add_method('GetTypeId', 
  1465     cls.add_method('GetTypeId', 
  1567     cls.add_method('SupportsPromiscuous', 
  1585     cls.add_method('SupportsPromiscuous', 
  1568                    'bool', 
  1586                    'bool', 
  1569                    [], 
  1587                    [], 
  1570                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1588                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1571     cls.add_constructor([])
  1589     cls.add_constructor([])
       
  1590     cls.add_copy_constructor()
  1572     return
  1591     return
  1573 
  1592 
  1574 def register_Ns3DropTailQueue_methods(root_module, cls):
  1593 def register_Ns3DropTailQueue_methods(root_module, cls):
  1575     ## drop-tail-queue.h: static ns3::TypeId ns3::DropTailQueue::GetTypeId() [member function]
  1594     ## drop-tail-queue.h: static ns3::TypeId ns3::DropTailQueue::GetTypeId() [member function]
  1576     cls.add_method('GetTypeId', 
  1595     cls.add_method('GetTypeId', 
  1592     ## drop-tail-queue.h: ns3::Ptr<const ns3::Packet> ns3::DropTailQueue::DoPeek() const [member function]
  1611     ## drop-tail-queue.h: ns3::Ptr<const ns3::Packet> ns3::DropTailQueue::DoPeek() const [member function]
  1593     cls.add_method('DoPeek', 
  1612     cls.add_method('DoPeek', 
  1594                    'ns3::Ptr< const ns3::Packet >', 
  1613                    'ns3::Ptr< const ns3::Packet >', 
  1595                    [], 
  1614                    [], 
  1596                    is_const=True, visibility='private', is_virtual=True)
  1615                    is_const=True, visibility='private', is_virtual=True)
       
  1616     cls.add_copy_constructor()
  1597     return
  1617     return
  1598 
  1618 
  1599 def register_Ns3AddressValue_methods(root_module, cls):
  1619 def register_Ns3AddressValue_methods(root_module, cls):
  1600     ## address.h: ns3::AddressValue::AddressValue() [constructor]
  1620     ## address.h: ns3::AddressValue::AddressValue() [constructor]
  1601     cls.add_constructor([])
  1621     cls.add_constructor([])
  1623     ## address.h: bool ns3::AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1643     ## address.h: bool ns3::AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1624     cls.add_method('DeserializeFromString', 
  1644     cls.add_method('DeserializeFromString', 
  1625                    'bool', 
  1645                    'bool', 
  1626                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1646                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1627                    is_virtual=True)
  1647                    is_virtual=True)
       
  1648     cls.add_copy_constructor()
  1628     return
  1649     return
  1629 
  1650 
  1630 def register_Ns3Node_methods(root_module, cls):
  1651 def register_Ns3Node_methods(root_module, cls):
  1631     ## node.h: static ns3::TypeId ns3::Node::GetTypeId() [member function]
  1652     ## node.h: static ns3::TypeId ns3::Node::GetTypeId() [member function]
  1632     cls.add_method('GetTypeId', 
  1653     cls.add_method('GetTypeId', 
  1691     ## node.h: void ns3::Node::NotifyDeviceAdded(ns3::Ptr<ns3::NetDevice> device) [member function]
  1712     ## node.h: void ns3::Node::NotifyDeviceAdded(ns3::Ptr<ns3::NetDevice> device) [member function]
  1692     cls.add_method('NotifyDeviceAdded', 
  1713     cls.add_method('NotifyDeviceAdded', 
  1693                    'void', 
  1714                    'void', 
  1694                    [param('ns3::Ptr< ns3::NetDevice >', 'device')], 
  1715                    [param('ns3::Ptr< ns3::NetDevice >', 'device')], 
  1695                    visibility='private', is_virtual=True)
  1716                    visibility='private', is_virtual=True)
       
  1717     cls.add_copy_constructor()
  1696     return
  1718     return
  1697 
  1719 
  1698 def register_Ns3Channel_methods(root_module, cls):
  1720 def register_Ns3Channel_methods(root_module, cls):
  1699     ## channel.h: static ns3::TypeId ns3::Channel::GetTypeId() [member function]
  1721     ## channel.h: static ns3::TypeId ns3::Channel::GetTypeId() [member function]
  1700     cls.add_method('GetTypeId', 
  1722     cls.add_method('GetTypeId', 
  1721     ## channel.h: ns3::Ptr<ns3::NetDevice> ns3::Channel::GetDevice(uint32_t i) const [member function]
  1743     ## channel.h: ns3::Ptr<ns3::NetDevice> ns3::Channel::GetDevice(uint32_t i) const [member function]
  1722     cls.add_method('GetDevice', 
  1744     cls.add_method('GetDevice', 
  1723                    'ns3::Ptr< ns3::NetDevice >', 
  1745                    'ns3::Ptr< ns3::NetDevice >', 
  1724                    [param('uint32_t', 'i')], 
  1746                    [param('uint32_t', 'i')], 
  1725                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1747                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1748     cls.add_copy_constructor()
  1726     return
  1749     return
  1727 
  1750 
  1728 def register_Ns3TcpSocket_methods(root_module, cls):
  1751 def register_Ns3TcpSocket_methods(root_module, cls):
  1729     ## tcp-socket.h: static ns3::TypeId ns3::TcpSocket::GetTypeId() [member function]
  1752     ## tcp-socket.h: static ns3::TypeId ns3::TcpSocket::GetTypeId() [member function]
  1730     cls.add_method('GetTypeId', 
  1753     cls.add_method('GetTypeId', 
  1831     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetDelAckMaxCount() const [member function]
  1854     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetDelAckMaxCount() const [member function]
  1832     cls.add_method('GetDelAckMaxCount', 
  1855     cls.add_method('GetDelAckMaxCount', 
  1833                    'uint32_t', 
  1856                    'uint32_t', 
  1834                    [], 
  1857                    [], 
  1835                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1858                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1859     cls.add_copy_constructor()
  1836     return
  1860     return
  1837 
  1861 
  1838 def register_Ns3EthernetHeader_methods(root_module, cls):
  1862 def register_Ns3EthernetHeader_methods(root_module, cls):
  1839     ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader(bool hasPreamble) [constructor]
  1863     ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader(bool hasPreamble) [constructor]
  1840     cls.add_constructor([param('bool', 'hasPreamble')])
  1864     cls.add_constructor([param('bool', 'hasPreamble')])
  1914     ## ethernet-header.h: uint32_t ns3::EthernetHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
  1938     ## ethernet-header.h: uint32_t ns3::EthernetHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
  1915     cls.add_method('Deserialize', 
  1939     cls.add_method('Deserialize', 
  1916                    'uint32_t', 
  1940                    'uint32_t', 
  1917                    [param('ns3::Buffer::Iterator', 'start')], 
  1941                    [param('ns3::Buffer::Iterator', 'start')], 
  1918                    is_virtual=True)
  1942                    is_virtual=True)
       
  1943     cls.add_copy_constructor()
  1919     return
  1944     return
  1920 
  1945 
  1921 def register_Ns3SocketIpTtlTag_methods(root_module, cls):
  1946 def register_Ns3SocketIpTtlTag_methods(root_module, cls):
  1922     ## socket.h: ns3::SocketIpTtlTag::SocketIpTtlTag() [constructor]
  1947     ## socket.h: ns3::SocketIpTtlTag::SocketIpTtlTag() [constructor]
  1923     cls.add_constructor([])
  1948     cls.add_constructor([])
  1958     ## socket.h: void ns3::SocketIpTtlTag::Print(std::ostream & os) const [member function]
  1983     ## socket.h: void ns3::SocketIpTtlTag::Print(std::ostream & os) const [member function]
  1959     cls.add_method('Print', 
  1984     cls.add_method('Print', 
  1960                    'void', 
  1985                    'void', 
  1961                    [param('std::ostream&', 'os')], 
  1986                    [param('std::ostream&', 'os')], 
  1962                    is_const=True, is_virtual=True)
  1987                    is_const=True, is_virtual=True)
       
  1988     cls.add_copy_constructor()
  1963     return
  1989     return
  1964 
  1990 
  1965 def register_Ns3Ipv4_methods(root_module, cls):
  1991 def register_Ns3Ipv4_methods(root_module, cls):
  1966     ## ipv4.h: static ns3::TypeId ns3::Ipv4::GetTypeId() [member function]
  1992     ## ipv4.h: static ns3::TypeId ns3::Ipv4::GetTypeId() [member function]
  1967     cls.add_method('GetTypeId', 
  1993     cls.add_method('GetTypeId', 
  2148     ## ipv4.h: uint32_t ns3::Ipv4::GetIfIndexByAddress(ns3::Ipv4Address addr, ns3::Ipv4Mask mask=ns3::Ipv4Mask(((const char*)"255.255.255.255"))) [member function]
  2174     ## ipv4.h: uint32_t ns3::Ipv4::GetIfIndexByAddress(ns3::Ipv4Address addr, ns3::Ipv4Mask mask=ns3::Ipv4Mask(((const char*)"255.255.255.255"))) [member function]
  2149     cls.add_method('GetIfIndexByAddress', 
  2175     cls.add_method('GetIfIndexByAddress', 
  2150                    'uint32_t', 
  2176                    'uint32_t', 
  2151                    [param('ns3::Ipv4Address', 'addr'), param('ns3::Ipv4Mask', 'mask', default_value='ns3::Ipv4Mask(((const char*)"255.255.255.255"))')], 
  2177                    [param('ns3::Ipv4Address', 'addr'), param('ns3::Ipv4Mask', 'mask', default_value='ns3::Ipv4Mask(((const char*)"255.255.255.255"))')], 
  2152                    is_virtual=True)
  2178                    is_virtual=True)
       
  2179     cls.add_copy_constructor()
  2153     return
  2180     return
  2154 
  2181 
  2155 def register_Ns3SocketFactory_methods(root_module, cls):
  2182 def register_Ns3SocketFactory_methods(root_module, cls):
  2156     ## socket-factory.h: static ns3::TypeId ns3::SocketFactory::GetTypeId() [member function]
  2183     ## socket-factory.h: static ns3::TypeId ns3::SocketFactory::GetTypeId() [member function]
  2157     cls.add_method('GetTypeId', 
  2184     cls.add_method('GetTypeId', 
  2163     ## socket-factory.h: ns3::Ptr<ns3::Socket> ns3::SocketFactory::CreateSocket() [member function]
  2190     ## socket-factory.h: ns3::Ptr<ns3::Socket> ns3::SocketFactory::CreateSocket() [member function]
  2164     cls.add_method('CreateSocket', 
  2191     cls.add_method('CreateSocket', 
  2165                    'ns3::Ptr< ns3::Socket >', 
  2192                    'ns3::Ptr< ns3::Socket >', 
  2166                    [], 
  2193                    [], 
  2167                    is_pure_virtual=True, is_virtual=True)
  2194                    is_pure_virtual=True, is_virtual=True)
       
  2195     cls.add_copy_constructor()
  2168     return
  2196     return
  2169 
  2197 
  2170 def register_Ns3EthernetTrailer_methods(root_module, cls):
  2198 def register_Ns3EthernetTrailer_methods(root_module, cls):
  2171     ## ethernet-trailer.h: ns3::EthernetTrailer::EthernetTrailer() [constructor]
  2199     ## ethernet-trailer.h: ns3::EthernetTrailer::EthernetTrailer() [constructor]
  2172     cls.add_constructor([])
  2200     cls.add_constructor([])
  2225     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::Deserialize(ns3::Buffer::Iterator end) [member function]
  2253     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::Deserialize(ns3::Buffer::Iterator end) [member function]
  2226     cls.add_method('Deserialize', 
  2254     cls.add_method('Deserialize', 
  2227                    'uint32_t', 
  2255                    'uint32_t', 
  2228                    [param('ns3::Buffer::Iterator', 'end')], 
  2256                    [param('ns3::Buffer::Iterator', 'end')], 
  2229                    is_virtual=True)
  2257                    is_virtual=True)
       
  2258     cls.add_copy_constructor()
  2230     return
  2259     return
  2231 
  2260 
  2232 def register_Ns3SimpleChannel_methods(root_module, cls):
  2261 def register_Ns3SimpleChannel_methods(root_module, cls):
  2233     ## simple-channel.h: static ns3::TypeId ns3::SimpleChannel::GetTypeId() [member function]
  2262     ## simple-channel.h: static ns3::TypeId ns3::SimpleChannel::GetTypeId() [member function]
  2234     cls.add_method('GetTypeId', 
  2263     cls.add_method('GetTypeId', 
  2253     ## simple-channel.h: ns3::Ptr<ns3::NetDevice> ns3::SimpleChannel::GetDevice(uint32_t i) const [member function]
  2282     ## simple-channel.h: ns3::Ptr<ns3::NetDevice> ns3::SimpleChannel::GetDevice(uint32_t i) const [member function]
  2254     cls.add_method('GetDevice', 
  2283     cls.add_method('GetDevice', 
  2255                    'ns3::Ptr< ns3::NetDevice >', 
  2284                    'ns3::Ptr< ns3::NetDevice >', 
  2256                    [param('uint32_t', 'i')], 
  2285                    [param('uint32_t', 'i')], 
  2257                    is_const=True, is_virtual=True)
  2286                    is_const=True, is_virtual=True)
       
  2287     cls.add_copy_constructor()
  2258     return
  2288     return
  2259 
  2289 
  2260 def register_Ns3LlcSnapHeader_methods(root_module, cls):
  2290 def register_Ns3LlcSnapHeader_methods(root_module, cls):
  2261     ## llc-snap-header.h: ns3::LlcSnapHeader::LlcSnapHeader() [constructor]
  2291     ## llc-snap-header.h: ns3::LlcSnapHeader::LlcSnapHeader() [constructor]
  2262     cls.add_constructor([])
  2292     cls.add_constructor([])
  2296     ## llc-snap-header.h: uint32_t ns3::LlcSnapHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
  2326     ## llc-snap-header.h: uint32_t ns3::LlcSnapHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
  2297     cls.add_method('Deserialize', 
  2327     cls.add_method('Deserialize', 
  2298                    'uint32_t', 
  2328                    'uint32_t', 
  2299                    [param('ns3::Buffer::Iterator', 'start')], 
  2329                    [param('ns3::Buffer::Iterator', 'start')], 
  2300                    is_virtual=True)
  2330                    is_virtual=True)
       
  2331     cls.add_copy_constructor()
  2301     return
  2332     return
  2302 
  2333 
  2303 def register_Ns3UdpSocketFactory_methods(root_module, cls):
  2334 def register_Ns3UdpSocketFactory_methods(root_module, cls):
  2304     ## udp-socket-factory.h: static ns3::TypeId ns3::UdpSocketFactory::GetTypeId() [member function]
  2335     ## udp-socket-factory.h: static ns3::TypeId ns3::UdpSocketFactory::GetTypeId() [member function]
  2305     cls.add_method('GetTypeId', 
  2336     cls.add_method('GetTypeId', 
  2306                    'ns3::TypeId', 
  2337                    'ns3::TypeId', 
  2307                    [], 
  2338                    [], 
  2308                    is_static=True)
  2339                    is_static=True)
  2309     cls.add_constructor([])
  2340     cls.add_constructor([])
       
  2341     cls.add_copy_constructor()
  2310     return
  2342     return
  2311 
  2343 
  2312 def register_Ns3SimpleNetDevice_methods(root_module, cls):
  2344 def register_Ns3SimpleNetDevice_methods(root_module, cls):
  2313     ## simple-net-device.h: static ns3::TypeId ns3::SimpleNetDevice::GetTypeId() [member function]
  2345     ## simple-net-device.h: static ns3::TypeId ns3::SimpleNetDevice::GetTypeId() [member function]
  2314     cls.add_method('GetTypeId', 
  2346     cls.add_method('GetTypeId', 
  2452     ## simple-net-device.h: void ns3::SimpleNetDevice::DoDispose() [member function]
  2484     ## simple-net-device.h: void ns3::SimpleNetDevice::DoDispose() [member function]
  2453     cls.add_method('DoDispose', 
  2485     cls.add_method('DoDispose', 
  2454                    'void', 
  2486                    'void', 
  2455                    [], 
  2487                    [], 
  2456                    visibility='protected', is_virtual=True)
  2488                    visibility='protected', is_virtual=True)
       
  2489     cls.add_copy_constructor()
  2457     return
  2490     return
  2458 
  2491 
  2459 def register_Ns3TcpSocketFactory_methods(root_module, cls):
  2492 def register_Ns3TcpSocketFactory_methods(root_module, cls):
  2460     ## tcp-socket-factory.h: static ns3::TypeId ns3::TcpSocketFactory::GetTypeId() [member function]
  2493     ## tcp-socket-factory.h: static ns3::TypeId ns3::TcpSocketFactory::GetTypeId() [member function]
  2461     cls.add_method('GetTypeId', 
  2494     cls.add_method('GetTypeId', 
  2462                    'ns3::TypeId', 
  2495                    'ns3::TypeId', 
  2463                    [], 
  2496                    [], 
  2464                    is_static=True)
  2497                    is_static=True)
  2465     cls.add_constructor([])
  2498     cls.add_constructor([])
       
  2499     cls.add_copy_constructor()
  2466     return
  2500     return
  2467 
  2501 
  2468 def register_Ns3PacketSocketFactory_methods(root_module, cls):
  2502 def register_Ns3PacketSocketFactory_methods(root_module, cls):
  2469     ## packet-socket-factory.h: static ns3::TypeId ns3::PacketSocketFactory::GetTypeId() [member function]
  2503     ## packet-socket-factory.h: static ns3::TypeId ns3::PacketSocketFactory::GetTypeId() [member function]
  2470     cls.add_method('GetTypeId', 
  2504     cls.add_method('GetTypeId', 
  2476     ## packet-socket-factory.h: ns3::Ptr<ns3::Socket> ns3::PacketSocketFactory::CreateSocket() [member function]
  2510     ## packet-socket-factory.h: ns3::Ptr<ns3::Socket> ns3::PacketSocketFactory::CreateSocket() [member function]
  2477     cls.add_method('CreateSocket', 
  2511     cls.add_method('CreateSocket', 
  2478                    'ns3::Ptr< ns3::Socket >', 
  2512                    'ns3::Ptr< ns3::Socket >', 
  2479                    [], 
  2513                    [], 
  2480                    is_virtual=True)
  2514                    is_virtual=True)
       
  2515     cls.add_copy_constructor()
  2481     return
  2516     return
  2482 
  2517 
  2483 def register_functions(root_module):
  2518 def register_functions(root_module):
  2484     module = root_module
  2519     module = root_module
  2485     ## mac48-address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeMac48AddressChecker() [free function]
  2520     ## mac48-address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeMac48AddressChecker() [free function]