Mercurial Mercurial > ns-3.5 / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
bindings/python/ns3_module_wifi.py
changeset 3567 728eb3f583b3
parent 3552 b822851cb95d
child 3574 b6804efbe16b
equal deleted inserted replaced
3566:b96af8dc8abf 3567:728eb3f583b3 
   180     register_Ns3ArfWifiManager_methods(root_module, root_module['ns3::ArfWifiManager'])
 
   180     register_Ns3ArfWifiManager_methods(root_module, root_module['ns3::ArfWifiManager'])
 
   181     register_Ns3AarfWifiManager_methods(root_module, root_module['ns3::AarfWifiManager'])
 
   181     register_Ns3AarfWifiManager_methods(root_module, root_module['ns3::AarfWifiManager'])
 
   182     return
 
   182     return
 
   183 
   183 
   184 def register_Ns3WifiRemoteStation_methods(root_module, cls):
 
   184 def register_Ns3WifiRemoteStation_methods(root_module, cls):
 
       
   185     ## wifi-remote-station-manager.h: ns3::WifiRemoteStation::WifiRemoteStation(ns3::WifiRemoteStation const & arg0) [copy constructor]
 
       
   186     cls.add_constructor([param('ns3::WifiRemoteStation&', 'arg0', is_const=True)])
 
   185     ## wifi-remote-station-manager.h: static ns3::TypeId ns3::WifiRemoteStation::GetTypeId() [member function]
 
   187     ## wifi-remote-station-manager.h: static ns3::TypeId ns3::WifiRemoteStation::GetTypeId() [member function]
 
   186     cls.add_method('GetTypeId', 
   188     cls.add_method('GetTypeId', 
   187                    'ns3::TypeId', 
   189                    'ns3::TypeId', 
   188                    [], 
   190                    [], 
   189                    is_static=True)
 
   191                    is_static=True)
 
   369     ## wifi-remote-station-manager.h: ns3::WifiMode ns3::WifiRemoteStation::DoGetRtsMode() [member function]
 
   371     ## wifi-remote-station-manager.h: ns3::WifiMode ns3::WifiRemoteStation::DoGetRtsMode() [member function]
 
   370     cls.add_method('DoGetRtsMode', 
   372     cls.add_method('DoGetRtsMode', 
   371                    'ns3::WifiMode', 
   373                    'ns3::WifiMode', 
   372                    [], 
   374                    [], 
   373                    is_pure_virtual=True, visibility='private', is_virtual=True)
 
   375                    is_pure_virtual=True, visibility='private', is_virtual=True)
 
   374     cls.add_copy_constructor()
 
       
   375     return
 
   376     return
 
   376 
   377 
   377 def register_Ns3WifiPhyListener_methods(root_module, cls):
 
   378 def register_Ns3WifiPhyListener_methods(root_module, cls):
 
       
   379     ## wifi-phy.h: ns3::WifiPhyListener::WifiPhyListener(ns3::WifiPhyListener const & arg0) [copy constructor]
 
       
   380     cls.add_constructor([param('ns3::WifiPhyListener&', 'arg0', is_const=True)])
 
       
   381     ## wifi-phy.h: ns3::WifiPhyListener::WifiPhyListener() [constructor]
 
       
   382     cls.add_constructor([])
 
   378     ## wifi-phy.h: void ns3::WifiPhyListener::NotifyRxStart(ns3::Time duration) [member function]
 
   383     ## wifi-phy.h: void ns3::WifiPhyListener::NotifyRxStart(ns3::Time duration) [member function]
 
   379     cls.add_method('NotifyRxStart', 
   384     cls.add_method('NotifyRxStart', 
   380                    'void', 
   385                    'void', 
   381                    [param('ns3::Time', 'duration')], 
   386                    [param('ns3::Time', 'duration')], 
   382                    is_pure_virtual=True, is_virtual=True)
 
   387                    is_pure_virtual=True, is_virtual=True)
 
   398     ## wifi-phy.h: void ns3::WifiPhyListener::NotifyCcaBusyStart(ns3::Time duration) [member function]
 
   403     ## wifi-phy.h: void ns3::WifiPhyListener::NotifyCcaBusyStart(ns3::Time duration) [member function]
 
   399     cls.add_method('NotifyCcaBusyStart', 
   404     cls.add_method('NotifyCcaBusyStart', 
   400                    'void', 
   405                    'void', 
   401                    [param('ns3::Time', 'duration')], 
   406                    [param('ns3::Time', 'duration')], 
   402                    is_pure_virtual=True, is_virtual=True)
 
   407                    is_pure_virtual=True, is_virtual=True)
 
   403     cls.add_constructor([])
 
       
   404     cls.add_copy_constructor()
 
       
   405     return
 
   408     return
 
   406 
   409 
   407 def register_Ns3ThresholdsItem_methods(root_module, cls):
 
   410 def register_Ns3ThresholdsItem_methods(root_module, cls):
 
   408     ## rraa-wifi-manager.h: ns3::ThresholdsItem::datarate [variable]
 
   411     ## rraa-wifi-manager.h: ns3::ThresholdsItem::datarate [variable]
 
   409     cls.add_instance_attribute('datarate', 'uint32_t', is_const=False)
 
   412     cls.add_instance_attribute('datarate', 'uint32_t', is_const=False)
 
   411     cls.add_instance_attribute('pori', 'double', is_const=False)
 
   414     cls.add_instance_attribute('pori', 'double', is_const=False)
 
   412     ## rraa-wifi-manager.h: ns3::ThresholdsItem::pmtl [variable]
 
   415     ## rraa-wifi-manager.h: ns3::ThresholdsItem::pmtl [variable]
 
   413     cls.add_instance_attribute('pmtl', 'double', is_const=False)
 
   416     cls.add_instance_attribute('pmtl', 'double', is_const=False)
 
   414     ## rraa-wifi-manager.h: ns3::ThresholdsItem::ewnd [variable]
 
   417     ## rraa-wifi-manager.h: ns3::ThresholdsItem::ewnd [variable]
 
   415     cls.add_instance_attribute('ewnd', 'uint32_t', is_const=False)
 
   418     cls.add_instance_attribute('ewnd', 'uint32_t', is_const=False)
 
   416     cls.add_constructor([])
 
   419     ## rraa-wifi-manager.h: ns3::ThresholdsItem::ThresholdsItem(ns3::ThresholdsItem const & arg0) [copy constructor]
 
   417     cls.add_copy_constructor()
 
   420     cls.add_constructor([param('ns3::ThresholdsItem&', 'arg0', is_const=True)])
 
       
   421     ## rraa-wifi-manager.h: ns3::ThresholdsItem::ThresholdsItem() [constructor]
 
       
   422     cls.add_constructor([])
 
   418     return
 
   423     return
 
   419 
   424 
   420 def register_Ns3SupportedRates_methods(root_module, cls):
 
   425 def register_Ns3SupportedRates_methods(root_module, cls):
 
   421     ## supported-rates.h: ns3::SupportedRates::SupportedRates(ns3::SupportedRates const & arg0) [copy constructor]
 
   426     ## supported-rates.h: ns3::SupportedRates::SupportedRates(ns3::SupportedRates const & arg0) [copy constructor]
 
   422     cls.add_constructor([param('ns3::SupportedRates&', 'arg0', is_const=True)])
 
   427     cls.add_constructor([param('ns3::SupportedRates&', 'arg0', is_const=True)])
 
   466                    [param('uint32_t', 'bs')])
 
   471                    [param('uint32_t', 'bs')])
 
   467     cls.add_output_stream_operator()
 
   472     cls.add_output_stream_operator()
 
   468     return
 
   473     return
 
   469 
   474 
   470 def register_Ns3IdealWifiRemoteStation_methods(root_module, cls):
 
   475 def register_Ns3IdealWifiRemoteStation_methods(root_module, cls):
 
       
   476     ## ideal-wifi-manager.h: ns3::IdealWifiRemoteStation::IdealWifiRemoteStation(ns3::IdealWifiRemoteStation const & arg0) [copy constructor]
 
       
   477     cls.add_constructor([param('ns3::IdealWifiRemoteStation&', 'arg0', is_const=True)])
 
   471     ## ideal-wifi-manager.h: ns3::IdealWifiRemoteStation::IdealWifiRemoteStation(ns3::Ptr<ns3::IdealWifiManager> stations) [constructor]
 
   478     ## ideal-wifi-manager.h: ns3::IdealWifiRemoteStation::IdealWifiRemoteStation(ns3::Ptr<ns3::IdealWifiManager> stations) [constructor]
 
   472     cls.add_constructor([param('ns3::Ptr< ns3::IdealWifiManager >', 'stations')])
 
   479     cls.add_constructor([param('ns3::Ptr< ns3::IdealWifiManager >', 'stations')])
 
   473     ## ideal-wifi-manager.h: void ns3::IdealWifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function]
 
   480     ## ideal-wifi-manager.h: void ns3::IdealWifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function]
 
   474     cls.add_method('DoReportRxOk', 
   481     cls.add_method('DoReportRxOk', 
   475                    'void', 
   482                    'void', 
   518     ## ideal-wifi-manager.h: ns3::WifiMode ns3::IdealWifiRemoteStation::DoGetRtsMode() [member function]
 
   525     ## ideal-wifi-manager.h: ns3::WifiMode ns3::IdealWifiRemoteStation::DoGetRtsMode() [member function]
 
   519     cls.add_method('DoGetRtsMode', 
   526     cls.add_method('DoGetRtsMode', 
   520                    'ns3::WifiMode', 
   527                    'ns3::WifiMode', 
   521                    [], 
   528                    [], 
   522                    visibility='private', is_virtual=True)
 
   529                    visibility='private', is_virtual=True)
 
   523     cls.add_copy_constructor()
 
       
   524     return
 
   530     return
 
   525 
   531 
   526 def register_Ns3WifiModeChecker_methods(root_module, cls):
 
   532 def register_Ns3WifiModeChecker_methods(root_module, cls):
 
   527     cls.add_constructor([])
 
   533     ## wifi-mode.h: ns3::WifiModeChecker::WifiModeChecker(ns3::WifiModeChecker const & arg0) [copy constructor]
 
   528     cls.add_copy_constructor()
 
   534     cls.add_constructor([param('ns3::WifiModeChecker&', 'arg0', is_const=True)])
 
       
   535     ## wifi-mode.h: ns3::WifiModeChecker::WifiModeChecker() [constructor]
 
       
   536     cls.add_constructor([])
 
   529     return
 
   537     return
 
   530 
   538 
   531 def register_Ns3WifiModeFactory_methods(root_module, cls):
 
   539 def register_Ns3WifiModeFactory_methods(root_module, cls):
 
       
   540     ## wifi-mode.h: ns3::WifiModeFactory::WifiModeFactory(ns3::WifiModeFactory const & arg0) [copy constructor]
 
       
   541     cls.add_constructor([param('ns3::WifiModeFactory&', 'arg0', is_const=True)])
 
   532     ## 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]
 
   542     ## 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]
 
   533     cls.add_method('CreateBpsk', 
   543     cls.add_method('CreateBpsk', 
   534                    'ns3::WifiMode', 
   544                    'ns3::WifiMode', 
   535                    [param('std::string', 'uniqueName'), param('bool', 'isMandatory'), param('uint32_t', 'bandwidth'), param('uint32_t', 'dataRate'), param('uint32_t', 'phyRate')], 
   545                    [param('std::string', 'uniqueName'), param('bool', 'isMandatory'), param('uint32_t', 'bandwidth'), param('uint32_t', 'dataRate'), param('uint32_t', 'phyRate')], 
   536                    is_static=True)
 
   546                    is_static=True)
 
   537     ## wifi-mode.h: static ns3::WifiMode ns3::WifiModeFactory::CreateQam(std::string uniqueName, bool isMandatory, uint32_t bandwidth, uint32_t dataRate, uint32_t phyRate, uint8_t constellationSize) [member function]
 
   547     ## wifi-mode.h: static ns3::WifiMode ns3::WifiModeFactory::CreateQam(std::string uniqueName, bool isMandatory, uint32_t bandwidth, uint32_t dataRate, uint32_t phyRate, uint8_t constellationSize) [member function]
 
   538     cls.add_method('CreateQam', 
   548     cls.add_method('CreateQam', 
   539                    'ns3::WifiMode', 
   549                    'ns3::WifiMode', 
   540                    [param('std::string', 'uniqueName'), param('bool', 'isMandatory'), param('uint32_t', 'bandwidth'), param('uint32_t', 'dataRate'), param('uint32_t', 'phyRate'), param('uint8_t', 'constellationSize')], 
   550                    [param('std::string', 'uniqueName'), param('bool', 'isMandatory'), param('uint32_t', 'bandwidth'), param('uint32_t', 'dataRate'), param('uint32_t', 'phyRate'), param('uint8_t', 'constellationSize')], 
   541                    is_static=True)
 
   551                    is_static=True)
 
   542     cls.add_copy_constructor()
 
       
   543     return
 
   552     return
 
   544 
   553 
   545 def register_Ns3OnoeWifiRemoteStation_methods(root_module, cls):
 
   554 def register_Ns3OnoeWifiRemoteStation_methods(root_module, cls):
 
       
   555     ## onoe-wifi-manager.h: ns3::OnoeWifiRemoteStation::OnoeWifiRemoteStation(ns3::OnoeWifiRemoteStation const & arg0) [copy constructor]
 
       
   556     cls.add_constructor([param('ns3::OnoeWifiRemoteStation&', 'arg0', is_const=True)])
 
   546     ## onoe-wifi-manager.h: ns3::OnoeWifiRemoteStation::OnoeWifiRemoteStation(ns3::Ptr<ns3::OnoeWifiManager> stations) [constructor]
 
   557     ## onoe-wifi-manager.h: ns3::OnoeWifiRemoteStation::OnoeWifiRemoteStation(ns3::Ptr<ns3::OnoeWifiManager> stations) [constructor]
 
   547     cls.add_constructor([param('ns3::Ptr< ns3::OnoeWifiManager >', 'stations')])
 
   558     cls.add_constructor([param('ns3::Ptr< ns3::OnoeWifiManager >', 'stations')])
 
   548     ## onoe-wifi-manager.h: void ns3::OnoeWifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function]
 
   559     ## onoe-wifi-manager.h: void ns3::OnoeWifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function]
 
   549     cls.add_method('DoReportRxOk', 
   560     cls.add_method('DoReportRxOk', 
   550                    'void', 
   561                    'void', 
   593     ## onoe-wifi-manager.h: ns3::WifiMode ns3::OnoeWifiRemoteStation::DoGetRtsMode() [member function]
 
   604     ## onoe-wifi-manager.h: ns3::WifiMode ns3::OnoeWifiRemoteStation::DoGetRtsMode() [member function]
 
   594     cls.add_method('DoGetRtsMode', 
   605     cls.add_method('DoGetRtsMode', 
   595                    'ns3::WifiMode', 
   606                    'ns3::WifiMode', 
   596                    [], 
   607                    [], 
   597                    visibility='private', is_virtual=True)
 
   608                    visibility='private', is_virtual=True)
 
   598     cls.add_copy_constructor()
 
       
   599     return
 
   609     return
 
   600 
   610 
   601 def register_Ns3RraaWifiRemoteStation_methods(root_module, cls):
 
   611 def register_Ns3RraaWifiRemoteStation_methods(root_module, cls):
 
       
   612     ## rraa-wifi-manager.h: ns3::RraaWifiRemoteStation::RraaWifiRemoteStation(ns3::RraaWifiRemoteStation const & arg0) [copy constructor]
 
       
   613     cls.add_constructor([param('ns3::RraaWifiRemoteStation&', 'arg0', is_const=True)])
 
   602     ## rraa-wifi-manager.h: ns3::RraaWifiRemoteStation::RraaWifiRemoteStation(ns3::Ptr<ns3::RraaWifiManager> stations) [constructor]
 
   614     ## rraa-wifi-manager.h: ns3::RraaWifiRemoteStation::RraaWifiRemoteStation(ns3::Ptr<ns3::RraaWifiManager> stations) [constructor]
 
   603     cls.add_constructor([param('ns3::Ptr< ns3::RraaWifiManager >', 'stations')])
 
   615     cls.add_constructor([param('ns3::Ptr< ns3::RraaWifiManager >', 'stations')])
 
   604     ## rraa-wifi-manager.h: bool ns3::RraaWifiRemoteStation::NeedRts(ns3::Ptr<const ns3::Packet> packet) [member function]
 
   616     ## rraa-wifi-manager.h: bool ns3::RraaWifiRemoteStation::NeedRts(ns3::Ptr<const ns3::Packet> packet) [member function]
 
   605     cls.add_method('NeedRts', 
   617     cls.add_method('NeedRts', 
   606                    'bool', 
   618                    'bool', 
   654     ## rraa-wifi-manager.h: ns3::WifiMode ns3::RraaWifiRemoteStation::DoGetRtsMode() [member function]
 
   666     ## rraa-wifi-manager.h: ns3::WifiMode ns3::RraaWifiRemoteStation::DoGetRtsMode() [member function]
 
   655     cls.add_method('DoGetRtsMode', 
   667     cls.add_method('DoGetRtsMode', 
   656                    'ns3::WifiMode', 
   668                    'ns3::WifiMode', 
   657                    [], 
   669                    [], 
   658                    visibility='private', is_virtual=True)
 
   670                    visibility='private', is_virtual=True)
 
   659     cls.add_copy_constructor()
 
       
   660     return
 
   671     return
 
   661 
   672 
   662 def register_Ns3Ssid_methods(root_module, cls):
 
   673 def register_Ns3Ssid_methods(root_module, cls):
 
   663     ## ssid.h: ns3::Ssid::Ssid(ns3::Ssid const & arg0) [copy constructor]
 
   674     ## ssid.h: ns3::Ssid::Ssid(ns3::Ssid const & arg0) [copy constructor]
 
   664     cls.add_constructor([param('ns3::Ssid&', 'arg0', is_const=True)])
 
   675     cls.add_constructor([param('ns3::Ssid&', 'arg0', is_const=True)])
 
   762                    is_const=True)
 
   773                    is_const=True)
 
   763     cls.add_output_stream_operator()
 
   774     cls.add_output_stream_operator()
 
   764     return
 
   775     return
 
   765 
   776 
   766 def register_Ns3SsidValue_methods(root_module, cls):
 
   777 def register_Ns3SsidValue_methods(root_module, cls):
 
       
   778     ## ssid.h: ns3::SsidValue::SsidValue(ns3::SsidValue const & arg0) [copy constructor]
 
       
   779     cls.add_constructor([param('ns3::SsidValue&', 'arg0', is_const=True)])
 
   767     ## ssid.h: ns3::SsidValue::SsidValue() [constructor]
 
   780     ## ssid.h: ns3::SsidValue::SsidValue() [constructor]
 
   768     cls.add_constructor([])
 
   781     cls.add_constructor([])
 
   769     ## ssid.h: ns3::SsidValue::SsidValue(ns3::Ssid const & value) [constructor]
 
   782     ## ssid.h: ns3::SsidValue::SsidValue(ns3::Ssid const & value) [constructor]
 
   770     cls.add_constructor([param('ns3::Ssid&', 'value', is_const=True)])
 
   783     cls.add_constructor([param('ns3::Ssid&', 'value', is_const=True)])
 
   771     ## ssid.h: void ns3::SsidValue::Set(ns3::Ssid const & value) [member function]
 
   784     ## ssid.h: void ns3::SsidValue::Set(ns3::Ssid const & value) [member function]
 
   790     ## ssid.h: bool ns3::SsidValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
 
   803     ## ssid.h: bool ns3::SsidValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
 
   791     cls.add_method('DeserializeFromString', 
   804     cls.add_method('DeserializeFromString', 
   792                    'bool', 
   805                    'bool', 
   793                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
   806                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
   794                    is_virtual=True)
 
   807                    is_virtual=True)
 
   795     cls.add_copy_constructor()
 
       
   796     return
 
   808     return
 
   797 
   809 
   798 def register_Ns3SsidChecker_methods(root_module, cls):
 
   810 def register_Ns3SsidChecker_methods(root_module, cls):
 
   799     cls.add_constructor([])
 
   811     ## ssid.h: ns3::SsidChecker::SsidChecker(ns3::SsidChecker const & arg0) [copy constructor]
 
   800     cls.add_copy_constructor()
 
   812     cls.add_constructor([param('ns3::SsidChecker&', 'arg0', is_const=True)])
 
       
   813     ## ssid.h: ns3::SsidChecker::SsidChecker() [constructor]
 
       
   814     cls.add_constructor([])
 
   801     return
 
   815     return
 
   802 
   816 
   803 def register_Ns3ConstantRateWifiRemoteStation_methods(root_module, cls):
 
   817 def register_Ns3ConstantRateWifiRemoteStation_methods(root_module, cls):
 
       
   818     ## constant-rate-wifi-manager.h: ns3::ConstantRateWifiRemoteStation::ConstantRateWifiRemoteStation(ns3::ConstantRateWifiRemoteStation const & arg0) [copy constructor]
 
       
   819     cls.add_constructor([param('ns3::ConstantRateWifiRemoteStation&', 'arg0', is_const=True)])
 
   804     ## constant-rate-wifi-manager.h: ns3::ConstantRateWifiRemoteStation::ConstantRateWifiRemoteStation(ns3::Ptr<ns3::ConstantRateWifiManager> stations) [constructor]
 
   820     ## constant-rate-wifi-manager.h: ns3::ConstantRateWifiRemoteStation::ConstantRateWifiRemoteStation(ns3::Ptr<ns3::ConstantRateWifiManager> stations) [constructor]
 
   805     cls.add_constructor([param('ns3::Ptr< ns3::ConstantRateWifiManager >', 'stations')])
 
   821     cls.add_constructor([param('ns3::Ptr< ns3::ConstantRateWifiManager >', 'stations')])
 
   806     ## constant-rate-wifi-manager.h: void ns3::ConstantRateWifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function]
 
   822     ## constant-rate-wifi-manager.h: void ns3::ConstantRateWifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function]
 
   807     cls.add_method('DoReportRxOk', 
   823     cls.add_method('DoReportRxOk', 
   808                    'void', 
   824                    'void', 
   851     ## constant-rate-wifi-manager.h: ns3::WifiMode ns3::ConstantRateWifiRemoteStation::DoGetRtsMode() [member function]
 
   867     ## constant-rate-wifi-manager.h: ns3::WifiMode ns3::ConstantRateWifiRemoteStation::DoGetRtsMode() [member function]
 
   852     cls.add_method('DoGetRtsMode', 
   868     cls.add_method('DoGetRtsMode', 
   853                    'ns3::WifiMode', 
   869                    'ns3::WifiMode', 
   854                    [], 
   870                    [], 
   855                    visibility='private', is_virtual=True)
 
   871                    visibility='private', is_virtual=True)
 
   856     cls.add_copy_constructor()
 
       
   857     return
 
   872     return
 
   858 
   873 
   859 def register_Ns3PropagationLossModel_methods(root_module, cls):
 
   874 def register_Ns3PropagationLossModel_methods(root_module, cls):
 
       
   875     ## propagation-loss-model.h: ns3::PropagationLossModel::PropagationLossModel(ns3::PropagationLossModel const & arg0) [copy constructor]
 
       
   876     cls.add_constructor([param('ns3::PropagationLossModel&', 'arg0', is_const=True)])
 
       
   877     ## propagation-loss-model.h: ns3::PropagationLossModel::PropagationLossModel() [constructor]
 
       
   878     cls.add_constructor([])
 
   860     ## propagation-loss-model.h: static ns3::TypeId ns3::PropagationLossModel::GetTypeId() [member function]
 
   879     ## propagation-loss-model.h: static ns3::TypeId ns3::PropagationLossModel::GetTypeId() [member function]
 
   861     cls.add_method('GetTypeId', 
   880     cls.add_method('GetTypeId', 
   862                    'ns3::TypeId', 
   881                    'ns3::TypeId', 
   863                    [], 
   882                    [], 
   864                    is_static=True)
 
   883                    is_static=True)
 
   865     ## propagation-loss-model.h: double ns3::PropagationLossModel::GetLoss(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
 
   884     ## propagation-loss-model.h: double ns3::PropagationLossModel::GetLoss(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
 
   866     cls.add_method('GetLoss', 
   885     cls.add_method('GetLoss', 
   867                    'double', 
   886                    'double', 
   868                    [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
   887                    [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
   869                    is_pure_virtual=True, is_const=True, is_virtual=True)
 
   888                    is_pure_virtual=True, is_const=True, is_virtual=True)
 
   870     cls.add_constructor([])
 
       
   871     cls.add_copy_constructor()
 
       
   872     return
 
   889     return
 
   873 
   890 
   874 def register_Ns3ArfWifiRemoteStation_methods(root_module, cls):
 
   891 def register_Ns3ArfWifiRemoteStation_methods(root_module, cls):
 
       
   892     ## arf-wifi-manager.h: ns3::ArfWifiRemoteStation::ArfWifiRemoteStation(ns3::ArfWifiRemoteStation const & arg0) [copy constructor]
 
       
   893     cls.add_constructor([param('ns3::ArfWifiRemoteStation&', 'arg0', is_const=True)])
 
   875     ## arf-wifi-manager.h: ns3::ArfWifiRemoteStation::ArfWifiRemoteStation(ns3::Ptr<ns3::ArfWifiManager> stations, int minTimerTimeout, int minSuccessThreshold) [constructor]
 
   894     ## arf-wifi-manager.h: ns3::ArfWifiRemoteStation::ArfWifiRemoteStation(ns3::Ptr<ns3::ArfWifiManager> stations, int minTimerTimeout, int minSuccessThreshold) [constructor]
 
   876     cls.add_constructor([param('ns3::Ptr< ns3::ArfWifiManager >', 'stations'), param('int', 'minTimerTimeout'), param('int', 'minSuccessThreshold')])
 
   895     cls.add_constructor([param('ns3::Ptr< ns3::ArfWifiManager >', 'stations'), param('int', 'minTimerTimeout'), param('int', 'minSuccessThreshold')])
 
   877     ## arf-wifi-manager.h: void ns3::ArfWifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function]
 
   896     ## arf-wifi-manager.h: void ns3::ArfWifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function]
 
   878     cls.add_method('DoReportRxOk', 
   897     cls.add_method('DoReportRxOk', 
   879                    'void', 
   898                    'void', 
   962     ## arf-wifi-manager.h: void ns3::ArfWifiRemoteStation::ReportFailure() [member function]
 
   981     ## arf-wifi-manager.h: void ns3::ArfWifiRemoteStation::ReportFailure() [member function]
 
   963     cls.add_method('ReportFailure', 
   982     cls.add_method('ReportFailure', 
   964                    'void', 
   983                    'void', 
   965                    [], 
   984                    [], 
   966                    visibility='private', is_virtual=True)
 
   985                    visibility='private', is_virtual=True)
 
   967     cls.add_copy_constructor()
 
       
   968     return
 
   986     return
 
   969 
   987 
   970 def register_Ns3WifiMac_methods(root_module, cls):
 
   988 def register_Ns3WifiMac_methods(root_module, cls):
 
       
   989     ## wifi-mac.h: ns3::WifiMac::WifiMac(ns3::WifiMac const & arg0) [copy constructor]
 
       
   990     cls.add_constructor([param('ns3::WifiMac&', 'arg0', is_const=True)])
 
       
   991     ## wifi-mac.h: ns3::WifiMac::WifiMac() [constructor]
 
       
   992     cls.add_constructor([])
 
   971     ## wifi-mac.h: static ns3::TypeId ns3::WifiMac::GetTypeId() [member function]
 
   993     ## wifi-mac.h: static ns3::TypeId ns3::WifiMac::GetTypeId() [member function]
 
   972     cls.add_method('GetTypeId', 
   994     cls.add_method('GetTypeId', 
   973                    'ns3::TypeId', 
   995                    'ns3::TypeId', 
   974                    [], 
   996                    [], 
   975                    is_static=True)
 
   997                    is_static=True)
 
  1102     ## wifi-mac.h: void ns3::WifiMac::SetLinkDownCallback(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> linkDown) [member function]
 
  1124     ## wifi-mac.h: void ns3::WifiMac::SetLinkDownCallback(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> linkDown) [member function]
 
  1103     cls.add_method('SetLinkDownCallback', 
  1125     cls.add_method('SetLinkDownCallback', 
  1104                    'void', 
  1126                    'void', 
  1105                    [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'linkDown')], 
  1127                    [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'linkDown')], 
  1106                    is_pure_virtual=True, visibility='private', is_virtual=True)
 
  1128                    is_pure_virtual=True, visibility='private', is_virtual=True)
 
  1107     cls.add_constructor([])
 
       
  1108     cls.add_copy_constructor()
 
       
  1109     return
 
  1129     return
 
  1110 
  1130 
  1111 def register_Ns3NqapWifiMac_methods(root_module, cls):
 
  1131 def register_Ns3NqapWifiMac_methods(root_module, cls):
 
  1112     ## nqap-wifi-mac.h: static ns3::TypeId ns3::NqapWifiMac::GetTypeId() [member function]
 
  1132     ## nqap-wifi-mac.h: static ns3::TypeId ns3::NqapWifiMac::GetTypeId() [member function]
 
  1113     cls.add_method('GetTypeId', 
  1133     cls.add_method('GetTypeId', 
  1220                    [], 
  1240                    [], 
  1221                    visibility='private', is_virtual=True)
 
  1241                    visibility='private', is_virtual=True)
 
  1222     return
 
  1242     return
 
  1223 
  1243 
  1224 def register_Ns3CompositePropagationLossModel_methods(root_module, cls):
 
  1244 def register_Ns3CompositePropagationLossModel_methods(root_module, cls):
 
       
  1245     ## composite-propagation-loss-model.h: ns3::CompositePropagationLossModel::CompositePropagationLossModel(ns3::CompositePropagationLossModel const & arg0) [copy constructor]
 
       
  1246     cls.add_constructor([param('ns3::CompositePropagationLossModel&', 'arg0', is_const=True)])
 
  1225     ## composite-propagation-loss-model.h: static ns3::TypeId ns3::CompositePropagationLossModel::GetTypeId() [member function]
 
  1247     ## composite-propagation-loss-model.h: static ns3::TypeId ns3::CompositePropagationLossModel::GetTypeId() [member function]
 
  1226     cls.add_method('GetTypeId', 
  1248     cls.add_method('GetTypeId', 
  1227                    'ns3::TypeId', 
  1249                    'ns3::TypeId', 
  1228                    [], 
  1250                    [], 
  1229                    is_static=True)
 
  1251                    is_static=True)
 
  1241     ## composite-propagation-loss-model.h: void ns3::CompositePropagationLossModel::AddDefaults() [member function]
 
  1263     ## composite-propagation-loss-model.h: void ns3::CompositePropagationLossModel::AddDefaults() [member function]
 
  1242     cls.add_method('AddDefaults', 
  1264     cls.add_method('AddDefaults', 
  1243                    'void', 
  1265                    'void', 
  1244                    [], 
  1266                    [], 
  1245                    visibility='protected', is_virtual=True)
 
  1267                    visibility='protected', is_virtual=True)
 
  1246     cls.add_copy_constructor()
 
       
  1247     return
 
  1268     return
 
  1248 
  1269 
  1249 def register_Ns3AmrrWifiRemoteStation_methods(root_module, cls):
 
  1270 def register_Ns3AmrrWifiRemoteStation_methods(root_module, cls):
 
       
  1271     ## amrr-wifi-manager.h: ns3::AmrrWifiRemoteStation::AmrrWifiRemoteStation(ns3::AmrrWifiRemoteStation const & arg0) [copy constructor]
 
       
  1272     cls.add_constructor([param('ns3::AmrrWifiRemoteStation&', 'arg0', is_const=True)])
 
  1250     ## amrr-wifi-manager.h: ns3::AmrrWifiRemoteStation::AmrrWifiRemoteStation(ns3::Ptr<ns3::AmrrWifiManager> stations) [constructor]
 
  1273     ## amrr-wifi-manager.h: ns3::AmrrWifiRemoteStation::AmrrWifiRemoteStation(ns3::Ptr<ns3::AmrrWifiManager> stations) [constructor]
 
  1251     cls.add_constructor([param('ns3::Ptr< ns3::AmrrWifiManager >', 'stations')])
 
  1274     cls.add_constructor([param('ns3::Ptr< ns3::AmrrWifiManager >', 'stations')])
 
  1252     ## amrr-wifi-manager.h: void ns3::AmrrWifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function]
 
  1275     ## amrr-wifi-manager.h: void ns3::AmrrWifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function]
 
  1253     cls.add_method('DoReportRxOk', 
  1276     cls.add_method('DoReportRxOk', 
  1254                    'void', 
  1277                    'void', 
  1297     ## amrr-wifi-manager.h: ns3::WifiMode ns3::AmrrWifiRemoteStation::DoGetRtsMode() [member function]
 
  1320     ## amrr-wifi-manager.h: ns3::WifiMode ns3::AmrrWifiRemoteStation::DoGetRtsMode() [member function]
 
  1298     cls.add_method('DoGetRtsMode', 
  1321     cls.add_method('DoGetRtsMode', 
  1299                    'ns3::WifiMode', 
  1322                    'ns3::WifiMode', 
  1300                    [], 
  1323                    [], 
  1301                    visibility='private', is_virtual=True)
 
  1324                    visibility='private', is_virtual=True)
 
  1302     cls.add_copy_constructor()
 
       
  1303     return
 
  1325     return
 
  1304 
  1326 
  1305 def register_Ns3FriisPropagationLossModel_methods(root_module, cls):
 
  1327 def register_Ns3FriisPropagationLossModel_methods(root_module, cls):
 
       
  1328     ## propagation-loss-model.h: ns3::FriisPropagationLossModel::FriisPropagationLossModel(ns3::FriisPropagationLossModel const & arg0) [copy constructor]
 
       
  1329     cls.add_constructor([param('ns3::FriisPropagationLossModel&', 'arg0', is_const=True)])
 
  1306     ## propagation-loss-model.h: static ns3::TypeId ns3::FriisPropagationLossModel::GetTypeId() [member function]
 
  1330     ## propagation-loss-model.h: static ns3::TypeId ns3::FriisPropagationLossModel::GetTypeId() [member function]
 
  1307     cls.add_method('GetTypeId', 
  1331     cls.add_method('GetTypeId', 
  1308                    'ns3::TypeId', 
  1332                    'ns3::TypeId', 
  1309                    [], 
  1333                    [], 
  1310                    is_static=True)
 
  1334                    is_static=True)
 
  1344     ## propagation-loss-model.h: double ns3::FriisPropagationLossModel::GetLoss(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
 
  1368     ## propagation-loss-model.h: double ns3::FriisPropagationLossModel::GetLoss(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
 
  1345     cls.add_method('GetLoss', 
  1369     cls.add_method('GetLoss', 
  1346                    'double', 
  1370                    'double', 
  1347                    [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
  1371                    [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
  1348                    is_const=True, is_virtual=True)
 
  1372                    is_const=True, is_virtual=True)
 
  1349     cls.add_copy_constructor()
 
       
  1350     return
 
  1373     return
 
  1351 
  1374 
  1352 def register_Ns3NqstaWifiMac_methods(root_module, cls):
 
  1375 def register_Ns3NqstaWifiMac_methods(root_module, cls):
 
  1353     ## nqsta-wifi-mac.h: static ns3::TypeId ns3::NqstaWifiMac::GetTypeId() [member function]
 
  1376     ## nqsta-wifi-mac.h: static ns3::TypeId ns3::NqstaWifiMac::GetTypeId() [member function]
 
  1354     cls.add_method('GetTypeId', 
  1377     cls.add_method('GetTypeId', 
  1464                    [], 
  1487                    [], 
  1465                    visibility='private', is_virtual=True)
 
  1488                    visibility='private', is_virtual=True)
 
  1466     return
 
  1489     return
 
  1467 
  1490 
  1468 def register_Ns3WifiRemoteStationManager_methods(root_module, cls):
 
  1491 def register_Ns3WifiRemoteStationManager_methods(root_module, cls):
 
       
  1492     ## wifi-remote-station-manager.h: ns3::WifiRemoteStationManager::WifiRemoteStationManager(ns3::WifiRemoteStationManager const & arg0) [copy constructor]
 
       
  1493     cls.add_constructor([param('ns3::WifiRemoteStationManager&', 'arg0', is_const=True)])
 
  1469     ## wifi-remote-station-manager.h: static ns3::TypeId ns3::WifiRemoteStationManager::GetTypeId() [member function]
 
  1494     ## wifi-remote-station-manager.h: static ns3::TypeId ns3::WifiRemoteStationManager::GetTypeId() [member function]
 
  1470     cls.add_method('GetTypeId', 
  1495     cls.add_method('GetTypeId', 
  1471                    'ns3::TypeId', 
  1496                    'ns3::TypeId', 
  1472                    [], 
  1497                    [], 
  1473                    is_static=True)
 
  1498                    is_static=True)
 
  1537                    'ns3::WifiMode', 
  1562                    'ns3::WifiMode', 
  1538                    [param('uint32_t', 'i')], 
  1563                    [param('uint32_t', 'i')], 
  1539                    is_const=True)
 
  1564                    is_const=True)
 
  1540     ## 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]
 
  1565     ## 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]
 
  1541     cls.add_method('BeginBasicModes', 
  1566     cls.add_method('BeginBasicModes', 
  1542                    '__gnu_cxx::__normal_iterator< const ns3::WifiMode*, std::vector< ns3::WifiMode, std::allocator< ns3::WifiMode > > >', 
  1567                    '__gnu_cxx::__normal_iterator< const ns3::WifiMode*, std::vector< ns3::WifiMode > >', 
  1543                    [], 
  1568                    [], 
  1544                    is_const=True)
 
  1569                    is_const=True)
 
  1545     ## 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]
 
  1570     ## 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]
 
  1546     cls.add_method('EndBasicModes', 
  1571     cls.add_method('EndBasicModes', 
  1547                    '__gnu_cxx::__normal_iterator< const ns3::WifiMode*, std::vector< ns3::WifiMode, std::allocator< ns3::WifiMode > > >', 
  1572                    '__gnu_cxx::__normal_iterator< const ns3::WifiMode*, std::vector< ns3::WifiMode > >', 
  1548                    [], 
  1573                    [], 
  1549                    is_const=True)
 
  1574                    is_const=True)
 
  1550     ## wifi-remote-station-manager.h: bool ns3::WifiRemoteStationManager::IsLowLatency() const [member function]
 
  1575     ## wifi-remote-station-manager.h: bool ns3::WifiRemoteStationManager::IsLowLatency() const [member function]
 
  1551     cls.add_method('IsLowLatency', 
  1576     cls.add_method('IsLowLatency', 
  1552                    'bool', 
  1577                    'bool', 
  1568     ## wifi-remote-station-manager.h: ns3::WifiRemoteStation * ns3::WifiRemoteStationManager::CreateStation() [member function]
 
  1593     ## wifi-remote-station-manager.h: ns3::WifiRemoteStation * ns3::WifiRemoteStationManager::CreateStation() [member function]
 
  1569     cls.add_method('CreateStation', 
  1594     cls.add_method('CreateStation', 
  1570                    'ns3::WifiRemoteStation *', 
  1595                    'ns3::WifiRemoteStation *', 
  1571                    [], 
  1596                    [], 
  1572                    is_pure_virtual=True, visibility='private', is_virtual=True)
 
  1597                    is_pure_virtual=True, visibility='private', is_virtual=True)
 
  1573     cls.add_copy_constructor()
 
       
  1574     return
 
  1598     return
 
  1575 
  1599 
  1576 def register_Ns3WifiModeValue_methods(root_module, cls):
 
  1600 def register_Ns3WifiModeValue_methods(root_module, cls):
 
       
  1601     ## wifi-mode.h: ns3::WifiModeValue::WifiModeValue(ns3::WifiModeValue const & arg0) [copy constructor]
 
       
  1602     cls.add_constructor([param('ns3::WifiModeValue&', 'arg0', is_const=True)])
 
  1577     ## wifi-mode.h: ns3::WifiModeValue::WifiModeValue() [constructor]
 
  1603     ## wifi-mode.h: ns3::WifiModeValue::WifiModeValue() [constructor]
 
  1578     cls.add_constructor([])
 
  1604     cls.add_constructor([])
 
  1579     ## wifi-mode.h: ns3::WifiModeValue::WifiModeValue(ns3::WifiMode const & value) [constructor]
 
  1605     ## wifi-mode.h: ns3::WifiModeValue::WifiModeValue(ns3::WifiMode const & value) [constructor]
 
  1580     cls.add_constructor([param('ns3::WifiMode&', 'value', is_const=True)])
 
  1606     cls.add_constructor([param('ns3::WifiMode&', 'value', is_const=True)])
 
  1581     ## wifi-mode.h: void ns3::WifiModeValue::Set(ns3::WifiMode const & value) [member function]
 
  1607     ## wifi-mode.h: void ns3::WifiModeValue::Set(ns3::WifiMode const & value) [member function]
 
  1600     ## wifi-mode.h: bool ns3::WifiModeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
 
  1626     ## wifi-mode.h: bool ns3::WifiModeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
 
  1601     cls.add_method('DeserializeFromString', 
  1627     cls.add_method('DeserializeFromString', 
  1602                    'bool', 
  1628                    'bool', 
  1603                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1629                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1604                    is_virtual=True)
 
  1630                    is_virtual=True)
 
  1605     cls.add_copy_constructor()
 
       
  1606     return
 
  1631     return
 
  1607 
  1632 
  1608 def register_Ns3OnoeWifiManager_methods(root_module, cls):
 
  1633 def register_Ns3OnoeWifiManager_methods(root_module, cls):
 
       
  1634     ## onoe-wifi-manager.h: ns3::OnoeWifiManager::OnoeWifiManager(ns3::OnoeWifiManager const & arg0) [copy constructor]
 
       
  1635     cls.add_constructor([param('ns3::OnoeWifiManager&', 'arg0', is_const=True)])
 
  1609     ## onoe-wifi-manager.h: static ns3::TypeId ns3::OnoeWifiManager::GetTypeId() [member function]
 
  1636     ## onoe-wifi-manager.h: static ns3::TypeId ns3::OnoeWifiManager::GetTypeId() [member function]
 
  1610     cls.add_method('GetTypeId', 
  1637     cls.add_method('GetTypeId', 
  1611                    'ns3::TypeId', 
  1638                    'ns3::TypeId', 
  1612                    [], 
  1639                    [], 
  1613                    is_static=True)
 
  1640                    is_static=True)
 
  1616     ## onoe-wifi-manager.h: ns3::WifiRemoteStation * ns3::OnoeWifiManager::CreateStation() [member function]
 
  1643     ## onoe-wifi-manager.h: ns3::WifiRemoteStation * ns3::OnoeWifiManager::CreateStation() [member function]
 
  1617     cls.add_method('CreateStation', 
  1644     cls.add_method('CreateStation', 
  1618                    'ns3::WifiRemoteStation *', 
  1645                    'ns3::WifiRemoteStation *', 
  1619                    [], 
  1646                    [], 
  1620                    visibility='private', is_virtual=True)
 
  1647                    visibility='private', is_virtual=True)
 
  1621     cls.add_copy_constructor()
 
       
  1622     return
 
  1648     return
 
  1623 
  1649 
  1624 def register_Ns3WifiPhy_methods(root_module, cls):
 
  1650 def register_Ns3WifiPhy_methods(root_module, cls):
 
  1625     ## wifi-phy.h: static ns3::TypeId ns3::WifiPhy::GetTypeId() [member function]
 
  1651     ## wifi-phy.h: static ns3::TypeId ns3::WifiPhy::GetTypeId() [member function]
 
  1626     cls.add_method('GetTypeId', 
  1652     cls.add_method('GetTypeId', 
  1784                    [], 
  1810                    [], 
  1785                    visibility='private', is_virtual=True)
 
  1811                    visibility='private', is_virtual=True)
 
  1786     return
 
  1812     return
 
  1787 
  1813 
  1788 def register_Ns3WifiChannel_methods(root_module, cls):
 
  1814 def register_Ns3WifiChannel_methods(root_module, cls):
 
       
  1815     ## wifi-channel.h: ns3::WifiChannel::WifiChannel(ns3::WifiChannel const & arg0) [copy constructor]
 
       
  1816     cls.add_constructor([param('ns3::WifiChannel&', 'arg0', is_const=True)])
 
  1789     ## wifi-channel.h: static ns3::TypeId ns3::WifiChannel::GetTypeId() [member function]
 
  1817     ## wifi-channel.h: static ns3::TypeId ns3::WifiChannel::GetTypeId() [member function]
 
  1790     cls.add_method('GetTypeId', 
  1818     cls.add_method('GetTypeId', 
  1791                    'ns3::TypeId', 
  1819                    'ns3::TypeId', 
  1792                    [], 
  1820                    [], 
  1793                    is_static=True)
 
  1821                    is_static=True)
 
  1818     ## wifi-channel.h: void ns3::WifiChannel::Send(ns3::Ptr<ns3::WifiPhy> sender, ns3::Ptr<const ns3::Packet> packet, double txPowerDbm, ns3::WifiMode wifiMode, ns3::WifiPreamble preamble) const [member function]
 
  1846     ## wifi-channel.h: void ns3::WifiChannel::Send(ns3::Ptr<ns3::WifiPhy> sender, ns3::Ptr<const ns3::Packet> packet, double txPowerDbm, ns3::WifiMode wifiMode, ns3::WifiPreamble preamble) const [member function]
 
  1819     cls.add_method('Send', 
  1847     cls.add_method('Send', 
  1820                    'void', 
  1848                    'void', 
  1821                    [param('ns3::Ptr< ns3::WifiPhy >', 'sender'), param('ns3::Ptr< const ns3::Packet >', 'packet'), param('double', 'txPowerDbm'), param('ns3::WifiMode', 'wifiMode'), param('ns3::WifiPreamble', 'preamble')], 
  1849                    [param('ns3::Ptr< ns3::WifiPhy >', 'sender'), param('ns3::Ptr< const ns3::Packet >', 'packet'), param('double', 'txPowerDbm'), param('ns3::WifiMode', 'wifiMode'), param('ns3::WifiPreamble', 'preamble')], 
  1822                    is_const=True)
 
  1850                    is_const=True)
 
  1823     cls.add_copy_constructor()
 
       
  1824     return
 
  1851     return
 
  1825 
  1852 
  1826 def register_Ns3LogDistancePropagationLossModel_methods(root_module, cls):
 
  1853 def register_Ns3LogDistancePropagationLossModel_methods(root_module, cls):
 
       
  1854     ## propagation-loss-model.h: ns3::LogDistancePropagationLossModel::LogDistancePropagationLossModel(ns3::LogDistancePropagationLossModel const & arg0) [copy constructor]
 
       
  1855     cls.add_constructor([param('ns3::LogDistancePropagationLossModel&', 'arg0', is_const=True)])
 
  1827     ## propagation-loss-model.h: static ns3::TypeId ns3::LogDistancePropagationLossModel::GetTypeId() [member function]
 
  1856     ## propagation-loss-model.h: static ns3::TypeId ns3::LogDistancePropagationLossModel::GetTypeId() [member function]
 
  1828     cls.add_method('GetTypeId', 
  1857     cls.add_method('GetTypeId', 
  1829                    'ns3::TypeId', 
  1858                    'ns3::TypeId', 
  1830                    [], 
  1859                    [], 
  1831                    is_static=True)
 
  1860                    is_static=True)
 
  1851     ## propagation-loss-model.h: double ns3::LogDistancePropagationLossModel::GetLoss(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
 
  1880     ## propagation-loss-model.h: double ns3::LogDistancePropagationLossModel::GetLoss(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
 
  1852     cls.add_method('GetLoss', 
  1881     cls.add_method('GetLoss', 
  1853                    'double', 
  1882                    'double', 
  1854                    [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
  1883                    [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
  1855                    is_const=True, is_virtual=True)
 
  1884                    is_const=True, is_virtual=True)
 
  1856     cls.add_copy_constructor()
 
       
  1857     return
 
  1885     return
 
  1858 
  1886 
  1859 def register_Ns3ConstantRateWifiManager_methods(root_module, cls):
 
  1887 def register_Ns3ConstantRateWifiManager_methods(root_module, cls):
 
       
  1888     ## constant-rate-wifi-manager.h: ns3::ConstantRateWifiManager::ConstantRateWifiManager(ns3::ConstantRateWifiManager const & arg0) [copy constructor]
 
       
  1889     cls.add_constructor([param('ns3::ConstantRateWifiManager&', 'arg0', is_const=True)])
 
  1860     ## constant-rate-wifi-manager.h: static ns3::TypeId ns3::ConstantRateWifiManager::GetTypeId() [member function]
 
  1890     ## constant-rate-wifi-manager.h: static ns3::TypeId ns3::ConstantRateWifiManager::GetTypeId() [member function]
 
  1861     cls.add_method('GetTypeId', 
  1891     cls.add_method('GetTypeId', 
  1862                    'ns3::TypeId', 
  1892                    'ns3::TypeId', 
  1863                    [], 
  1893                    [], 
  1864                    is_static=True)
 
  1894                    is_static=True)
 
  1877     ## constant-rate-wifi-manager.h: ns3::WifiRemoteStation * ns3::ConstantRateWifiManager::CreateStation() [member function]
 
  1907     ## constant-rate-wifi-manager.h: ns3::WifiRemoteStation * ns3::ConstantRateWifiManager::CreateStation() [member function]
 
  1878     cls.add_method('CreateStation', 
  1908     cls.add_method('CreateStation', 
  1879                    'ns3::WifiRemoteStation *', 
  1909                    'ns3::WifiRemoteStation *', 
  1880                    [], 
  1910                    [], 
  1881                    visibility='private', is_virtual=True)
 
  1911                    visibility='private', is_virtual=True)
 
  1882     cls.add_copy_constructor()
 
       
  1883     return
 
  1912     return
 
  1884 
  1913 
  1885 def register_Ns3AarfWifiRemoteStation_methods(root_module, cls):
 
  1914 def register_Ns3AarfWifiRemoteStation_methods(root_module, cls):
 
       
  1915     ## aarf-wifi-manager.h: ns3::AarfWifiRemoteStation::AarfWifiRemoteStation(ns3::AarfWifiRemoteStation const & arg0) [copy constructor]
 
       
  1916     cls.add_constructor([param('ns3::AarfWifiRemoteStation&', 'arg0', is_const=True)])
 
  1886     ## 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]
 
  1917     ## 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]
 
  1887     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')])
 
  1918     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')])
 
  1888     ## aarf-wifi-manager.h: void ns3::AarfWifiRemoteStation::ReportRecoveryFailure() [member function]
 
  1919     ## aarf-wifi-manager.h: void ns3::AarfWifiRemoteStation::ReportRecoveryFailure() [member function]
 
  1889     cls.add_method('ReportRecoveryFailure', 
  1920     cls.add_method('ReportRecoveryFailure', 
  1890                    'void', 
  1921                    'void', 
  1893     ## aarf-wifi-manager.h: void ns3::AarfWifiRemoteStation::ReportFailure() [member function]
 
  1924     ## aarf-wifi-manager.h: void ns3::AarfWifiRemoteStation::ReportFailure() [member function]
 
  1894     cls.add_method('ReportFailure', 
  1925     cls.add_method('ReportFailure', 
  1895                    'void', 
  1926                    'void', 
  1896                    [], 
  1927                    [], 
  1897                    visibility='private', is_virtual=True)
 
  1928                    visibility='private', is_virtual=True)
 
  1898     cls.add_copy_constructor()
 
       
  1899     return
 
  1929     return
 
  1900 
  1930 
  1901 def register_Ns3PropagationDelayModel_methods(root_module, cls):
 
  1931 def register_Ns3PropagationDelayModel_methods(root_module, cls):
 
       
  1932     ## propagation-delay-model.h: ns3::PropagationDelayModel::PropagationDelayModel(ns3::PropagationDelayModel const & arg0) [copy constructor]
 
       
  1933     cls.add_constructor([param('ns3::PropagationDelayModel&', 'arg0', is_const=True)])
 
       
  1934     ## propagation-delay-model.h: ns3::PropagationDelayModel::PropagationDelayModel() [constructor]
 
       
  1935     cls.add_constructor([])
 
  1902     ## propagation-delay-model.h: static ns3::TypeId ns3::PropagationDelayModel::GetTypeId() [member function]
 
  1936     ## propagation-delay-model.h: static ns3::TypeId ns3::PropagationDelayModel::GetTypeId() [member function]
 
  1903     cls.add_method('GetTypeId', 
  1937     cls.add_method('GetTypeId', 
  1904                    'ns3::TypeId', 
  1938                    'ns3::TypeId', 
  1905                    [], 
  1939                    [], 
  1906                    is_static=True)
 
  1940                    is_static=True)
 
  1907     ## propagation-delay-model.h: ns3::Time ns3::PropagationDelayModel::GetDelay(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
 
  1941     ## propagation-delay-model.h: ns3::Time ns3::PropagationDelayModel::GetDelay(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
 
  1908     cls.add_method('GetDelay', 
  1942     cls.add_method('GetDelay', 
  1909                    'ns3::Time', 
  1943                    'ns3::Time', 
  1910                    [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
  1944                    [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
  1911                    is_pure_virtual=True, is_const=True, is_virtual=True)
 
  1945                    is_pure_virtual=True, is_const=True, is_virtual=True)
 
  1912     cls.add_constructor([])
 
       
  1913     cls.add_copy_constructor()
 
       
  1914     return
 
  1946     return
 
  1915 
  1947 
  1916 def register_Ns3AdhocWifiMac_methods(root_module, cls):
 
  1948 def register_Ns3AdhocWifiMac_methods(root_module, cls):
 
  1917     ## adhoc-wifi-mac.h: static ns3::TypeId ns3::AdhocWifiMac::GetTypeId() [member function]
 
  1949     ## adhoc-wifi-mac.h: static ns3::TypeId ns3::AdhocWifiMac::GetTypeId() [member function]
 
  1918     cls.add_method('GetTypeId', 
  1950     cls.add_method('GetTypeId', 
  2012                    [], 
  2044                    [], 
  2013                    visibility='private', is_virtual=True)
 
  2045                    visibility='private', is_virtual=True)
 
  2014     return
 
  2046     return
 
  2015 
  2047 
  2016 def register_Ns3JakesPropagationLossModel_methods(root_module, cls):
 
  2048 def register_Ns3JakesPropagationLossModel_methods(root_module, cls):
 
       
  2049     ## jakes-propagation-loss-model.h: ns3::JakesPropagationLossModel::JakesPropagationLossModel(ns3::JakesPropagationLossModel const & arg0) [copy constructor]
 
       
  2050     cls.add_constructor([param('ns3::JakesPropagationLossModel&', 'arg0', is_const=True)])
 
  2017     ## jakes-propagation-loss-model.h: static ns3::TypeId ns3::JakesPropagationLossModel::GetTypeId() [member function]
 
  2051     ## jakes-propagation-loss-model.h: static ns3::TypeId ns3::JakesPropagationLossModel::GetTypeId() [member function]
 
  2018     cls.add_method('GetTypeId', 
  2052     cls.add_method('GetTypeId', 
  2019                    'ns3::TypeId', 
  2053                    'ns3::TypeId', 
  2020                    [], 
  2054                    [], 
  2021                    is_static=True)
 
  2055                    is_static=True)
 
  2032                    [param('uint8_t', 'nRays')])
 
  2066                    [param('uint8_t', 'nRays')])
 
  2033     ## jakes-propagation-loss-model.h: void ns3::JakesPropagationLossModel::SetNOscillators(uint8_t nOscillators) [member function]
 
  2067     ## jakes-propagation-loss-model.h: void ns3::JakesPropagationLossModel::SetNOscillators(uint8_t nOscillators) [member function]
 
  2034     cls.add_method('SetNOscillators', 
  2068     cls.add_method('SetNOscillators', 
  2035                    'void', 
  2069                    'void', 
  2036                    [param('uint8_t', 'nOscillators')])
 
  2070                    [param('uint8_t', 'nOscillators')])
 
  2037     cls.add_copy_constructor()
 
       
  2038     return
 
  2071     return
 
  2039 
  2072 
  2040 def register_Ns3WifiNetDevice_methods(root_module, cls):
 
  2073 def register_Ns3WifiNetDevice_methods(root_module, cls):
 
       
  2074     ## wifi-net-device.h: ns3::WifiNetDevice::WifiNetDevice(ns3::WifiNetDevice const & arg0) [copy constructor]
 
       
  2075     cls.add_constructor([param('ns3::WifiNetDevice&', 'arg0', is_const=True)])
 
  2041     ## wifi-net-device.h: static ns3::TypeId ns3::WifiNetDevice::GetTypeId() [member function]
 
  2076     ## wifi-net-device.h: static ns3::TypeId ns3::WifiNetDevice::GetTypeId() [member function]
 
  2042     cls.add_method('GetTypeId', 
  2077     cls.add_method('GetTypeId', 
  2043                    'ns3::TypeId', 
  2078                    'ns3::TypeId', 
  2044                    [], 
  2079                    [], 
  2045                    is_static=True)
 
  2080                    is_static=True)
 
  2174     ## wifi-net-device.h: bool ns3::WifiNetDevice::NeedsArp() const [member function]
 
  2209     ## wifi-net-device.h: bool ns3::WifiNetDevice::NeedsArp() const [member function]
 
  2175     cls.add_method('NeedsArp', 
  2210     cls.add_method('NeedsArp', 
  2176                    'bool', 
  2211                    'bool', 
  2177                    [], 
  2212                    [], 
  2178                    is_const=True, is_virtual=True)
 
  2213                    is_const=True, is_virtual=True)
 
  2179     ## 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]
 
  2214     ## 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]
 
  2180     cls.add_method('SetReceiveCallback', 
  2215     cls.add_method('SetReceiveCallback', 
  2181                    'void', 
  2216                    'void', 
  2182                    [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr<const ns3::Packet >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], 
  2217                    [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], 
  2183                    is_virtual=True)
 
  2218                    is_virtual=True)
 
  2184     ## 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]
 
  2219     ## 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]
 
  2185     cls.add_method('SendFrom', 
  2220     cls.add_method('SendFrom', 
  2186                    'bool', 
  2221                    'bool', 
  2187                    [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address&', 'source', is_const=True), param('ns3::Address&', 'dest', is_const=True), param('uint16_t', 'protocolNumber')], 
  2222                    [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address&', 'source', is_const=True), param('ns3::Address&', 'dest', is_const=True), param('uint16_t', 'protocolNumber')], 
  2188                    is_virtual=True)
 
  2223                    is_virtual=True)
 
  2189     ## 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]
 
  2224     ## 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]
 
  2190     cls.add_method('SetPromiscReceiveCallback', 
  2225     cls.add_method('SetPromiscReceiveCallback', 
  2191                    'void', 
  2226                    'void', 
  2192                    [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')], 
  2227                    [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')], 
  2193                    is_virtual=True)
 
  2228                    is_virtual=True)
 
  2194     ## wifi-net-device.h: bool ns3::WifiNetDevice::SupportsPromiscuous() const [member function]
 
  2229     ## wifi-net-device.h: bool ns3::WifiNetDevice::SupportsPromiscuous() const [member function]
 
  2195     cls.add_method('SupportsPromiscuous', 
  2230     cls.add_method('SupportsPromiscuous', 
  2196                    'bool', 
  2231                    'bool', 
  2197                    [], 
  2232                    [], 
  2199     ## wifi-net-device.h: void ns3::WifiNetDevice::DoDispose() [member function]
 
  2234     ## wifi-net-device.h: void ns3::WifiNetDevice::DoDispose() [member function]
 
  2200     cls.add_method('DoDispose', 
  2235     cls.add_method('DoDispose', 
  2201                    'void', 
  2236                    'void', 
  2202                    [], 
  2237                    [], 
  2203                    visibility='private', is_virtual=True)
 
  2238                    visibility='private', is_virtual=True)
 
  2204     cls.add_copy_constructor()
 
       
  2205     return
 
  2239     return
 
  2206 
  2240 
  2207 def register_Ns3ConstantSpeedPropagationDelayModel_methods(root_module, cls):
 
  2241 def register_Ns3ConstantSpeedPropagationDelayModel_methods(root_module, cls):
 
       
  2242     ## propagation-delay-model.h: ns3::ConstantSpeedPropagationDelayModel::ConstantSpeedPropagationDelayModel(ns3::ConstantSpeedPropagationDelayModel const & arg0) [copy constructor]
 
       
  2243     cls.add_constructor([param('ns3::ConstantSpeedPropagationDelayModel&', 'arg0', is_const=True)])
 
  2208     ## propagation-delay-model.h: static ns3::TypeId ns3::ConstantSpeedPropagationDelayModel::GetTypeId() [member function]
 
  2244     ## propagation-delay-model.h: static ns3::TypeId ns3::ConstantSpeedPropagationDelayModel::GetTypeId() [member function]
 
  2209     cls.add_method('GetTypeId', 
  2245     cls.add_method('GetTypeId', 
  2210                    'ns3::TypeId', 
  2246                    'ns3::TypeId', 
  2211                    [], 
  2247                    [], 
  2212                    is_static=True)
 
  2248                    is_static=True)
 
  2224     ## propagation-delay-model.h: double ns3::ConstantSpeedPropagationDelayModel::GetSpeed() const [member function]
 
  2260     ## propagation-delay-model.h: double ns3::ConstantSpeedPropagationDelayModel::GetSpeed() const [member function]
 
  2225     cls.add_method('GetSpeed', 
  2261     cls.add_method('GetSpeed', 
  2226                    'double', 
  2262                    'double', 
  2227                    [], 
  2263                    [], 
  2228                    is_const=True)
 
  2264                    is_const=True)
 
  2229     cls.add_copy_constructor()
 
       
  2230     return
 
  2265     return
 
  2231 
  2266 
  2232 def register_Ns3RandomPropagationLossModel_methods(root_module, cls):
 
  2267 def register_Ns3RandomPropagationLossModel_methods(root_module, cls):
 
       
  2268     ## propagation-loss-model.h: ns3::RandomPropagationLossModel::RandomPropagationLossModel(ns3::RandomPropagationLossModel const & arg0) [copy constructor]
 
       
  2269     cls.add_constructor([param('ns3::RandomPropagationLossModel&', 'arg0', is_const=True)])
 
  2233     ## propagation-loss-model.h: static ns3::TypeId ns3::RandomPropagationLossModel::GetTypeId() [member function]
 
  2270     ## propagation-loss-model.h: static ns3::TypeId ns3::RandomPropagationLossModel::GetTypeId() [member function]
 
  2234     cls.add_method('GetTypeId', 
  2271     cls.add_method('GetTypeId', 
  2235                    'ns3::TypeId', 
  2272                    'ns3::TypeId', 
  2236                    [], 
  2273                    [], 
  2237                    is_static=True)
 
  2274                    is_static=True)
 
  2240     ## propagation-loss-model.h: double ns3::RandomPropagationLossModel::GetLoss(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
 
  2277     ## propagation-loss-model.h: double ns3::RandomPropagationLossModel::GetLoss(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
 
  2241     cls.add_method('GetLoss', 
  2278     cls.add_method('GetLoss', 
  2242                    'double', 
  2279                    'double', 
  2243                    [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
  2280                    [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
  2244                    is_const=True, is_virtual=True)
 
  2281                    is_const=True, is_virtual=True)
 
  2245     cls.add_copy_constructor()
 
       
  2246     return
 
  2282     return
 
  2247 
  2283 
  2248 def register_Ns3RandomPropagationDelayModel_methods(root_module, cls):
 
  2284 def register_Ns3RandomPropagationDelayModel_methods(root_module, cls):
 
       
  2285     ## propagation-delay-model.h: ns3::RandomPropagationDelayModel::RandomPropagationDelayModel(ns3::RandomPropagationDelayModel const & arg0) [copy constructor]
 
       
  2286     cls.add_constructor([param('ns3::RandomPropagationDelayModel&', 'arg0', is_const=True)])
 
  2249     ## propagation-delay-model.h: static ns3::TypeId ns3::RandomPropagationDelayModel::GetTypeId() [member function]
 
  2287     ## propagation-delay-model.h: static ns3::TypeId ns3::RandomPropagationDelayModel::GetTypeId() [member function]
 
  2250     cls.add_method('GetTypeId', 
  2288     cls.add_method('GetTypeId', 
  2251                    'ns3::TypeId', 
  2289                    'ns3::TypeId', 
  2252                    [], 
  2290                    [], 
  2253                    is_static=True)
 
  2291                    is_static=True)
 
  2256     ## propagation-delay-model.h: ns3::Time ns3::RandomPropagationDelayModel::GetDelay(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
 
  2294     ## propagation-delay-model.h: ns3::Time ns3::RandomPropagationDelayModel::GetDelay(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
 
  2257     cls.add_method('GetDelay', 
  2295     cls.add_method('GetDelay', 
  2258                    'ns3::Time', 
  2296                    'ns3::Time', 
  2259                    [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
  2297                    [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], 
  2260                    is_const=True, is_virtual=True)
 
  2298                    is_const=True, is_virtual=True)
 
  2261     cls.add_copy_constructor()
 
       
  2262     return
 
  2299     return
 
  2263 
  2300 
  2264 def register_Ns3AmrrWifiManager_methods(root_module, cls):
 
  2301 def register_Ns3AmrrWifiManager_methods(root_module, cls):
 
       
  2302     ## amrr-wifi-manager.h: ns3::AmrrWifiManager::AmrrWifiManager(ns3::AmrrWifiManager const & arg0) [copy constructor]
 
       
  2303     cls.add_constructor([param('ns3::AmrrWifiManager&', 'arg0', is_const=True)])
 
  2265     ## amrr-wifi-manager.h: static ns3::TypeId ns3::AmrrWifiManager::GetTypeId() [member function]
 
  2304     ## amrr-wifi-manager.h: static ns3::TypeId ns3::AmrrWifiManager::GetTypeId() [member function]
 
  2266     cls.add_method('GetTypeId', 
  2305     cls.add_method('GetTypeId', 
  2267                    'ns3::TypeId', 
  2306                    'ns3::TypeId', 
  2268                    [], 
  2307                    [], 
  2269                    is_static=True)
 
  2308                    is_static=True)
 
  2272     ## amrr-wifi-manager.h: ns3::WifiRemoteStation * ns3::AmrrWifiManager::CreateStation() [member function]
 
  2311     ## amrr-wifi-manager.h: ns3::WifiRemoteStation * ns3::AmrrWifiManager::CreateStation() [member function]
 
  2273     cls.add_method('CreateStation', 
  2312     cls.add_method('CreateStation', 
  2274                    'ns3::WifiRemoteStation *', 
  2313                    'ns3::WifiRemoteStation *', 
  2275                    [], 
  2314                    [], 
  2276                    visibility='private', is_virtual=True)
 
  2315                    visibility='private', is_virtual=True)
 
  2277     cls.add_copy_constructor()
 
       
  2278     return
 
  2316     return
 
  2279 
  2317 
  2280 def register_Ns3RraaWifiManager_methods(root_module, cls):
 
  2318 def register_Ns3RraaWifiManager_methods(root_module, cls):
 
       
  2319     ## rraa-wifi-manager.h: ns3::RraaWifiManager::RraaWifiManager(ns3::RraaWifiManager const & arg0) [copy constructor]
 
       
  2320     cls.add_constructor([param('ns3::RraaWifiManager&', 'arg0', is_const=True)])
 
  2281     ## rraa-wifi-manager.h: static ns3::TypeId ns3::RraaWifiManager::GetTypeId() [member function]
 
  2321     ## rraa-wifi-manager.h: static ns3::TypeId ns3::RraaWifiManager::GetTypeId() [member function]
 
  2282     cls.add_method('GetTypeId', 
  2322     cls.add_method('GetTypeId', 
  2283                    'ns3::TypeId', 
  2323                    'ns3::TypeId', 
  2284                    [], 
  2324                    [], 
  2285                    is_static=True)
 
  2325                    is_static=True)
 
  2302     ## rraa-wifi-manager.h: ns3::WifiRemoteStation * ns3::RraaWifiManager::CreateStation() [member function]
 
  2342     ## rraa-wifi-manager.h: ns3::WifiRemoteStation * ns3::RraaWifiManager::CreateStation() [member function]
 
  2303     cls.add_method('CreateStation', 
  2343     cls.add_method('CreateStation', 
  2304                    'ns3::WifiRemoteStation *', 
  2344                    'ns3::WifiRemoteStation *', 
  2305                    [], 
  2345                    [], 
  2306                    visibility='private', is_virtual=True)
 
  2346                    visibility='private', is_virtual=True)
 
  2307     cls.add_copy_constructor()
 
       
  2308     return
 
  2347     return
 
  2309 
  2348 
  2310 def register_Ns3IdealWifiManager_methods(root_module, cls):
 
  2349 def register_Ns3IdealWifiManager_methods(root_module, cls):
 
       
  2350     ## ideal-wifi-manager.h: ns3::IdealWifiManager::IdealWifiManager(ns3::IdealWifiManager const & arg0) [copy constructor]
 
       
  2351     cls.add_constructor([param('ns3::IdealWifiManager&', 'arg0', is_const=True)])
 
  2311     ## ideal-wifi-manager.h: static ns3::TypeId ns3::IdealWifiManager::GetTypeId() [member function]
 
  2352     ## ideal-wifi-manager.h: static ns3::TypeId ns3::IdealWifiManager::GetTypeId() [member function]
 
  2312     cls.add_method('GetTypeId', 
  2353     cls.add_method('GetTypeId', 
  2313                    'ns3::TypeId', 
  2354                    'ns3::TypeId', 
  2314                    [], 
  2355                    [], 
  2315                    is_static=True)
 
  2356                    is_static=True)
 
  2332     ## ideal-wifi-manager.h: ns3::WifiRemoteStation * ns3::IdealWifiManager::CreateStation() [member function]
 
  2373     ## ideal-wifi-manager.h: ns3::WifiRemoteStation * ns3::IdealWifiManager::CreateStation() [member function]
 
  2333     cls.add_method('CreateStation', 
  2374     cls.add_method('CreateStation', 
  2334                    'ns3::WifiRemoteStation *', 
  2375                    'ns3::WifiRemoteStation *', 
  2335                    [], 
  2376                    [], 
  2336                    visibility='private', is_virtual=True)
 
  2377                    visibility='private', is_virtual=True)
 
  2337     cls.add_copy_constructor()
 
       
  2338     return
 
  2378     return
 
  2339 
  2379 
  2340 def register_Ns3ArfWifiManager_methods(root_module, cls):
 
  2380 def register_Ns3ArfWifiManager_methods(root_module, cls):
 
       
  2381     ## arf-wifi-manager.h: ns3::ArfWifiManager::ArfWifiManager(ns3::ArfWifiManager const & arg0) [copy constructor]
 
       
  2382     cls.add_constructor([param('ns3::ArfWifiManager&', 'arg0', is_const=True)])
 
  2341     ## arf-wifi-manager.h: static ns3::TypeId ns3::ArfWifiManager::GetTypeId() [member function]
 
  2383     ## arf-wifi-manager.h: static ns3::TypeId ns3::ArfWifiManager::GetTypeId() [member function]
 
  2342     cls.add_method('GetTypeId', 
  2384     cls.add_method('GetTypeId', 
  2343                    'ns3::TypeId', 
  2385                    'ns3::TypeId', 
  2344                    [], 
  2386                    [], 
  2345                    is_static=True)
 
  2387                    is_static=True)
 
  2348     ## arf-wifi-manager.h: ns3::WifiRemoteStation * ns3::ArfWifiManager::CreateStation() [member function]
 
  2390     ## arf-wifi-manager.h: ns3::WifiRemoteStation * ns3::ArfWifiManager::CreateStation() [member function]
 
  2349     cls.add_method('CreateStation', 
  2391     cls.add_method('CreateStation', 
  2350                    'ns3::WifiRemoteStation *', 
  2392                    'ns3::WifiRemoteStation *', 
  2351                    [], 
  2393                    [], 
  2352                    visibility='private', is_virtual=True)
 
  2394                    visibility='private', is_virtual=True)
 
  2353     cls.add_copy_constructor()
 
       
  2354     return
 
  2395     return
 
  2355 
  2396 
  2356 def register_Ns3AarfWifiManager_methods(root_module, cls):
 
  2397 def register_Ns3AarfWifiManager_methods(root_module, cls):
 
       
  2398     ## aarf-wifi-manager.h: ns3::AarfWifiManager::AarfWifiManager(ns3::AarfWifiManager const & arg0) [copy constructor]
 
       
  2399     cls.add_constructor([param('ns3::AarfWifiManager&', 'arg0', is_const=True)])
 
  2357     ## aarf-wifi-manager.h: static ns3::TypeId ns3::AarfWifiManager::GetTypeId() [member function]
 
  2400     ## aarf-wifi-manager.h: static ns3::TypeId ns3::AarfWifiManager::GetTypeId() [member function]
 
  2358     cls.add_method('GetTypeId', 
  2401     cls.add_method('GetTypeId', 
  2359                    'ns3::TypeId', 
  2402                    'ns3::TypeId', 
  2360                    [], 
  2403                    [], 
  2361                    is_static=True)
 
  2404                    is_static=True)
 
  2364     ## aarf-wifi-manager.h: ns3::WifiRemoteStation * ns3::AarfWifiManager::CreateStation() [member function]
 
  2407     ## aarf-wifi-manager.h: ns3::WifiRemoteStation * ns3::AarfWifiManager::CreateStation() [member function]
 
  2365     cls.add_method('CreateStation', 
  2408     cls.add_method('CreateStation', 
  2366                    'ns3::WifiRemoteStation *', 
  2409                    'ns3::WifiRemoteStation *', 
  2367                    [], 
  2410                    [], 
  2368                    visibility='private', is_virtual=True)
 
  2411                    visibility='private', is_virtual=True)
 
  2369     cls.add_copy_constructor()
 
       
  2370     return
 
  2412     return
 
  2371 
  2413 
  2372 def register_functions(root_module):
 
  2414 def register_functions(root_module):
 
  2373     module = root_module
 
  2415     module = root_module
 
  2374     ## wifi-mode.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeWifiModeChecker() [free function]
 
  2416     ## wifi-mode.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeWifiModeChecker() [free function]
ns-3.5