Mercurial Mercurial > ns-3.24 / 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/apidefs/gcc-LP64/ns3_module_helper.py
changeset 6027 8ed838dd0be5
parent 6014 d251d4a44fde
child 6028 96fb92f73f3d
equal deleted inserted replaced
6026:38a97b815052 6027:8ed838dd0be5 
     7     module.add_class('AnimationInterface')
 
     7     module.add_class('AnimationInterface')
 
     8     ## application-container.h: ns3::ApplicationContainer [class]
 
     8     ## application-container.h: ns3::ApplicationContainer [class]
 
     9     module.add_class('ApplicationContainer')
 
     9     module.add_class('ApplicationContainer')
 
    10     ## ascii-trace-helper.h: ns3::AsciiTraceHelper [class]
 
    10     ## ascii-trace-helper.h: ns3::AsciiTraceHelper [class]
 
    11     module.add_class('AsciiTraceHelper', allow_subclassing=False)
 
    11     module.add_class('AsciiTraceHelper', allow_subclassing=False)
 
    12     ## ascii-trace-user-helper-for-device.h: ns3::AsciiTraceUserHelperForDevice [class]
 
    12     ## ascii-trace-helper.h: ns3::AsciiTraceUserHelperForDevice [class]
 
    13     module.add_class('AsciiTraceUserHelperForDevice', allow_subclassing=True)
 
    13     module.add_class('AsciiTraceUserHelperForDevice', allow_subclassing=True)
 
    14     ## ascii-trace-user-helper-for-ipv4.h: ns3::AsciiTraceUserHelperForIpv4 [class]
 
    14     ## ascii-trace-helper.h: ns3::AsciiTraceUserHelperForIpv4 [class]
 
    15     module.add_class('AsciiTraceUserHelperForIpv4', allow_subclassing=True)
 
    15     module.add_class('AsciiTraceUserHelperForIpv4', allow_subclassing=True)
 
       
    16     ## ascii-trace-helper.h: ns3::AsciiTraceUserHelperForIpv6 [class]
 
       
    17     module.add_class('AsciiTraceUserHelperForIpv6', allow_subclassing=True)
 
    16     ## athstats-helper.h: ns3::AthstatsHelper [class]
 
    18     ## athstats-helper.h: ns3::AthstatsHelper [class]
 
    17     module.add_class('AthstatsHelper', allow_subclassing=False)
 
    19     module.add_class('AthstatsHelper', allow_subclassing=False)
 
    18     ## bridge-helper.h: ns3::BridgeHelper [class]
 
    20     ## bridge-helper.h: ns3::BridgeHelper [class]
 
    19     module.add_class('BridgeHelper', allow_subclassing=False)
 
    21     module.add_class('BridgeHelper', allow_subclassing=False)
 
    20     ## csma-star-helper.h: ns3::CsmaStarHelper [class]
 
    22     ## csma-star-helper.h: ns3::CsmaStarHelper [class]
 
    71     module.add_enum('', ['DLT_IEEE802_11'], outer_class=root_module['ns3::PcapHelper'])
 
    73     module.add_enum('', ['DLT_IEEE802_11'], outer_class=root_module['ns3::PcapHelper'])
 
    72     ## pcap-helper.h: ns3::PcapHelper [enumeration]
 
    74     ## pcap-helper.h: ns3::PcapHelper [enumeration]
 
    73     module.add_enum('', ['DLT_PRISM_HEADER'], outer_class=root_module['ns3::PcapHelper'])
 
    75     module.add_enum('', ['DLT_PRISM_HEADER'], outer_class=root_module['ns3::PcapHelper'])
 
    74     ## pcap-helper.h: ns3::PcapHelper [enumeration]
 
    76     ## pcap-helper.h: ns3::PcapHelper [enumeration]
 
    75     module.add_enum('', ['DLT_IEEE802_11_RADIO'], outer_class=root_module['ns3::PcapHelper'])
 
    77     module.add_enum('', ['DLT_IEEE802_11_RADIO'], outer_class=root_module['ns3::PcapHelper'])
 
    76     ## pcap-user-helper-for-device.h: ns3::PcapUserHelperForDevice [class]
 
    78     ## pcap-helper.h: ns3::PcapUserHelperForDevice [class]
 
    77     module.add_class('PcapUserHelperForDevice', allow_subclassing=True)
 
    79     module.add_class('PcapUserHelperForDevice', allow_subclassing=True)
 
    78     ## pcap-user-helper-for-ipv4.h: ns3::PcapUserHelperForIpv4 [class]
 
    80     ## pcap-helper.h: ns3::PcapUserHelperForIpv4 [class]
 
    79     module.add_class('PcapUserHelperForIpv4', allow_subclassing=True)
 
    81     module.add_class('PcapUserHelperForIpv4', allow_subclassing=True)
 
       
    82     ## pcap-helper.h: ns3::PcapUserHelperForIpv6 [class]
 
       
    83     module.add_class('PcapUserHelperForIpv6', allow_subclassing=True)
 
    80     ## ping6-helper.h: ns3::Ping6Helper [class]
 
    84     ## ping6-helper.h: ns3::Ping6Helper [class]
 
    81     module.add_class('Ping6Helper', allow_subclassing=False)
 
    85     module.add_class('Ping6Helper', allow_subclassing=False)
 
    82     ## point-to-point-dumbbell-helper.h: ns3::PointToPointDumbbellHelper [class]
 
    86     ## point-to-point-dumbbell-helper.h: ns3::PointToPointDumbbellHelper [class]
 
    83     module.add_class('PointToPointDumbbellHelper', allow_subclassing=False)
 
    87     module.add_class('PointToPointDumbbellHelper', allow_subclassing=False)
 
    84     ## point-to-point-grid-helper.h: ns3::PointToPointGridHelper [class]
 
    88     ## point-to-point-grid-helper.h: ns3::PointToPointGridHelper [class]
 
   216     register_Ns3AnimationInterface_methods(root_module, root_module['ns3::AnimationInterface'])
 
   220     register_Ns3AnimationInterface_methods(root_module, root_module['ns3::AnimationInterface'])
 
   217     register_Ns3ApplicationContainer_methods(root_module, root_module['ns3::ApplicationContainer'])
 
   221     register_Ns3ApplicationContainer_methods(root_module, root_module['ns3::ApplicationContainer'])
 
   218     register_Ns3AsciiTraceHelper_methods(root_module, root_module['ns3::AsciiTraceHelper'])
 
   222     register_Ns3AsciiTraceHelper_methods(root_module, root_module['ns3::AsciiTraceHelper'])
 
   219     register_Ns3AsciiTraceUserHelperForDevice_methods(root_module, root_module['ns3::AsciiTraceUserHelperForDevice'])
 
   223     register_Ns3AsciiTraceUserHelperForDevice_methods(root_module, root_module['ns3::AsciiTraceUserHelperForDevice'])
 
   220     register_Ns3AsciiTraceUserHelperForIpv4_methods(root_module, root_module['ns3::AsciiTraceUserHelperForIpv4'])
 
   224     register_Ns3AsciiTraceUserHelperForIpv4_methods(root_module, root_module['ns3::AsciiTraceUserHelperForIpv4'])
 
       
   225     register_Ns3AsciiTraceUserHelperForIpv6_methods(root_module, root_module['ns3::AsciiTraceUserHelperForIpv6'])
 
   221     register_Ns3AthstatsHelper_methods(root_module, root_module['ns3::AthstatsHelper'])
 
   226     register_Ns3AthstatsHelper_methods(root_module, root_module['ns3::AthstatsHelper'])
 
   222     register_Ns3BridgeHelper_methods(root_module, root_module['ns3::BridgeHelper'])
 
   227     register_Ns3BridgeHelper_methods(root_module, root_module['ns3::BridgeHelper'])
 
   223     register_Ns3CsmaStarHelper_methods(root_module, root_module['ns3::CsmaStarHelper'])
 
   228     register_Ns3CsmaStarHelper_methods(root_module, root_module['ns3::CsmaStarHelper'])
 
   224     register_Ns3FlowMonitorHelper_methods(root_module, root_module['ns3::FlowMonitorHelper'])
 
   229     register_Ns3FlowMonitorHelper_methods(root_module, root_module['ns3::FlowMonitorHelper'])
 
   225     register_Ns3Ipv4AddressHelper_methods(root_module, root_module['ns3::Ipv4AddressHelper'])
 
   230     register_Ns3Ipv4AddressHelper_methods(root_module, root_module['ns3::Ipv4AddressHelper'])
 
   240     register_Ns3PacketSinkHelper_methods(root_module, root_module['ns3::PacketSinkHelper'])
 
   245     register_Ns3PacketSinkHelper_methods(root_module, root_module['ns3::PacketSinkHelper'])
 
   241     register_Ns3PacketSocketHelper_methods(root_module, root_module['ns3::PacketSocketHelper'])
 
   246     register_Ns3PacketSocketHelper_methods(root_module, root_module['ns3::PacketSocketHelper'])
 
   242     register_Ns3PcapHelper_methods(root_module, root_module['ns3::PcapHelper'])
 
   247     register_Ns3PcapHelper_methods(root_module, root_module['ns3::PcapHelper'])
 
   243     register_Ns3PcapUserHelperForDevice_methods(root_module, root_module['ns3::PcapUserHelperForDevice'])
 
   248     register_Ns3PcapUserHelperForDevice_methods(root_module, root_module['ns3::PcapUserHelperForDevice'])
 
   244     register_Ns3PcapUserHelperForIpv4_methods(root_module, root_module['ns3::PcapUserHelperForIpv4'])
 
   249     register_Ns3PcapUserHelperForIpv4_methods(root_module, root_module['ns3::PcapUserHelperForIpv4'])
 
       
   250     register_Ns3PcapUserHelperForIpv6_methods(root_module, root_module['ns3::PcapUserHelperForIpv6'])
 
   245     register_Ns3Ping6Helper_methods(root_module, root_module['ns3::Ping6Helper'])
 
   251     register_Ns3Ping6Helper_methods(root_module, root_module['ns3::Ping6Helper'])
 
   246     register_Ns3PointToPointDumbbellHelper_methods(root_module, root_module['ns3::PointToPointDumbbellHelper'])
 
   252     register_Ns3PointToPointDumbbellHelper_methods(root_module, root_module['ns3::PointToPointDumbbellHelper'])
 
   247     register_Ns3PointToPointGridHelper_methods(root_module, root_module['ns3::PointToPointGridHelper'])
 
   253     register_Ns3PointToPointGridHelper_methods(root_module, root_module['ns3::PointToPointGridHelper'])
 
   248     register_Ns3PointToPointStarHelper_methods(root_module, root_module['ns3::PointToPointStarHelper'])
 
   254     register_Ns3PointToPointStarHelper_methods(root_module, root_module['ns3::PointToPointStarHelper'])
 
   249     register_Ns3TapBridgeHelper_methods(root_module, root_module['ns3::TapBridgeHelper'])
 
   255     register_Ns3TapBridgeHelper_methods(root_module, root_module['ns3::TapBridgeHelper'])
 
   396                    is_static=True)
 
   402                    is_static=True)
 
   397     ## ascii-trace-helper.h: std::string ns3::AsciiTraceHelper::GetFilenameFromDevice(std::string prefix, ns3::Ptr<ns3::NetDevice> device, bool useObjectNames=true) [member function]
 
   403     ## ascii-trace-helper.h: std::string ns3::AsciiTraceHelper::GetFilenameFromDevice(std::string prefix, ns3::Ptr<ns3::NetDevice> device, bool useObjectNames=true) [member function]
 
   398     cls.add_method('GetFilenameFromDevice', 
   404     cls.add_method('GetFilenameFromDevice', 
   399                    'std::string', 
   405                    'std::string', 
   400                    [param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'useObjectNames', default_value='true')])
 
   406                    [param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'useObjectNames', default_value='true')])
 
   401     ## ascii-trace-helper.h: std::string ns3::AsciiTraceHelper::GetFilenameFromInterfacePair(std::string prefix, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface, bool useObjectNames=true) [member function]
 
   407     ## ascii-trace-helper.h: std::string ns3::AsciiTraceHelper::GetFilenameFromInterfacePair(std::string prefix, ns3::Ptr<ns3::Object> object, uint32_t interface, bool useObjectNames=true) [member function]
 
   402     cls.add_method('GetFilenameFromInterfacePair', 
   408     cls.add_method('GetFilenameFromInterfacePair', 
   403                    'std::string', 
   409                    'std::string', 
   404                    [param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface'), param('bool', 'useObjectNames', default_value='true')])
 
   410                    [param('std::string', 'prefix'), param('ns3::Ptr< ns3::Object >', 'object'), param('uint32_t', 'interface'), param('bool', 'useObjectNames', default_value='true')])
 
   405     return
 
   411     return
 
   406 
   412 
   407 def register_Ns3AsciiTraceUserHelperForDevice_methods(root_module, cls):
 
   413 def register_Ns3AsciiTraceUserHelperForDevice_methods(root_module, cls):
 
   408     ## ascii-trace-user-helper-for-device.h: ns3::AsciiTraceUserHelperForDevice::AsciiTraceUserHelperForDevice() [constructor]
 
   414     ## ascii-trace-helper.h: ns3::AsciiTraceUserHelperForDevice::AsciiTraceUserHelperForDevice() [constructor]
 
   409     cls.add_constructor([])
 
   415     cls.add_constructor([])
 
   410     ## ascii-trace-user-helper-for-device.h: ns3::AsciiTraceUserHelperForDevice::AsciiTraceUserHelperForDevice(ns3::AsciiTraceUserHelperForDevice const & arg0) [copy constructor]
 
   416     ## ascii-trace-helper.h: ns3::AsciiTraceUserHelperForDevice::AsciiTraceUserHelperForDevice(ns3::AsciiTraceUserHelperForDevice const & arg0) [copy constructor]
 
   411     cls.add_constructor([param('ns3::AsciiTraceUserHelperForDevice const &', 'arg0')])
 
   417     cls.add_constructor([param('ns3::AsciiTraceUserHelperForDevice const &', 'arg0')])
 
   412     ## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, ns3::Ptr<ns3::NetDevice> nd) [member function]
 
   418     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, ns3::Ptr<ns3::NetDevice> nd) [member function]
 
   413     cls.add_method('EnableAscii', 
   419     cls.add_method('EnableAscii', 
   414                    'void', 
   420                    'void', 
   415                    [param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd')])
 
   421                    [param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd')])
 
   416     ## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::Ptr<ns3::NetDevice> nd) [member function]
 
   422     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::Ptr<ns3::NetDevice> nd) [member function]
 
   417     cls.add_method('EnableAscii', 
   423     cls.add_method('EnableAscii', 
   418                    'void', 
   424                    'void', 
   419                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::Ptr< ns3::NetDevice >', 'nd')])
 
   425                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::Ptr< ns3::NetDevice >', 'nd')])
 
   420     ## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, std::string ndName) [member function]
 
   426     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, std::string ndName) [member function]
 
   421     cls.add_method('EnableAscii', 
   427     cls.add_method('EnableAscii', 
   422                    'void', 
   428                    'void', 
   423                    [param('std::string', 'prefix'), param('std::string', 'ndName')])
 
   429                    [param('std::string', 'prefix'), param('std::string', 'ndName')])
 
   424     ## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, std::string ndName) [member function]
 
   430     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, std::string ndName) [member function]
 
   425     cls.add_method('EnableAscii', 
   431     cls.add_method('EnableAscii', 
   426                    'void', 
   432                    'void', 
   427                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('std::string', 'ndName')])
 
   433                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('std::string', 'ndName')])
 
   428     ## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, ns3::NetDeviceContainer d) [member function]
 
   434     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, ns3::NetDeviceContainer d) [member function]
 
   429     cls.add_method('EnableAscii', 
   435     cls.add_method('EnableAscii', 
   430                    'void', 
   436                    'void', 
   431                    [param('std::string', 'prefix'), param('ns3::NetDeviceContainer', 'd')])
 
   437                    [param('std::string', 'prefix'), param('ns3::NetDeviceContainer', 'd')])
 
   432     ## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::NetDeviceContainer d) [member function]
 
   438     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::NetDeviceContainer d) [member function]
 
   433     cls.add_method('EnableAscii', 
   439     cls.add_method('EnableAscii', 
   434                    'void', 
   440                    'void', 
   435                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::NetDeviceContainer', 'd')])
 
   441                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::NetDeviceContainer', 'd')])
 
   436     ## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, ns3::NodeContainer n) [member function]
 
   442     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, ns3::NodeContainer n) [member function]
 
   437     cls.add_method('EnableAscii', 
   443     cls.add_method('EnableAscii', 
   438                    'void', 
   444                    'void', 
   439                    [param('std::string', 'prefix'), param('ns3::NodeContainer', 'n')])
 
   445                    [param('std::string', 'prefix'), param('ns3::NodeContainer', 'n')])
 
   440     ## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::NodeContainer n) [member function]
 
   446     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::NodeContainer n) [member function]
 
   441     cls.add_method('EnableAscii', 
   447     cls.add_method('EnableAscii', 
   442                    'void', 
   448                    'void', 
   443                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::NodeContainer', 'n')])
 
   449                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::NodeContainer', 'n')])
 
   444     ## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, uint32_t nodeid, uint32_t deviceid) [member function]
 
   450     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, uint32_t nodeid, uint32_t deviceid) [member function]
 
   445     cls.add_method('EnableAscii', 
   451     cls.add_method('EnableAscii', 
   446                    'void', 
   452                    'void', 
   447                    [param('std::string', 'prefix'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')])
 
   453                    [param('std::string', 'prefix'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')])
 
   448     ## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, uint32_t nodeid, uint32_t deviceid) [member function]
 
   454     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, uint32_t nodeid, uint32_t deviceid) [member function]
 
   449     cls.add_method('EnableAscii', 
   455     cls.add_method('EnableAscii', 
   450                    'void', 
   456                    'void', 
   451                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')])
 
   457                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')])
 
   452     ## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAsciiAll(std::string prefix) [member function]
 
   458     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAsciiAll(std::string prefix) [member function]
 
   453     cls.add_method('EnableAsciiAll', 
   459     cls.add_method('EnableAsciiAll', 
   454                    'void', 
   460                    'void', 
   455                    [param('std::string', 'prefix')])
 
   461                    [param('std::string', 'prefix')])
 
   456     ## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAsciiAll(ns3::Ptr<ns3::OutputStreamObject> stream) [member function]
 
   462     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAsciiAll(ns3::Ptr<ns3::OutputStreamObject> stream) [member function]
 
   457     cls.add_method('EnableAsciiAll', 
   463     cls.add_method('EnableAsciiAll', 
   458                    'void', 
   464                    'void', 
   459                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream')])
 
   465                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream')])
 
   460     ## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAsciiInternal(ns3::Ptr<ns3::OutputStreamObject> stream, std::string prefix, ns3::Ptr<ns3::NetDevice> nd) [member function]
 
   466     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAsciiInternal(ns3::Ptr<ns3::OutputStreamObject> stream, std::string prefix, ns3::Ptr<ns3::NetDevice> nd) [member function]
 
   461     cls.add_method('EnableAsciiInternal', 
   467     cls.add_method('EnableAsciiInternal', 
   462                    'void', 
   468                    'void', 
   463                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd')], 
   469                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd')], 
   464                    is_pure_virtual=True, is_virtual=True)
 
   470                    is_pure_virtual=True, is_virtual=True)
 
   465     return
 
   471     return
 
   466 
   472 
   467 def register_Ns3AsciiTraceUserHelperForIpv4_methods(root_module, cls):
 
   473 def register_Ns3AsciiTraceUserHelperForIpv4_methods(root_module, cls):
 
   468     ## ascii-trace-user-helper-for-ipv4.h: ns3::AsciiTraceUserHelperForIpv4::AsciiTraceUserHelperForIpv4() [constructor]
 
   474     ## ascii-trace-helper.h: ns3::AsciiTraceUserHelperForIpv4::AsciiTraceUserHelperForIpv4() [constructor]
 
   469     cls.add_constructor([])
 
   475     cls.add_constructor([])
 
   470     ## ascii-trace-user-helper-for-ipv4.h: ns3::AsciiTraceUserHelperForIpv4::AsciiTraceUserHelperForIpv4(ns3::AsciiTraceUserHelperForIpv4 const & arg0) [copy constructor]
 
   476     ## ascii-trace-helper.h: ns3::AsciiTraceUserHelperForIpv4::AsciiTraceUserHelperForIpv4(ns3::AsciiTraceUserHelperForIpv4 const & arg0) [copy constructor]
 
   471     cls.add_constructor([param('ns3::AsciiTraceUserHelperForIpv4 const &', 'arg0')])
 
   477     cls.add_constructor([param('ns3::AsciiTraceUserHelperForIpv4 const &', 'arg0')])
 
   472     ## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(std::string prefix, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface) [member function]
 
   478     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(std::string prefix, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface) [member function]
 
   473     cls.add_method('EnableAscii', 
   479     cls.add_method('EnableAsciiIpv4', 
   474                    'void', 
   480                    'void', 
   475                    [param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')])
 
   481                    [param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')])
 
   476     ## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface) [member function]
 
   482     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface) [member function]
 
   477     cls.add_method('EnableAscii', 
   483     cls.add_method('EnableAsciiIpv4', 
   478                    'void', 
   484                    'void', 
   479                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')])
 
   485                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')])
 
   480     ## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(std::string prefix, std::string ipv4Name, uint32_t interface) [member function]
 
   486     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(std::string prefix, std::string ipv4Name, uint32_t interface) [member function]
 
   481     cls.add_method('EnableAscii', 
   487     cls.add_method('EnableAsciiIpv4', 
   482                    'void', 
   488                    'void', 
   483                    [param('std::string', 'prefix'), param('std::string', 'ipv4Name'), param('uint32_t', 'interface')])
 
   489                    [param('std::string', 'prefix'), param('std::string', 'ipv4Name'), param('uint32_t', 'interface')])
 
   484     ## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, std::string ipv4Name, uint32_t interface) [member function]
 
   490     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(ns3::Ptr<ns3::OutputStreamObject> stream, std::string ipv4Name, uint32_t interface) [member function]
 
   485     cls.add_method('EnableAscii', 
   491     cls.add_method('EnableAsciiIpv4', 
   486                    'void', 
   492                    'void', 
   487                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('std::string', 'ipv4Name'), param('uint32_t', 'interface')])
 
   493                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('std::string', 'ipv4Name'), param('uint32_t', 'interface')])
 
   488     ## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(std::string prefix, ns3::Ipv4InterfaceContainer c) [member function]
 
   494     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(std::string prefix, ns3::Ipv4InterfaceContainer c) [member function]
 
   489     cls.add_method('EnableAscii', 
   495     cls.add_method('EnableAsciiIpv4', 
   490                    'void', 
   496                    'void', 
   491                    [param('std::string', 'prefix'), param('ns3::Ipv4InterfaceContainer', 'c')])
 
   497                    [param('std::string', 'prefix'), param('ns3::Ipv4InterfaceContainer', 'c')])
 
   492     ## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::Ipv4InterfaceContainer c) [member function]
 
   498     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::Ipv4InterfaceContainer c) [member function]
 
   493     cls.add_method('EnableAscii', 
   499     cls.add_method('EnableAsciiIpv4', 
   494                    'void', 
   500                    'void', 
   495                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::Ipv4InterfaceContainer', 'c')])
 
   501                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::Ipv4InterfaceContainer', 'c')])
 
   496     ## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(std::string prefix, ns3::NodeContainer n) [member function]
 
   502     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(std::string prefix, ns3::NodeContainer n) [member function]
 
   497     cls.add_method('EnableAscii', 
   503     cls.add_method('EnableAsciiIpv4', 
   498                    'void', 
   504                    'void', 
   499                    [param('std::string', 'prefix'), param('ns3::NodeContainer', 'n')])
 
   505                    [param('std::string', 'prefix'), param('ns3::NodeContainer', 'n')])
 
   500     ## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::NodeContainer n) [member function]
 
   506     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::NodeContainer n) [member function]
 
   501     cls.add_method('EnableAscii', 
   507     cls.add_method('EnableAsciiIpv4', 
   502                    'void', 
   508                    'void', 
   503                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::NodeContainer', 'n')])
 
   509                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::NodeContainer', 'n')])
 
   504     ## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(std::string prefix, uint32_t nodeid, uint32_t deviceid) [member function]
 
   510     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(std::string prefix, uint32_t nodeid, uint32_t deviceid) [member function]
 
   505     cls.add_method('EnableAscii', 
   511     cls.add_method('EnableAsciiIpv4', 
   506                    'void', 
   512                    'void', 
   507                    [param('std::string', 'prefix'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')])
 
   513                    [param('std::string', 'prefix'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')])
 
   508     ## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, uint32_t nodeid, uint32_t interface) [member function]
 
   514     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(ns3::Ptr<ns3::OutputStreamObject> stream, uint32_t nodeid, uint32_t interface) [member function]
 
   509     cls.add_method('EnableAscii', 
   515     cls.add_method('EnableAsciiIpv4', 
   510                    'void', 
   516                    'void', 
   511                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('uint32_t', 'nodeid'), param('uint32_t', 'interface')])
 
   517                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('uint32_t', 'nodeid'), param('uint32_t', 'interface')])
 
   512     ## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiAll(std::string prefix) [member function]
 
   518     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4All(std::string prefix) [member function]
 
   513     cls.add_method('EnableAsciiAll', 
   519     cls.add_method('EnableAsciiIpv4All', 
   514                    'void', 
   520                    'void', 
   515                    [param('std::string', 'prefix')])
 
   521                    [param('std::string', 'prefix')])
 
   516     ## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiAll(ns3::Ptr<ns3::OutputStreamObject> stream) [member function]
 
   522     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4All(ns3::Ptr<ns3::OutputStreamObject> stream) [member function]
 
   517     cls.add_method('EnableAsciiAll', 
   523     cls.add_method('EnableAsciiIpv4All', 
   518                    'void', 
   524                    'void', 
   519                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream')])
 
   525                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream')])
 
   520     ## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiInternal(ns3::Ptr<ns3::OutputStreamObject> stream, std::string prefix, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface) [member function]
 
   526     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4Internal(ns3::Ptr<ns3::OutputStreamObject> stream, std::string prefix, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface) [member function]
 
   521     cls.add_method('EnableAsciiInternal', 
   527     cls.add_method('EnableAsciiIpv4Internal', 
   522                    'void', 
   528                    'void', 
   523                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')], 
   529                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')], 
       
   530                    is_pure_virtual=True, is_virtual=True)
 
       
   531     return
 
       
   532 
       
   533 def register_Ns3AsciiTraceUserHelperForIpv6_methods(root_module, cls):
 
       
   534     ## ascii-trace-helper.h: ns3::AsciiTraceUserHelperForIpv6::AsciiTraceUserHelperForIpv6() [constructor]
 
       
   535     cls.add_constructor([])
 
       
   536     ## ascii-trace-helper.h: ns3::AsciiTraceUserHelperForIpv6::AsciiTraceUserHelperForIpv6(ns3::AsciiTraceUserHelperForIpv6 const & arg0) [copy constructor]
 
       
   537     cls.add_constructor([param('ns3::AsciiTraceUserHelperForIpv6 const &', 'arg0')])
 
       
   538     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(std::string prefix, ns3::Ptr<ns3::Ipv6> ipv6, uint32_t interface) [member function]
 
       
   539     cls.add_method('EnableAsciiIpv6', 
       
   540                    'void', 
       
   541                    [param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv6 >', 'ipv6'), param('uint32_t', 'interface')])
 
       
   542     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::Ptr<ns3::Ipv6> ipv6, uint32_t interface) [member function]
 
       
   543     cls.add_method('EnableAsciiIpv6', 
       
   544                    'void', 
       
   545                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::Ptr< ns3::Ipv6 >', 'ipv6'), param('uint32_t', 'interface')])
 
       
   546     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(std::string prefix, std::string ipv6Name, uint32_t interface) [member function]
 
       
   547     cls.add_method('EnableAsciiIpv6', 
       
   548                    'void', 
       
   549                    [param('std::string', 'prefix'), param('std::string', 'ipv6Name'), param('uint32_t', 'interface')])
 
       
   550     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(ns3::Ptr<ns3::OutputStreamObject> stream, std::string ipv6Name, uint32_t interface) [member function]
 
       
   551     cls.add_method('EnableAsciiIpv6', 
       
   552                    'void', 
       
   553                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('std::string', 'ipv6Name'), param('uint32_t', 'interface')])
 
       
   554     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(std::string prefix, ns3::Ipv6InterfaceContainer c) [member function]
 
       
   555     cls.add_method('EnableAsciiIpv6', 
       
   556                    'void', 
       
   557                    [param('std::string', 'prefix'), param('ns3::Ipv6InterfaceContainer', 'c')])
 
       
   558     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::Ipv6InterfaceContainer c) [member function]
 
       
   559     cls.add_method('EnableAsciiIpv6', 
       
   560                    'void', 
       
   561                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::Ipv6InterfaceContainer', 'c')])
 
       
   562     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(std::string prefix, ns3::NodeContainer n) [member function]
 
       
   563     cls.add_method('EnableAsciiIpv6', 
       
   564                    'void', 
       
   565                    [param('std::string', 'prefix'), param('ns3::NodeContainer', 'n')])
 
       
   566     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::NodeContainer n) [member function]
 
       
   567     cls.add_method('EnableAsciiIpv6', 
       
   568                    'void', 
       
   569                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::NodeContainer', 'n')])
 
       
   570     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(std::string prefix, uint32_t nodeid, uint32_t deviceid) [member function]
 
       
   571     cls.add_method('EnableAsciiIpv6', 
       
   572                    'void', 
       
   573                    [param('std::string', 'prefix'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')])
 
       
   574     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(ns3::Ptr<ns3::OutputStreamObject> stream, uint32_t nodeid, uint32_t interface) [member function]
 
       
   575     cls.add_method('EnableAsciiIpv6', 
       
   576                    'void', 
       
   577                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('uint32_t', 'nodeid'), param('uint32_t', 'interface')])
 
       
   578     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6All(std::string prefix) [member function]
 
       
   579     cls.add_method('EnableAsciiIpv6All', 
       
   580                    'void', 
       
   581                    [param('std::string', 'prefix')])
 
       
   582     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6All(ns3::Ptr<ns3::OutputStreamObject> stream) [member function]
 
       
   583     cls.add_method('EnableAsciiIpv6All', 
       
   584                    'void', 
       
   585                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream')])
 
       
   586     ## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6Internal(ns3::Ptr<ns3::OutputStreamObject> stream, std::string prefix, ns3::Ptr<ns3::Ipv6> ipv6, uint32_t interface) [member function]
 
       
   587     cls.add_method('EnableAsciiIpv6Internal', 
       
   588                    'void', 
       
   589                    [param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv6 >', 'ipv6'), param('uint32_t', 'interface')], 
   524                    is_pure_virtual=True, is_virtual=True)
 
   590                    is_pure_virtual=True, is_virtual=True)
 
   525     return
 
   591     return
 
   526 
   592 
   527 def register_Ns3AthstatsHelper_methods(root_module, cls):
 
   593 def register_Ns3AthstatsHelper_methods(root_module, cls):
 
   528     ## athstats-helper.h: ns3::AthstatsHelper::AthstatsHelper(ns3::AthstatsHelper const & arg0) [copy constructor]
 
   594     ## athstats-helper.h: ns3::AthstatsHelper::AthstatsHelper(ns3::AthstatsHelper const & arg0) [copy constructor]
 
   837                    [param('ns3::Ipv6InterfaceContainer &', 'c')])
 
   903                    [param('ns3::Ipv6InterfaceContainer &', 'c')])
 
   838     ## ipv6-interface-container.h: void ns3::Ipv6InterfaceContainer::Add(std::string ipv6Name, uint32_t interface) [member function]
 
   904     ## ipv6-interface-container.h: void ns3::Ipv6InterfaceContainer::Add(std::string ipv6Name, uint32_t interface) [member function]
 
   839     cls.add_method('Add', 
   905     cls.add_method('Add', 
   840                    'void', 
   906                    'void', 
   841                    [param('std::string', 'ipv6Name'), param('uint32_t', 'interface')])
 
   907                    [param('std::string', 'ipv6Name'), param('uint32_t', 'interface')])
 
       
   908     ## ipv6-interface-container.h: __gnu_cxx::__normal_iterator<const std::pair<ns3::Ptr<ns3::Ipv6>, unsigned int>*,std::vector<std::pair<ns3::Ptr<ns3::Ipv6>, unsigned int>, std::allocator<std::pair<ns3::Ptr<ns3::Ipv6>, unsigned int> > > > ns3::Ipv6InterfaceContainer::Begin() const [member function]
 
       
   909     cls.add_method('Begin', 
       
   910                    '__gnu_cxx::__normal_iterator< std::pair< ns3::Ptr< ns3::Ipv6 >, unsigned int > const, std::vector< std::pair< ns3::Ptr< ns3::Ipv6 >, unsigned int > > >', 
       
   911                    [], 
       
   912                    is_const=True)
 
       
   913     ## ipv6-interface-container.h: __gnu_cxx::__normal_iterator<const std::pair<ns3::Ptr<ns3::Ipv6>, unsigned int>*,std::vector<std::pair<ns3::Ptr<ns3::Ipv6>, unsigned int>, std::allocator<std::pair<ns3::Ptr<ns3::Ipv6>, unsigned int> > > > ns3::Ipv6InterfaceContainer::End() const [member function]
 
       
   914     cls.add_method('End', 
       
   915                    '__gnu_cxx::__normal_iterator< std::pair< ns3::Ptr< ns3::Ipv6 >, unsigned int > const, std::vector< std::pair< ns3::Ptr< ns3::Ipv6 >, unsigned int > > >', 
       
   916                    [], 
       
   917                    is_const=True)
 
   842     ## ipv6-interface-container.h: ns3::Ipv6Address ns3::Ipv6InterfaceContainer::GetAddress(uint32_t i, uint32_t j) const [member function]
 
   918     ## ipv6-interface-container.h: ns3::Ipv6Address ns3::Ipv6InterfaceContainer::GetAddress(uint32_t i, uint32_t j) const [member function]
 
   843     cls.add_method('GetAddress', 
   919     cls.add_method('GetAddress', 
   844                    'ns3::Ipv6Address', 
   920                    'ns3::Ipv6Address', 
   845                    [param('uint32_t', 'i'), param('uint32_t', 'j')], 
   921                    [param('uint32_t', 'i'), param('uint32_t', 'j')], 
   846                    is_const=True)
 
   922                    is_const=True)
 
  1261                    [param('std::string', 'filename'), param('std::string', 'filemode'), param('uint32_t', 'dataLinkType'), param('uint32_t', 'snapLen', default_value='65535'), param('int32_t', 'tzCorrection', default_value='0')])
 
  1337                    [param('std::string', 'filename'), param('std::string', 'filemode'), param('uint32_t', 'dataLinkType'), param('uint32_t', 'snapLen', default_value='65535'), param('int32_t', 'tzCorrection', default_value='0')])
 
  1262     ## pcap-helper.h: std::string ns3::PcapHelper::GetFilenameFromDevice(std::string prefix, ns3::Ptr<ns3::NetDevice> device, bool useObjectNames=true) [member function]
 
  1338     ## pcap-helper.h: std::string ns3::PcapHelper::GetFilenameFromDevice(std::string prefix, ns3::Ptr<ns3::NetDevice> device, bool useObjectNames=true) [member function]
 
  1263     cls.add_method('GetFilenameFromDevice', 
  1339     cls.add_method('GetFilenameFromDevice', 
  1264                    'std::string', 
  1340                    'std::string', 
  1265                    [param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'useObjectNames', default_value='true')])
 
  1341                    [param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'useObjectNames', default_value='true')])
 
  1266     ## pcap-helper.h: std::string ns3::PcapHelper::GetFilenameFromInterfacePair(std::string prefix, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface, bool useObjectNames=true) [member function]
 
  1342     ## pcap-helper.h: std::string ns3::PcapHelper::GetFilenameFromInterfacePair(std::string prefix, ns3::Ptr<ns3::Object> object, uint32_t interface, bool useObjectNames=true) [member function]
 
  1267     cls.add_method('GetFilenameFromInterfacePair', 
  1343     cls.add_method('GetFilenameFromInterfacePair', 
  1268                    'std::string', 
  1344                    'std::string', 
  1269                    [param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface'), param('bool', 'useObjectNames', default_value='true')])
 
  1345                    [param('std::string', 'prefix'), param('ns3::Ptr< ns3::Object >', 'object'), param('uint32_t', 'interface'), param('bool', 'useObjectNames', default_value='true')])
 
  1270     return
 
  1346     return
 
  1271 
  1347 
  1272 def register_Ns3PcapUserHelperForDevice_methods(root_module, cls):
 
  1348 def register_Ns3PcapUserHelperForDevice_methods(root_module, cls):
 
  1273     ## pcap-user-helper-for-device.h: ns3::PcapUserHelperForDevice::PcapUserHelperForDevice() [constructor]
 
  1349     ## pcap-helper.h: ns3::PcapUserHelperForDevice::PcapUserHelperForDevice() [constructor]
 
  1274     cls.add_constructor([])
 
  1350     cls.add_constructor([])
 
  1275     ## pcap-user-helper-for-device.h: ns3::PcapUserHelperForDevice::PcapUserHelperForDevice(ns3::PcapUserHelperForDevice const & arg0) [copy constructor]
 
  1351     ## pcap-helper.h: ns3::PcapUserHelperForDevice::PcapUserHelperForDevice(ns3::PcapUserHelperForDevice const & arg0) [copy constructor]
 
  1276     cls.add_constructor([param('ns3::PcapUserHelperForDevice const &', 'arg0')])
 
  1352     cls.add_constructor([param('ns3::PcapUserHelperForDevice const &', 'arg0')])
 
  1277     ## pcap-user-helper-for-device.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, ns3::Ptr<ns3::NetDevice> nd, bool promiscuous=false) [member function]
 
  1353     ## pcap-helper.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, ns3::Ptr<ns3::NetDevice> nd, bool promiscuous=false) [member function]
 
  1278     cls.add_method('EnablePcap', 
  1354     cls.add_method('EnablePcap', 
  1279                    'void', 
  1355                    'void', 
  1280                    [param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd'), param('bool', 'promiscuous', default_value='false')])
 
  1356                    [param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd'), param('bool', 'promiscuous', default_value='false')])
 
  1281     ## pcap-user-helper-for-device.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, std::string ndName, bool promiscuous=false) [member function]
 
  1357     ## pcap-helper.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, std::string ndName, bool promiscuous=false) [member function]
 
  1282     cls.add_method('EnablePcap', 
  1358     cls.add_method('EnablePcap', 
  1283                    'void', 
  1359                    'void', 
  1284                    [param('std::string', 'prefix'), param('std::string', 'ndName'), param('bool', 'promiscuous', default_value='false')])
 
  1360                    [param('std::string', 'prefix'), param('std::string', 'ndName'), param('bool', 'promiscuous', default_value='false')])
 
  1285     ## pcap-user-helper-for-device.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, ns3::NetDeviceContainer d, bool promiscuous=false) [member function]
 
  1361     ## pcap-helper.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, ns3::NetDeviceContainer d, bool promiscuous=false) [member function]
 
  1286     cls.add_method('EnablePcap', 
  1362     cls.add_method('EnablePcap', 
  1287                    'void', 
  1363                    'void', 
  1288                    [param('std::string', 'prefix'), param('ns3::NetDeviceContainer', 'd'), param('bool', 'promiscuous', default_value='false')])
 
  1364                    [param('std::string', 'prefix'), param('ns3::NetDeviceContainer', 'd'), param('bool', 'promiscuous', default_value='false')])
 
  1289     ## pcap-user-helper-for-device.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, ns3::NodeContainer n, bool promiscuous=false) [member function]
 
  1365     ## pcap-helper.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, ns3::NodeContainer n, bool promiscuous=false) [member function]
 
  1290     cls.add_method('EnablePcap', 
  1366     cls.add_method('EnablePcap', 
  1291                    'void', 
  1367                    'void', 
  1292                    [param('std::string', 'prefix'), param('ns3::NodeContainer', 'n'), param('bool', 'promiscuous', default_value='false')])
 
  1368                    [param('std::string', 'prefix'), param('ns3::NodeContainer', 'n'), param('bool', 'promiscuous', default_value='false')])
 
  1293     ## pcap-user-helper-for-device.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, uint32_t nodeid, uint32_t deviceid, bool promiscuous=false) [member function]
 
  1369     ## pcap-helper.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, uint32_t nodeid, uint32_t deviceid, bool promiscuous=false) [member function]
 
  1294     cls.add_method('EnablePcap', 
  1370     cls.add_method('EnablePcap', 
  1295                    'void', 
  1371                    'void', 
  1296                    [param('std::string', 'prefix'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid'), param('bool', 'promiscuous', default_value='false')])
 
  1372                    [param('std::string', 'prefix'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid'), param('bool', 'promiscuous', default_value='false')])
 
  1297     ## pcap-user-helper-for-device.h: void ns3::PcapUserHelperForDevice::EnablePcapAll(std::string prefix, bool promiscuous=false) [member function]
 
  1373     ## pcap-helper.h: void ns3::PcapUserHelperForDevice::EnablePcapAll(std::string prefix, bool promiscuous=false) [member function]
 
  1298     cls.add_method('EnablePcapAll', 
  1374     cls.add_method('EnablePcapAll', 
  1299                    'void', 
  1375                    'void', 
  1300                    [param('std::string', 'prefix'), param('bool', 'promiscuous', default_value='false')])
 
  1376                    [param('std::string', 'prefix'), param('bool', 'promiscuous', default_value='false')])
 
  1301     ## pcap-user-helper-for-device.h: void ns3::PcapUserHelperForDevice::EnablePcapInternal(std::string prefix, ns3::Ptr<ns3::NetDevice> nd, bool promiscuous) [member function]
 
  1377     ## pcap-helper.h: void ns3::PcapUserHelperForDevice::EnablePcapInternal(std::string prefix, ns3::Ptr<ns3::NetDevice> nd, bool promiscuous) [member function]
 
  1302     cls.add_method('EnablePcapInternal', 
  1378     cls.add_method('EnablePcapInternal', 
  1303                    'void', 
  1379                    'void', 
  1304                    [param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd'), param('bool', 'promiscuous')], 
  1380                    [param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd'), param('bool', 'promiscuous')], 
  1305                    is_pure_virtual=True, is_virtual=True)
 
  1381                    is_pure_virtual=True, is_virtual=True)
 
  1306     return
 
  1382     return
 
  1307 
  1383 
  1308 def register_Ns3PcapUserHelperForIpv4_methods(root_module, cls):
 
  1384 def register_Ns3PcapUserHelperForIpv4_methods(root_module, cls):
 
  1309     ## pcap-user-helper-for-ipv4.h: ns3::PcapUserHelperForIpv4::PcapUserHelperForIpv4() [constructor]
 
  1385     ## pcap-helper.h: ns3::PcapUserHelperForIpv4::PcapUserHelperForIpv4() [constructor]
 
  1310     cls.add_constructor([])
 
  1386     cls.add_constructor([])
 
  1311     ## pcap-user-helper-for-ipv4.h: ns3::PcapUserHelperForIpv4::PcapUserHelperForIpv4(ns3::PcapUserHelperForIpv4 const & arg0) [copy constructor]
 
  1387     ## pcap-helper.h: ns3::PcapUserHelperForIpv4::PcapUserHelperForIpv4(ns3::PcapUserHelperForIpv4 const & arg0) [copy constructor]
 
  1312     cls.add_constructor([param('ns3::PcapUserHelperForIpv4 const &', 'arg0')])
 
  1388     cls.add_constructor([param('ns3::PcapUserHelperForIpv4 const &', 'arg0')])
 
  1313     ## pcap-user-helper-for-ipv4.h: void ns3::PcapUserHelperForIpv4::EnablePcap(std::string prefix, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface) [member function]
 
  1389     ## pcap-helper.h: void ns3::PcapUserHelperForIpv4::EnablePcapIpv4(std::string prefix, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface) [member function]
 
  1314     cls.add_method('EnablePcap', 
  1390     cls.add_method('EnablePcapIpv4', 
  1315                    'void', 
  1391                    'void', 
  1316                    [param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')])
 
  1392                    [param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')])
 
  1317     ## pcap-user-helper-for-ipv4.h: void ns3::PcapUserHelperForIpv4::EnablePcap(std::string prefix, std::string ipv4Name, uint32_t interface) [member function]
 
  1393     ## pcap-helper.h: void ns3::PcapUserHelperForIpv4::EnablePcapIpv4(std::string prefix, std::string ipv4Name, uint32_t interface) [member function]
 
  1318     cls.add_method('EnablePcap', 
  1394     cls.add_method('EnablePcapIpv4', 
  1319                    'void', 
  1395                    'void', 
  1320                    [param('std::string', 'prefix'), param('std::string', 'ipv4Name'), param('uint32_t', 'interface')])
 
  1396                    [param('std::string', 'prefix'), param('std::string', 'ipv4Name'), param('uint32_t', 'interface')])
 
  1321     ## pcap-user-helper-for-ipv4.h: void ns3::PcapUserHelperForIpv4::EnablePcap(std::string prefix, ns3::Ipv4InterfaceContainer c) [member function]
 
  1397     ## pcap-helper.h: void ns3::PcapUserHelperForIpv4::EnablePcapIpv4(std::string prefix, ns3::Ipv4InterfaceContainer c) [member function]
 
  1322     cls.add_method('EnablePcap', 
  1398     cls.add_method('EnablePcapIpv4', 
  1323                    'void', 
  1399                    'void', 
  1324                    [param('std::string', 'prefix'), param('ns3::Ipv4InterfaceContainer', 'c')])
 
  1400                    [param('std::string', 'prefix'), param('ns3::Ipv4InterfaceContainer', 'c')])
 
  1325     ## pcap-user-helper-for-ipv4.h: void ns3::PcapUserHelperForIpv4::EnablePcap(std::string prefix, ns3::NodeContainer n) [member function]
 
  1401     ## pcap-helper.h: void ns3::PcapUserHelperForIpv4::EnablePcapIpv4(std::string prefix, ns3::NodeContainer n) [member function]
 
  1326     cls.add_method('EnablePcap', 
  1402     cls.add_method('EnablePcapIpv4', 
  1327                    'void', 
  1403                    'void', 
  1328                    [param('std::string', 'prefix'), param('ns3::NodeContainer', 'n')])
 
  1404                    [param('std::string', 'prefix'), param('ns3::NodeContainer', 'n')])
 
  1329     ## pcap-user-helper-for-ipv4.h: void ns3::PcapUserHelperForIpv4::EnablePcap(std::string prefix, uint32_t nodeid, uint32_t interface) [member function]
 
  1405     ## pcap-helper.h: void ns3::PcapUserHelperForIpv4::EnablePcapIpv4(std::string prefix, uint32_t nodeid, uint32_t interface) [member function]
 
  1330     cls.add_method('EnablePcap', 
  1406     cls.add_method('EnablePcapIpv4', 
  1331                    'void', 
  1407                    'void', 
  1332                    [param('std::string', 'prefix'), param('uint32_t', 'nodeid'), param('uint32_t', 'interface')])
 
  1408                    [param('std::string', 'prefix'), param('uint32_t', 'nodeid'), param('uint32_t', 'interface')])
 
  1333     ## pcap-user-helper-for-ipv4.h: void ns3::PcapUserHelperForIpv4::EnablePcapAll(std::string prefix) [member function]
 
  1409     ## pcap-helper.h: void ns3::PcapUserHelperForIpv4::EnablePcapIpv4All(std::string prefix) [member function]
 
  1334     cls.add_method('EnablePcapAll', 
  1410     cls.add_method('EnablePcapIpv4All', 
  1335                    'void', 
  1411                    'void', 
  1336                    [param('std::string', 'prefix')])
 
  1412                    [param('std::string', 'prefix')])
 
  1337     ## pcap-user-helper-for-ipv4.h: void ns3::PcapUserHelperForIpv4::EnablePcapInternal(std::string prefix, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface) [member function]
 
  1413     ## pcap-helper.h: void ns3::PcapUserHelperForIpv4::EnablePcapIpv4Internal(std::string prefix, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface) [member function]
 
  1338     cls.add_method('EnablePcapInternal', 
  1414     cls.add_method('EnablePcapIpv4Internal', 
  1339                    'void', 
  1415                    'void', 
  1340                    [param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')], 
  1416                    [param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')], 
       
  1417                    is_pure_virtual=True, is_virtual=True)
 
       
  1418     return
 
       
  1419 
       
  1420 def register_Ns3PcapUserHelperForIpv6_methods(root_module, cls):
 
       
  1421     ## pcap-helper.h: ns3::PcapUserHelperForIpv6::PcapUserHelperForIpv6() [constructor]
 
       
  1422     cls.add_constructor([])
 
       
  1423     ## pcap-helper.h: ns3::PcapUserHelperForIpv6::PcapUserHelperForIpv6(ns3::PcapUserHelperForIpv6 const & arg0) [copy constructor]
 
       
  1424     cls.add_constructor([param('ns3::PcapUserHelperForIpv6 const &', 'arg0')])
 
       
  1425     ## pcap-helper.h: void ns3::PcapUserHelperForIpv6::EnablePcapIpv6(std::string prefix, ns3::Ptr<ns3::Ipv6> ipv6, uint32_t interface) [member function]
 
       
  1426     cls.add_method('EnablePcapIpv6', 
       
  1427                    'void', 
       
  1428                    [param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv6 >', 'ipv6'), param('uint32_t', 'interface')])
 
       
  1429     ## pcap-helper.h: void ns3::PcapUserHelperForIpv6::EnablePcapIpv6(std::string prefix, std::string ipv6Name, uint32_t interface) [member function]
 
       
  1430     cls.add_method('EnablePcapIpv6', 
       
  1431                    'void', 
       
  1432                    [param('std::string', 'prefix'), param('std::string', 'ipv6Name'), param('uint32_t', 'interface')])
 
       
  1433     ## pcap-helper.h: void ns3::PcapUserHelperForIpv6::EnablePcapIpv6(std::string prefix, ns3::Ipv6InterfaceContainer c) [member function]
 
       
  1434     cls.add_method('EnablePcapIpv6', 
       
  1435                    'void', 
       
  1436                    [param('std::string', 'prefix'), param('ns3::Ipv6InterfaceContainer', 'c')])
 
       
  1437     ## pcap-helper.h: void ns3::PcapUserHelperForIpv6::EnablePcapIpv6(std::string prefix, ns3::NodeContainer n) [member function]
 
       
  1438     cls.add_method('EnablePcapIpv6', 
       
  1439                    'void', 
       
  1440                    [param('std::string', 'prefix'), param('ns3::NodeContainer', 'n')])
 
       
  1441     ## pcap-helper.h: void ns3::PcapUserHelperForIpv6::EnablePcapIpv6(std::string prefix, uint32_t nodeid, uint32_t interface) [member function]
 
       
  1442     cls.add_method('EnablePcapIpv6', 
       
  1443                    'void', 
       
  1444                    [param('std::string', 'prefix'), param('uint32_t', 'nodeid'), param('uint32_t', 'interface')])
 
       
  1445     ## pcap-helper.h: void ns3::PcapUserHelperForIpv6::EnablePcapIpv6All(std::string prefix) [member function]
 
       
  1446     cls.add_method('EnablePcapIpv6All', 
       
  1447                    'void', 
       
  1448                    [param('std::string', 'prefix')])
 
       
  1449     ## pcap-helper.h: void ns3::PcapUserHelperForIpv6::EnablePcapIpv6Internal(std::string prefix, ns3::Ptr<ns3::Ipv6> ipv6, uint32_t interface) [member function]
 
       
  1450     cls.add_method('EnablePcapIpv6Internal', 
       
  1451                    'void', 
       
  1452                    [param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv6 >', 'ipv6'), param('uint32_t', 'interface')], 
  1341                    is_pure_virtual=True, is_virtual=True)
 
  1453                    is_pure_virtual=True, is_virtual=True)
 
  1342     return
 
  1454     return
 
  1343 
  1455 
  1344 def register_Ns3Ping6Helper_methods(root_module, cls):
 
  1456 def register_Ns3Ping6Helper_methods(root_module, cls):
 
  1345     ## ping6-helper.h: ns3::Ping6Helper::Ping6Helper(ns3::Ping6Helper const & arg0) [copy constructor]
 
  1457     ## ping6-helper.h: ns3::Ping6Helper::Ping6Helper(ns3::Ping6Helper const & arg0) [copy constructor]
ns-3.24