bindings/python/ns3_module_helper.py
changeset 3544 3685ab98e4b2
parent 3539 427638d49248
child 3567 728eb3f583b3
equal deleted inserted replaced
3543:04315a10b9c1 3544:3685ab98e4b2
   153     ## mobility-helper.h: static void ns3::MobilityHelper::EnableAsciiAll(std::ostream & os) [member function]
   153     ## mobility-helper.h: static void ns3::MobilityHelper::EnableAsciiAll(std::ostream & os) [member function]
   154     cls.add_method('EnableAsciiAll', 
   154     cls.add_method('EnableAsciiAll', 
   155                    'void', 
   155                    'void', 
   156                    [param('std::ostream&', 'os')], 
   156                    [param('std::ostream&', 'os')], 
   157                    is_static=True)
   157                    is_static=True)
       
   158     cls.add_copy_constructor()
   158     return
   159     return
   159 
   160 
   160 def register_Ns3InternetStackHelper_methods(root_module, cls):
   161 def register_Ns3InternetStackHelper_methods(root_module, cls):
   161     ## internet-stack-helper.h: void ns3::InternetStackHelper::Install(ns3::NodeContainer c) [member function]
   162     ## internet-stack-helper.h: void ns3::InternetStackHelper::Install(ns3::NodeContainer c) [member function]
   162     cls.add_method('Install', 
   163     cls.add_method('Install', 
   166     cls.add_method('EnablePcapAll', 
   167     cls.add_method('EnablePcapAll', 
   167                    'void', 
   168                    'void', 
   168                    [param('std::string', 'filename')], 
   169                    [param('std::string', 'filename')], 
   169                    is_static=True)
   170                    is_static=True)
   170     cls.add_constructor([])
   171     cls.add_constructor([])
       
   172     cls.add_copy_constructor()
   171     return
   173     return
   172 
   174 
   173 def register_Ns3NodeContainer_methods(root_module, cls):
   175 def register_Ns3NodeContainer_methods(root_module, cls):
   174     ## node-container.h: ns3::NodeContainer::NodeContainer() [constructor]
   176     ## node-container.h: ns3::NodeContainer::NodeContainer() [constructor]
   175     cls.add_constructor([])
   177     cls.add_constructor([])
   216     ## node-container.h: static ns3::NodeContainer ns3::NodeContainer::GetGlobal() [member function]
   218     ## node-container.h: static ns3::NodeContainer ns3::NodeContainer::GetGlobal() [member function]
   217     cls.add_method('GetGlobal', 
   219     cls.add_method('GetGlobal', 
   218                    'ns3::NodeContainer', 
   220                    'ns3::NodeContainer', 
   219                    [], 
   221                    [], 
   220                    is_static=True)
   222                    is_static=True)
       
   223     cls.add_copy_constructor()
   221     return
   224     return
   222 
   225 
   223 def register_Ns3PointToPointHelper_methods(root_module, cls):
   226 def register_Ns3PointToPointHelper_methods(root_module, cls):
   224     ## point-to-point-helper.h: ns3::PointToPointHelper::PointToPointHelper() [constructor]
   227     ## point-to-point-helper.h: ns3::PointToPointHelper::PointToPointHelper() [constructor]
   225     cls.add_constructor([])
   228     cls.add_constructor([])
   291                    [param('ns3::NodeContainer', 'c')])
   294                    [param('ns3::NodeContainer', 'c')])
   292     ## point-to-point-helper.h: ns3::NetDeviceContainer ns3::PointToPointHelper::Install(ns3::Ptr<ns3::Node> a, ns3::Ptr<ns3::Node> b) [member function]
   295     ## point-to-point-helper.h: ns3::NetDeviceContainer ns3::PointToPointHelper::Install(ns3::Ptr<ns3::Node> a, ns3::Ptr<ns3::Node> b) [member function]
   293     cls.add_method('Install', 
   296     cls.add_method('Install', 
   294                    'ns3::NetDeviceContainer', 
   297                    'ns3::NetDeviceContainer', 
   295                    [param('ns3::Ptr< ns3::Node >', 'a'), param('ns3::Ptr< ns3::Node >', 'b')])
   298                    [param('ns3::Ptr< ns3::Node >', 'a'), param('ns3::Ptr< ns3::Node >', 'b')])
       
   299     cls.add_copy_constructor()
   296     return
   300     return
   297 
   301 
   298 def register_Ns3NetDeviceContainer_methods(root_module, cls):
   302 def register_Ns3NetDeviceContainer_methods(root_module, cls):
   299     ## 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]
   303     ## 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]
   300     cls.add_method('Begin', 
   304     cls.add_method('Begin', 
   323     ## net-device-container.h: void ns3::NetDeviceContainer::Add(ns3::Ptr<ns3::NetDevice> device) [member function]
   327     ## net-device-container.h: void ns3::NetDeviceContainer::Add(ns3::Ptr<ns3::NetDevice> device) [member function]
   324     cls.add_method('Add', 
   328     cls.add_method('Add', 
   325                    'void', 
   329                    'void', 
   326                    [param('ns3::Ptr< ns3::NetDevice >', 'device')])
   330                    [param('ns3::Ptr< ns3::NetDevice >', 'device')])
   327     cls.add_constructor([])
   331     cls.add_constructor([])
       
   332     cls.add_copy_constructor()
   328     return
   333     return
   329 
   334 
   330 def register_Ns3CsmaHelper_methods(root_module, cls):
   335 def register_Ns3CsmaHelper_methods(root_module, cls):
   331     ## csma-helper.h: ns3::CsmaHelper::CsmaHelper() [constructor]
   336     ## csma-helper.h: ns3::CsmaHelper::CsmaHelper() [constructor]
   332     cls.add_constructor([])
   337     cls.add_constructor([])
   398                    [param('ns3::NodeContainer&', 'c', is_const=True)])
   403                    [param('ns3::NodeContainer&', 'c', is_const=True)])
   399     ## csma-helper.h: ns3::NetDeviceContainer ns3::CsmaHelper::Install(ns3::NodeContainer const & c, ns3::Ptr<ns3::CsmaChannel> channel) [member function]
   404     ## csma-helper.h: ns3::NetDeviceContainer ns3::CsmaHelper::Install(ns3::NodeContainer const & c, ns3::Ptr<ns3::CsmaChannel> channel) [member function]
   400     cls.add_method('Install', 
   405     cls.add_method('Install', 
   401                    'ns3::NetDeviceContainer', 
   406                    'ns3::NetDeviceContainer', 
   402                    [param('ns3::NodeContainer&', 'c', is_const=True), param('ns3::Ptr< ns3::CsmaChannel >', 'channel')])
   407                    [param('ns3::NodeContainer&', 'c', is_const=True), param('ns3::Ptr< ns3::CsmaChannel >', 'channel')])
       
   408     cls.add_copy_constructor()
   403     return
   409     return
   404 
   410 
   405 def register_Ns3UdpEchoServerHelper_methods(root_module, cls):
   411 def register_Ns3UdpEchoServerHelper_methods(root_module, cls):
   406     ## udp-echo-helper.h: ns3::UdpEchoServerHelper::UdpEchoServerHelper(uint16_t port) [constructor]
   412     ## udp-echo-helper.h: ns3::UdpEchoServerHelper::UdpEchoServerHelper(uint16_t port) [constructor]
   407     cls.add_constructor([param('uint16_t', 'port')])
   413     cls.add_constructor([param('uint16_t', 'port')])
   411                    [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
   417                    [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
   412     ## udp-echo-helper.h: ns3::ApplicationContainer ns3::UdpEchoServerHelper::Install(ns3::NodeContainer c) [member function]
   418     ## udp-echo-helper.h: ns3::ApplicationContainer ns3::UdpEchoServerHelper::Install(ns3::NodeContainer c) [member function]
   413     cls.add_method('Install', 
   419     cls.add_method('Install', 
   414                    'ns3::ApplicationContainer', 
   420                    'ns3::ApplicationContainer', 
   415                    [param('ns3::NodeContainer', 'c')])
   421                    [param('ns3::NodeContainer', 'c')])
       
   422     cls.add_copy_constructor()
   416     return
   423     return
   417 
   424 
   418 def register_Ns3OlsrHelper_methods(root_module, cls):
   425 def register_Ns3OlsrHelper_methods(root_module, cls):
   419     ## olsr-helper.h: ns3::OlsrHelper::OlsrHelper() [constructor]
   426     ## olsr-helper.h: ns3::OlsrHelper::OlsrHelper() [constructor]
   420     cls.add_constructor([])
   427     cls.add_constructor([])
   432                    [param('ns3::Ptr< ns3::Node >', 'node')])
   439                    [param('ns3::Ptr< ns3::Node >', 'node')])
   433     ## olsr-helper.h: void ns3::OlsrHelper::InstallAll() [member function]
   440     ## olsr-helper.h: void ns3::OlsrHelper::InstallAll() [member function]
   434     cls.add_method('InstallAll', 
   441     cls.add_method('InstallAll', 
   435                    'void', 
   442                    'void', 
   436                    [])
   443                    [])
       
   444     cls.add_copy_constructor()
   437     return
   445     return
   438 
   446 
   439 def register_Ns3PacketSocketHelper_methods(root_module, cls):
   447 def register_Ns3PacketSocketHelper_methods(root_module, cls):
   440     ## packet-socket-helper.h: void ns3::PacketSocketHelper::Install(ns3::NodeContainer c) [member function]
   448     ## packet-socket-helper.h: void ns3::PacketSocketHelper::Install(ns3::NodeContainer c) [member function]
   441     cls.add_method('Install', 
   449     cls.add_method('Install', 
   442                    'void', 
   450                    'void', 
   443                    [param('ns3::NodeContainer', 'c')])
   451                    [param('ns3::NodeContainer', 'c')])
   444     cls.add_constructor([])
   452     cls.add_constructor([])
       
   453     cls.add_copy_constructor()
   445     return
   454     return
   446 
   455 
   447 def register_Ns3OnOffHelper_methods(root_module, cls):
   456 def register_Ns3OnOffHelper_methods(root_module, cls):
   448     ## on-off-helper.h: ns3::OnOffHelper::OnOffHelper(std::string protocol, ns3::Address address) [constructor]
   457     ## on-off-helper.h: ns3::OnOffHelper::OnOffHelper(std::string protocol, ns3::Address address) [constructor]
   449     cls.add_constructor([param('std::string', 'protocol'), param('ns3::Address', 'address')])
   458     cls.add_constructor([param('std::string', 'protocol'), param('ns3::Address', 'address')])
   453                    [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
   462                    [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
   454     ## on-off-helper.h: ns3::ApplicationContainer ns3::OnOffHelper::Install(ns3::NodeContainer c) [member function]
   463     ## on-off-helper.h: ns3::ApplicationContainer ns3::OnOffHelper::Install(ns3::NodeContainer c) [member function]
   455     cls.add_method('Install', 
   464     cls.add_method('Install', 
   456                    'ns3::ApplicationContainer', 
   465                    'ns3::ApplicationContainer', 
   457                    [param('ns3::NodeContainer', 'c')])
   466                    [param('ns3::NodeContainer', 'c')])
       
   467     cls.add_copy_constructor()
   458     return
   468     return
   459 
   469 
   460 def register_Ns3UdpEchoClientHelper_methods(root_module, cls):
   470 def register_Ns3UdpEchoClientHelper_methods(root_module, cls):
   461     ## udp-echo-helper.h: ns3::UdpEchoClientHelper::UdpEchoClientHelper(ns3::Ipv4Address ip, uint16_t port) [constructor]
   471     ## udp-echo-helper.h: ns3::UdpEchoClientHelper::UdpEchoClientHelper(ns3::Ipv4Address ip, uint16_t port) [constructor]
   462     cls.add_constructor([param('ns3::Ipv4Address', 'ip'), param('uint16_t', 'port')])
   472     cls.add_constructor([param('ns3::Ipv4Address', 'ip'), param('uint16_t', 'port')])
   466                    [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
   476                    [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
   467     ## udp-echo-helper.h: ns3::ApplicationContainer ns3::UdpEchoClientHelper::Install(ns3::NodeContainer c) [member function]
   477     ## udp-echo-helper.h: ns3::ApplicationContainer ns3::UdpEchoClientHelper::Install(ns3::NodeContainer c) [member function]
   468     cls.add_method('Install', 
   478     cls.add_method('Install', 
   469                    'ns3::ApplicationContainer', 
   479                    'ns3::ApplicationContainer', 
   470                    [param('ns3::NodeContainer', 'c')])
   480                    [param('ns3::NodeContainer', 'c')])
       
   481     cls.add_copy_constructor()
   471     return
   482     return
   472 
   483 
   473 def register_Ns3StaticMulticastRouteHelper_methods(root_module, cls):
   484 def register_Ns3StaticMulticastRouteHelper_methods(root_module, cls):
   474     ## static-multicast-route-helper.h: ns3::StaticMulticastRouteHelper::StaticMulticastRouteHelper() [constructor]
   485     ## static-multicast-route-helper.h: ns3::StaticMulticastRouteHelper::StaticMulticastRouteHelper() [constructor]
   475     cls.add_constructor([])
   486     cls.add_constructor([])
   483                    [param('ns3::Ptr< ns3::Node >', 'n'), param('ns3::Ptr< ns3::NetDevice >', 'nd')])
   494                    [param('ns3::Ptr< ns3::Node >', 'n'), param('ns3::Ptr< ns3::NetDevice >', 'nd')])
   484     ## static-multicast-route-helper.h: void ns3::StaticMulticastRouteHelper::JoinMulticastGroup(ns3::Ptr<ns3::Node> n, ns3::Ipv4Address source, ns3::Ipv4Address group) [member function]
   495     ## static-multicast-route-helper.h: void ns3::StaticMulticastRouteHelper::JoinMulticastGroup(ns3::Ptr<ns3::Node> n, ns3::Ipv4Address source, ns3::Ipv4Address group) [member function]
   485     cls.add_method('JoinMulticastGroup', 
   496     cls.add_method('JoinMulticastGroup', 
   486                    'void', 
   497                    'void', 
   487                    [param('ns3::Ptr< ns3::Node >', 'n'), param('ns3::Ipv4Address', 'source'), param('ns3::Ipv4Address', 'group')])
   498                    [param('ns3::Ptr< ns3::Node >', 'n'), param('ns3::Ipv4Address', 'source'), param('ns3::Ipv4Address', 'group')])
       
   499     cls.add_copy_constructor()
   488     return
   500     return
   489 
   501 
   490 def register_Ns3Ipv4InterfaceContainer_methods(root_module, cls):
   502 def register_Ns3Ipv4InterfaceContainer_methods(root_module, cls):
   491     ## ipv4-interface-container.h: ns3::Ipv4InterfaceContainer::Ipv4InterfaceContainer() [constructor]
   503     ## ipv4-interface-container.h: ns3::Ipv4InterfaceContainer::Ipv4InterfaceContainer() [constructor]
   492     cls.add_constructor([])
   504     cls.add_constructor([])
   506                    [param('uint32_t', 'i'), param('uint16_t', 'metric')])
   518                    [param('uint32_t', 'i'), param('uint16_t', 'metric')])
   507     ## ipv4-interface-container.h: void ns3::Ipv4InterfaceContainer::Add(ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface) [member function]
   519     ## ipv4-interface-container.h: void ns3::Ipv4InterfaceContainer::Add(ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface) [member function]
   508     cls.add_method('Add', 
   520     cls.add_method('Add', 
   509                    'void', 
   521                    'void', 
   510                    [param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')])
   522                    [param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')])
       
   523     cls.add_copy_constructor()
   511     return
   524     return
   512 
   525 
   513 def register_Ns3ApplicationContainer_methods(root_module, cls):
   526 def register_Ns3ApplicationContainer_methods(root_module, cls):
   514     ## 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]
   527     ## 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]
   515     cls.add_method('Begin', 
   528     cls.add_method('Begin', 
   546     ## application-container.h: void ns3::ApplicationContainer::Stop(ns3::Time stop) [member function]
   559     ## application-container.h: void ns3::ApplicationContainer::Stop(ns3::Time stop) [member function]
   547     cls.add_method('Stop', 
   560     cls.add_method('Stop', 
   548                    'void', 
   561                    'void', 
   549                    [param('ns3::Time', 'stop')])
   562                    [param('ns3::Time', 'stop')])
   550     cls.add_constructor([])
   563     cls.add_constructor([])
       
   564     cls.add_copy_constructor()
   551     return
   565     return
   552 
   566 
   553 def register_Ns3WifiHelper_methods(root_module, cls):
   567 def register_Ns3WifiHelper_methods(root_module, cls):
   554     ## wifi-helper.h: ns3::WifiHelper::WifiHelper() [constructor]
   568     ## wifi-helper.h: ns3::WifiHelper::WifiHelper() [constructor]
   555     cls.add_constructor([])
   569     cls.add_constructor([])
   613     ## wifi-helper.h: ns3::NetDeviceContainer ns3::WifiHelper::Install(ns3::NodeContainer c, ns3::Ptr<ns3::WifiChannel> channel) const [member function]
   627     ## wifi-helper.h: ns3::NetDeviceContainer ns3::WifiHelper::Install(ns3::NodeContainer c, ns3::Ptr<ns3::WifiChannel> channel) const [member function]
   614     cls.add_method('Install', 
   628     cls.add_method('Install', 
   615                    'ns3::NetDeviceContainer', 
   629                    'ns3::NetDeviceContainer', 
   616                    [param('ns3::NodeContainer', 'c'), param('ns3::Ptr< ns3::WifiChannel >', 'channel')], 
   630                    [param('ns3::NodeContainer', 'c'), param('ns3::Ptr< ns3::WifiChannel >', 'channel')], 
   617                    is_const=True)
   631                    is_const=True)
       
   632     cls.add_copy_constructor()
   618     return
   633     return
   619 
   634 
   620 def register_Ns3Ipv4AddressHelper_methods(root_module, cls):
   635 def register_Ns3Ipv4AddressHelper_methods(root_module, cls):
   621     ## ipv4-address-helper.h: ns3::Ipv4AddressHelper::Ipv4AddressHelper() [constructor]
   636     ## ipv4-address-helper.h: ns3::Ipv4AddressHelper::Ipv4AddressHelper() [constructor]
   622     cls.add_constructor([])
   637     cls.add_constructor([])
   634                    [])
   649                    [])
   635     ## ipv4-address-helper.h: ns3::Ipv4InterfaceContainer ns3::Ipv4AddressHelper::Assign(ns3::NetDeviceContainer const & c) [member function]
   650     ## ipv4-address-helper.h: ns3::Ipv4InterfaceContainer ns3::Ipv4AddressHelper::Assign(ns3::NetDeviceContainer const & c) [member function]
   636     cls.add_method('Assign', 
   651     cls.add_method('Assign', 
   637                    'ns3::Ipv4InterfaceContainer', 
   652                    'ns3::Ipv4InterfaceContainer', 
   638                    [param('ns3::NetDeviceContainer&', 'c', is_const=True)])
   653                    [param('ns3::NetDeviceContainer&', 'c', is_const=True)])
       
   654     cls.add_copy_constructor()
   639     return
   655     return
   640 
   656 
   641 def register_Ns3BridgeHelper_methods(root_module, cls):
   657 def register_Ns3BridgeHelper_methods(root_module, cls):
   642     ## bridge-helper.h: ns3::BridgeHelper::BridgeHelper() [constructor]
   658     ## bridge-helper.h: ns3::BridgeHelper::BridgeHelper() [constructor]
   643     cls.add_constructor([])
   659     cls.add_constructor([])
   647                    [param('std::string', 'n1'), param('ns3::AttributeValue&', 'v1', is_const=True)])
   663                    [param('std::string', 'n1'), param('ns3::AttributeValue&', 'v1', is_const=True)])
   648     ## bridge-helper.h: ns3::NetDeviceContainer ns3::BridgeHelper::Install(ns3::Ptr<ns3::Node> node, ns3::NetDeviceContainer c) [member function]
   664     ## bridge-helper.h: ns3::NetDeviceContainer ns3::BridgeHelper::Install(ns3::Ptr<ns3::Node> node, ns3::NetDeviceContainer c) [member function]
   649     cls.add_method('Install', 
   665     cls.add_method('Install', 
   650                    'ns3::NetDeviceContainer', 
   666                    'ns3::NetDeviceContainer', 
   651                    [param('ns3::Ptr< ns3::Node >', 'node'), param('ns3::NetDeviceContainer', 'c')])
   667                    [param('ns3::Ptr< ns3::Node >', 'node'), param('ns3::NetDeviceContainer', 'c')])
       
   668     cls.add_copy_constructor()
   652     return
   669     return
   653 
   670 
   654 def register_Ns3PacketSinkHelper_methods(root_module, cls):
   671 def register_Ns3PacketSinkHelper_methods(root_module, cls):
   655     ## packet-sink-helper.h: ns3::PacketSinkHelper::PacketSinkHelper(std::string protocol, ns3::Address address) [constructor]
   672     ## packet-sink-helper.h: ns3::PacketSinkHelper::PacketSinkHelper(std::string protocol, ns3::Address address) [constructor]
   656     cls.add_constructor([param('std::string', 'protocol'), param('ns3::Address', 'address')])
   673     cls.add_constructor([param('std::string', 'protocol'), param('ns3::Address', 'address')])
   660                    [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
   677                    [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
   661     ## packet-sink-helper.h: ns3::ApplicationContainer ns3::PacketSinkHelper::Install(ns3::NodeContainer c) [member function]
   678     ## packet-sink-helper.h: ns3::ApplicationContainer ns3::PacketSinkHelper::Install(ns3::NodeContainer c) [member function]
   662     cls.add_method('Install', 
   679     cls.add_method('Install', 
   663                    'ns3::ApplicationContainer', 
   680                    'ns3::ApplicationContainer', 
   664                    [param('ns3::NodeContainer', 'c')])
   681                    [param('ns3::NodeContainer', 'c')])
       
   682     cls.add_copy_constructor()
   665     return
   683     return
   666 
   684 
   667 def register_Ns3Ns2MobilityHelper_methods(root_module, cls):
   685 def register_Ns3Ns2MobilityHelper_methods(root_module, cls):
   668     ## ns2-mobility-helper.h: ns3::Ns2MobilityHelper::Ns2MobilityHelper(std::string filename) [constructor]
   686     ## ns2-mobility-helper.h: ns3::Ns2MobilityHelper::Ns2MobilityHelper(std::string filename) [constructor]
   669     cls.add_constructor([param('std::string', 'filename')])
   687     cls.add_constructor([param('std::string', 'filename')])
   670     ## ns2-mobility-helper.h: void ns3::Ns2MobilityHelper::Install() const [member function]
   688     ## ns2-mobility-helper.h: void ns3::Ns2MobilityHelper::Install() const [member function]
   671     cls.add_method('Install', 
   689     cls.add_method('Install', 
   672                    'void', 
   690                    'void', 
   673                    [], 
   691                    [], 
   674                    is_const=True)
   692                    is_const=True)
       
   693     cls.add_copy_constructor()
   675     return
   694     return
   676 
   695 
   677 def register_functions(root_module):
   696 def register_functions(root_module):
   678     module = root_module
   697     module = root_module
   679     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
   698     register_functions_ns3_internal(module.get_submodule('internal'), root_module)