F5/unison
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add ipv6

Browse Source
This commit is contained in:
Craig Dowell
2010-01-27 21:23:30 -08:00
parent d9a4bf75f6
commit f3cd175d71
12 changed files with 1286 additions and 355 deletions
Download Patch File Download Diff File Expand all files Collapse all files

264
bindings/python/apidefs/gcc-ILP32/ns3_module_helper.py
View File

@@ -9,10 +9,12 @@ def register_types(module):
module.add_class('ApplicationContainer')
## ascii-trace-helper.h: ns3::AsciiTraceHelper [class]
module.add_class('AsciiTraceHelper', allow_subclassing=False)
## ascii-trace-user-helper-for-device.h: ns3::AsciiTraceUserHelperForDevice [class]
## ascii-trace-helper.h: ns3::AsciiTraceUserHelperForDevice [class]
module.add_class('AsciiTraceUserHelperForDevice', allow_subclassing=True)
## ascii-trace-user-helper-for-ipv4.h: ns3::AsciiTraceUserHelperForIpv4 [class]
## ascii-trace-helper.h: ns3::AsciiTraceUserHelperForIpv4 [class]
module.add_class('AsciiTraceUserHelperForIpv4', allow_subclassing=True)
## ascii-trace-helper.h: ns3::AsciiTraceUserHelperForIpv6 [class]
module.add_class('AsciiTraceUserHelperForIpv6', allow_subclassing=True)
## athstats-helper.h: ns3::AthstatsHelper [class]
module.add_class('AthstatsHelper', allow_subclassing=False)
## bridge-helper.h: ns3::BridgeHelper [class]
@@ -73,10 +75,12 @@ def register_types(module):
module.add_enum('', ['DLT_PRISM_HEADER'], outer_class=root_module['ns3::PcapHelper'])
## pcap-helper.h: ns3::PcapHelper [enumeration]
module.add_enum('', ['DLT_IEEE802_11_RADIO'], outer_class=root_module['ns3::PcapHelper'])
## pcap-user-helper-for-device.h: ns3::PcapUserHelperForDevice [class]
## pcap-helper.h: ns3::PcapUserHelperForDevice [class]
module.add_class('PcapUserHelperForDevice', allow_subclassing=True)
## pcap-user-helper-for-ipv4.h: ns3::PcapUserHelperForIpv4 [class]
## pcap-helper.h: ns3::PcapUserHelperForIpv4 [class]
module.add_class('PcapUserHelperForIpv4', allow_subclassing=True)
## pcap-helper.h: ns3::PcapUserHelperForIpv6 [class]
module.add_class('PcapUserHelperForIpv6', allow_subclassing=True)
## ping6-helper.h: ns3::Ping6Helper [class]
module.add_class('Ping6Helper', allow_subclassing=False)
## point-to-point-dumbbell-helper.h: ns3::PointToPointDumbbellHelper [class]
@@ -218,6 +222,7 @@ def register_methods(root_module):
register_Ns3AsciiTraceHelper_methods(root_module, root_module['ns3::AsciiTraceHelper'])
register_Ns3AsciiTraceUserHelperForDevice_methods(root_module, root_module['ns3::AsciiTraceUserHelperForDevice'])
register_Ns3AsciiTraceUserHelperForIpv4_methods(root_module, root_module['ns3::AsciiTraceUserHelperForIpv4'])
register_Ns3AsciiTraceUserHelperForIpv6_methods(root_module, root_module['ns3::AsciiTraceUserHelperForIpv6'])
register_Ns3AthstatsHelper_methods(root_module, root_module['ns3::AthstatsHelper'])
register_Ns3BridgeHelper_methods(root_module, root_module['ns3::BridgeHelper'])
register_Ns3CsmaStarHelper_methods(root_module, root_module['ns3::CsmaStarHelper'])
@@ -242,6 +247,7 @@ def register_methods(root_module):
register_Ns3PcapHelper_methods(root_module, root_module['ns3::PcapHelper'])
register_Ns3PcapUserHelperForDevice_methods(root_module, root_module['ns3::PcapUserHelperForDevice'])
register_Ns3PcapUserHelperForIpv4_methods(root_module, root_module['ns3::PcapUserHelperForIpv4'])
register_Ns3PcapUserHelperForIpv6_methods(root_module, root_module['ns3::PcapUserHelperForIpv6'])
register_Ns3Ping6Helper_methods(root_module, root_module['ns3::Ping6Helper'])
register_Ns3PointToPointDumbbellHelper_methods(root_module, root_module['ns3::PointToPointDumbbellHelper'])
register_Ns3PointToPointGridHelper_methods(root_module, root_module['ns3::PointToPointGridHelper'])
@@ -398,66 +404,66 @@ def register_Ns3AsciiTraceHelper_methods(root_module, cls):
cls.add_method('GetFilenameFromDevice',
'std::string',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'useObjectNames', default_value='true')])
## 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]
## 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]
cls.add_method('GetFilenameFromInterfacePair',
'std::string',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface'), param('bool', 'useObjectNames', default_value='true')])
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::Object >', 'object'), param('uint32_t', 'interface'), param('bool', 'useObjectNames', default_value='true')])
return
def register_Ns3AsciiTraceUserHelperForDevice_methods(root_module, cls):
## ascii-trace-user-helper-for-device.h: ns3::AsciiTraceUserHelperForDevice::AsciiTraceUserHelperForDevice() [constructor]
## ascii-trace-helper.h: ns3::AsciiTraceUserHelperForDevice::AsciiTraceUserHelperForDevice() [constructor]
cls.add_constructor([])
## ascii-trace-user-helper-for-device.h: ns3::AsciiTraceUserHelperForDevice::AsciiTraceUserHelperForDevice(ns3::AsciiTraceUserHelperForDevice const & arg0) [copy constructor]
## ascii-trace-helper.h: ns3::AsciiTraceUserHelperForDevice::AsciiTraceUserHelperForDevice(ns3::AsciiTraceUserHelperForDevice const & arg0) [copy constructor]
cls.add_constructor([param('ns3::AsciiTraceUserHelperForDevice const &', 'arg0')])
## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, ns3::Ptr<ns3::NetDevice> nd) [member function]
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, ns3::Ptr<ns3::NetDevice> nd) [member function]
cls.add_method('EnableAscii',
'void',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd')])
## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::Ptr<ns3::NetDevice> nd) [member function]
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::Ptr<ns3::NetDevice> nd) [member function]
cls.add_method('EnableAscii',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::Ptr< ns3::NetDevice >', 'nd')])
## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, std::string ndName) [member function]
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, std::string ndName) [member function]
cls.add_method('EnableAscii',
'void',
[param('std::string', 'prefix'), param('std::string', 'ndName')])
## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, std::string ndName) [member function]
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, std::string ndName) [member function]
cls.add_method('EnableAscii',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('std::string', 'ndName')])
## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, ns3::NetDeviceContainer d) [member function]
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, ns3::NetDeviceContainer d) [member function]
cls.add_method('EnableAscii',
'void',
[param('std::string', 'prefix'), param('ns3::NetDeviceContainer', 'd')])
## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::NetDeviceContainer d) [member function]
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::NetDeviceContainer d) [member function]
cls.add_method('EnableAscii',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::NetDeviceContainer', 'd')])
## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, ns3::NodeContainer n) [member function]
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, ns3::NodeContainer n) [member function]
cls.add_method('EnableAscii',
'void',
[param('std::string', 'prefix'), param('ns3::NodeContainer', 'n')])
## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::NodeContainer n) [member function]
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::NodeContainer n) [member function]
cls.add_method('EnableAscii',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::NodeContainer', 'n')])
## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, uint32_t nodeid, uint32_t deviceid) [member function]
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, uint32_t nodeid, uint32_t deviceid) [member function]
cls.add_method('EnableAscii',
'void',
[param('std::string', 'prefix'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')])
## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, uint32_t nodeid, uint32_t deviceid) [member function]
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, uint32_t nodeid, uint32_t deviceid) [member function]
cls.add_method('EnableAscii',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')])
## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAsciiAll(std::string prefix) [member function]
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAsciiAll(std::string prefix) [member function]
cls.add_method('EnableAsciiAll',
'void',
[param('std::string', 'prefix')])
## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAsciiAll(ns3::Ptr<ns3::OutputStreamObject> stream) [member function]
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAsciiAll(ns3::Ptr<ns3::OutputStreamObject> stream) [member function]
cls.add_method('EnableAsciiAll',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream')])
## 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]
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAsciiInternal(ns3::Ptr<ns3::OutputStreamObject> stream, std::string prefix, ns3::Ptr<ns3::NetDevice> nd) [member function]
cls.add_method('EnableAsciiInternal',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd')],
@@ -465,65 +471,125 @@ def register_Ns3AsciiTraceUserHelperForDevice_methods(root_module, cls):
return
def register_Ns3AsciiTraceUserHelperForIpv4_methods(root_module, cls):
## ascii-trace-user-helper-for-ipv4.h: ns3::AsciiTraceUserHelperForIpv4::AsciiTraceUserHelperForIpv4() [constructor]
## ascii-trace-helper.h: ns3::AsciiTraceUserHelperForIpv4::AsciiTraceUserHelperForIpv4() [constructor]
cls.add_constructor([])
## ascii-trace-user-helper-for-ipv4.h: ns3::AsciiTraceUserHelperForIpv4::AsciiTraceUserHelperForIpv4(ns3::AsciiTraceUserHelperForIpv4 const & arg0) [copy constructor]
## ascii-trace-helper.h: ns3::AsciiTraceUserHelperForIpv4::AsciiTraceUserHelperForIpv4(ns3::AsciiTraceUserHelperForIpv4 const & arg0) [copy constructor]
cls.add_constructor([param('ns3::AsciiTraceUserHelperForIpv4 const &', 'arg0')])
## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(std::string prefix, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface) [member function]
cls.add_method('EnableAscii',
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(std::string prefix, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface) [member function]
cls.add_method('EnableAsciiIpv4',
'void',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')])
## 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]
cls.add_method('EnableAscii',
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface) [member function]
cls.add_method('EnableAsciiIpv4',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')])
## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(std::string prefix, std::string ipv4Name, uint32_t interface) [member function]
cls.add_method('EnableAscii',
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(std::string prefix, std::string ipv4Name, uint32_t interface) [member function]
cls.add_method('EnableAsciiIpv4',
'void',
[param('std::string', 'prefix'), param('std::string', 'ipv4Name'), param('uint32_t', 'interface')])
## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, std::string ipv4Name, uint32_t interface) [member function]
cls.add_method('EnableAscii',
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(ns3::Ptr<ns3::OutputStreamObject> stream, std::string ipv4Name, uint32_t interface) [member function]
cls.add_method('EnableAsciiIpv4',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('std::string', 'ipv4Name'), param('uint32_t', 'interface')])
## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(std::string prefix, ns3::Ipv4InterfaceContainer c) [member function]
cls.add_method('EnableAscii',
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(std::string prefix, ns3::Ipv4InterfaceContainer c) [member function]
cls.add_method('EnableAsciiIpv4',
'void',
[param('std::string', 'prefix'), param('ns3::Ipv4InterfaceContainer', 'c')])
## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::Ipv4InterfaceContainer c) [member function]
cls.add_method('EnableAscii',
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::Ipv4InterfaceContainer c) [member function]
cls.add_method('EnableAsciiIpv4',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::Ipv4InterfaceContainer', 'c')])
## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(std::string prefix, ns3::NodeContainer n) [member function]
cls.add_method('EnableAscii',
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(std::string prefix, ns3::NodeContainer n) [member function]
cls.add_method('EnableAsciiIpv4',
'void',
[param('std::string', 'prefix'), param('ns3::NodeContainer', 'n')])
## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::NodeContainer n) [member function]
cls.add_method('EnableAscii',
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::NodeContainer n) [member function]
cls.add_method('EnableAsciiIpv4',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::NodeContainer', 'n')])
## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(std::string prefix, uint32_t nodeid, uint32_t deviceid) [member function]
cls.add_method('EnableAscii',
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(std::string prefix, uint32_t nodeid, uint32_t deviceid) [member function]
cls.add_method('EnableAsciiIpv4',
'void',
[param('std::string', 'prefix'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')])
## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, uint32_t nodeid, uint32_t interface) [member function]
cls.add_method('EnableAscii',
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(ns3::Ptr<ns3::OutputStreamObject> stream, uint32_t nodeid, uint32_t interface) [member function]
cls.add_method('EnableAsciiIpv4',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('uint32_t', 'nodeid'), param('uint32_t', 'interface')])
## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiAll(std::string prefix) [member function]
cls.add_method('EnableAsciiAll',
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4All(std::string prefix) [member function]
cls.add_method('EnableAsciiIpv4All',
'void',
[param('std::string', 'prefix')])
## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiAll(ns3::Ptr<ns3::OutputStreamObject> stream) [member function]
cls.add_method('EnableAsciiAll',
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4All(ns3::Ptr<ns3::OutputStreamObject> stream) [member function]
cls.add_method('EnableAsciiIpv4All',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream')])
## 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]
cls.add_method('EnableAsciiInternal',
## 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]
cls.add_method('EnableAsciiIpv4Internal',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')],
is_pure_virtual=True, is_virtual=True)
return
def register_Ns3AsciiTraceUserHelperForIpv6_methods(root_module, cls):
## ascii-trace-helper.h: ns3::AsciiTraceUserHelperForIpv6::AsciiTraceUserHelperForIpv6() [constructor]
cls.add_constructor([])
## ascii-trace-helper.h: ns3::AsciiTraceUserHelperForIpv6::AsciiTraceUserHelperForIpv6(ns3::AsciiTraceUserHelperForIpv6 const & arg0) [copy constructor]
cls.add_constructor([param('ns3::AsciiTraceUserHelperForIpv6 const &', 'arg0')])
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(std::string prefix, ns3::Ptr<ns3::Ipv6> ipv6, uint32_t interface) [member function]
cls.add_method('EnableAsciiIpv6',
'void',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv6 >', 'ipv6'), param('uint32_t', 'interface')])
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::Ptr<ns3::Ipv6> ipv6, uint32_t interface) [member function]
cls.add_method('EnableAsciiIpv6',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::Ptr< ns3::Ipv6 >', 'ipv6'), param('uint32_t', 'interface')])
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(std::string prefix, std::string ipv6Name, uint32_t interface) [member function]
cls.add_method('EnableAsciiIpv6',
'void',
[param('std::string', 'prefix'), param('std::string', 'ipv6Name'), param('uint32_t', 'interface')])
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(ns3::Ptr<ns3::OutputStreamObject> stream, std::string ipv6Name, uint32_t interface) [member function]
cls.add_method('EnableAsciiIpv6',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('std::string', 'ipv6Name'), param('uint32_t', 'interface')])
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(std::string prefix, ns3::Ipv6InterfaceContainer c) [member function]
cls.add_method('EnableAsciiIpv6',
'void',
[param('std::string', 'prefix'), param('ns3::Ipv6InterfaceContainer', 'c')])
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::Ipv6InterfaceContainer c) [member function]
cls.add_method('EnableAsciiIpv6',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::Ipv6InterfaceContainer', 'c')])
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(std::string prefix, ns3::NodeContainer n) [member function]
cls.add_method('EnableAsciiIpv6',
'void',
[param('std::string', 'prefix'), param('ns3::NodeContainer', 'n')])
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::NodeContainer n) [member function]
cls.add_method('EnableAsciiIpv6',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::NodeContainer', 'n')])
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(std::string prefix, uint32_t nodeid, uint32_t deviceid) [member function]
cls.add_method('EnableAsciiIpv6',
'void',
[param('std::string', 'prefix'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')])
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(ns3::Ptr<ns3::OutputStreamObject> stream, uint32_t nodeid, uint32_t interface) [member function]
cls.add_method('EnableAsciiIpv6',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('uint32_t', 'nodeid'), param('uint32_t', 'interface')])
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6All(std::string prefix) [member function]
cls.add_method('EnableAsciiIpv6All',
'void',
[param('std::string', 'prefix')])
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6All(ns3::Ptr<ns3::OutputStreamObject> stream) [member function]
cls.add_method('EnableAsciiIpv6All',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream')])
## 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]
cls.add_method('EnableAsciiIpv6Internal',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv6 >', 'ipv6'), param('uint32_t', 'interface')],
is_pure_virtual=True, is_virtual=True)
return
def register_Ns3AthstatsHelper_methods(root_module, cls):
## athstats-helper.h: ns3::AthstatsHelper::AthstatsHelper(ns3::AthstatsHelper const & arg0) [copy constructor]
cls.add_constructor([param('ns3::AthstatsHelper const &', 'arg0')])
@@ -839,6 +905,16 @@ def register_Ns3Ipv6InterfaceContainer_methods(root_module, cls):
cls.add_method('Add',
'void',
[param('std::string', 'ipv6Name'), param('uint32_t', 'interface')])
## 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]
cls.add_method('Begin',
'__gnu_cxx::__normal_iterator< std::pair< ns3::Ptr< ns3::Ipv6 >, unsigned int > const, std::vector< std::pair< ns3::Ptr< ns3::Ipv6 >, unsigned int > > >',
[],
is_const=True)
## 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]
cls.add_method('End',
'__gnu_cxx::__normal_iterator< std::pair< ns3::Ptr< ns3::Ipv6 >, unsigned int > const, std::vector< std::pair< ns3::Ptr< ns3::Ipv6 >, unsigned int > > >',
[],
is_const=True)
## ipv6-interface-container.h: ns3::Ipv6Address ns3::Ipv6InterfaceContainer::GetAddress(uint32_t i, uint32_t j) const [member function]
cls.add_method('GetAddress',
'ns3::Ipv6Address',
@@ -1263,42 +1339,42 @@ def register_Ns3PcapHelper_methods(root_module, cls):
cls.add_method('GetFilenameFromDevice',
'std::string',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'useObjectNames', default_value='true')])
## pcap-helper.h: std::string ns3::PcapHelper::GetFilenameFromInterfacePair(std::string prefix, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface, bool useObjectNames=true) [member function]
## pcap-helper.h: std::string ns3::PcapHelper::GetFilenameFromInterfacePair(std::string prefix, ns3::Ptr<ns3::Object> object, uint32_t interface, bool useObjectNames=true) [member function]
cls.add_method('GetFilenameFromInterfacePair',
'std::string',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface'), param('bool', 'useObjectNames', default_value='true')])
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::Object >', 'object'), param('uint32_t', 'interface'), param('bool', 'useObjectNames', default_value='true')])
return
def register_Ns3PcapUserHelperForDevice_methods(root_module, cls):
## pcap-user-helper-for-device.h: ns3::PcapUserHelperForDevice::PcapUserHelperForDevice() [constructor]
## pcap-helper.h: ns3::PcapUserHelperForDevice::PcapUserHelperForDevice() [constructor]
cls.add_constructor([])
## pcap-user-helper-for-device.h: ns3::PcapUserHelperForDevice::PcapUserHelperForDevice(ns3::PcapUserHelperForDevice const & arg0) [copy constructor]
## pcap-helper.h: ns3::PcapUserHelperForDevice::PcapUserHelperForDevice(ns3::PcapUserHelperForDevice const & arg0) [copy constructor]
cls.add_constructor([param('ns3::PcapUserHelperForDevice const &', 'arg0')])
## pcap-user-helper-for-device.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, ns3::Ptr<ns3::NetDevice> nd, bool promiscuous=false) [member function]
## pcap-helper.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, ns3::Ptr<ns3::NetDevice> nd, bool promiscuous=false) [member function]
cls.add_method('EnablePcap',
'void',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd'), param('bool', 'promiscuous', default_value='false')])
## pcap-user-helper-for-device.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, std::string ndName, bool promiscuous=false) [member function]
## pcap-helper.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, std::string ndName, bool promiscuous=false) [member function]
cls.add_method('EnablePcap',
'void',
[param('std::string', 'prefix'), param('std::string', 'ndName'), param('bool', 'promiscuous', default_value='false')])
## pcap-user-helper-for-device.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, ns3::NetDeviceContainer d, bool promiscuous=false) [member function]
## pcap-helper.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, ns3::NetDeviceContainer d, bool promiscuous=false) [member function]
cls.add_method('EnablePcap',
'void',
[param('std::string', 'prefix'), param('ns3::NetDeviceContainer', 'd'), param('bool', 'promiscuous', default_value='false')])
## pcap-user-helper-for-device.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, ns3::NodeContainer n, bool promiscuous=false) [member function]
## pcap-helper.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, ns3::NodeContainer n, bool promiscuous=false) [member function]
cls.add_method('EnablePcap',
'void',
[param('std::string', 'prefix'), param('ns3::NodeContainer', 'n'), param('bool', 'promiscuous', default_value='false')])
## pcap-user-helper-for-device.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, uint32_t nodeid, uint32_t deviceid, bool promiscuous=false) [member function]
## pcap-helper.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, uint32_t nodeid, uint32_t deviceid, bool promiscuous=false) [member function]
cls.add_method('EnablePcap',
'void',
[param('std::string', 'prefix'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid'), param('bool', 'promiscuous', default_value='false')])
## pcap-user-helper-for-device.h: void ns3::PcapUserHelperForDevice::EnablePcapAll(std::string prefix, bool promiscuous=false) [member function]
## pcap-helper.h: void ns3::PcapUserHelperForDevice::EnablePcapAll(std::string prefix, bool promiscuous=false) [member function]
cls.add_method('EnablePcapAll',
'void',
[param('std::string', 'prefix'), param('bool', 'promiscuous', default_value='false')])
## pcap-user-helper-for-device.h: void ns3::PcapUserHelperForDevice::EnablePcapInternal(std::string prefix, ns3::Ptr<ns3::NetDevice> nd, bool promiscuous) [member function]
## pcap-helper.h: void ns3::PcapUserHelperForDevice::EnablePcapInternal(std::string prefix, ns3::Ptr<ns3::NetDevice> nd, bool promiscuous) [member function]
cls.add_method('EnablePcapInternal',
'void',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd'), param('bool', 'promiscuous')],
@@ -1306,41 +1382,77 @@ def register_Ns3PcapUserHelperForDevice_methods(root_module, cls):
return
def register_Ns3PcapUserHelperForIpv4_methods(root_module, cls):
## pcap-user-helper-for-ipv4.h: ns3::PcapUserHelperForIpv4::PcapUserHelperForIpv4() [constructor]
## pcap-helper.h: ns3::PcapUserHelperForIpv4::PcapUserHelperForIpv4() [constructor]
cls.add_constructor([])
## pcap-user-helper-for-ipv4.h: ns3::PcapUserHelperForIpv4::PcapUserHelperForIpv4(ns3::PcapUserHelperForIpv4 const & arg0) [copy constructor]
## pcap-helper.h: ns3::PcapUserHelperForIpv4::PcapUserHelperForIpv4(ns3::PcapUserHelperForIpv4 const & arg0) [copy constructor]
cls.add_constructor([param('ns3::PcapUserHelperForIpv4 const &', 'arg0')])
## pcap-user-helper-for-ipv4.h: void ns3::PcapUserHelperForIpv4::EnablePcap(std::string prefix, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface) [member function]
cls.add_method('EnablePcap',
## pcap-helper.h: void ns3::PcapUserHelperForIpv4::EnablePcapIpv4(std::string prefix, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface) [member function]
cls.add_method('EnablePcapIpv4',
'void',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')])
## pcap-user-helper-for-ipv4.h: void ns3::PcapUserHelperForIpv4::EnablePcap(std::string prefix, std::string ipv4Name, uint32_t interface) [member function]
cls.add_method('EnablePcap',
## pcap-helper.h: void ns3::PcapUserHelperForIpv4::EnablePcapIpv4(std::string prefix, std::string ipv4Name, uint32_t interface) [member function]
cls.add_method('EnablePcapIpv4',
'void',
[param('std::string', 'prefix'), param('std::string', 'ipv4Name'), param('uint32_t', 'interface')])
## pcap-user-helper-for-ipv4.h: void ns3::PcapUserHelperForIpv4::EnablePcap(std::string prefix, ns3::Ipv4InterfaceContainer c) [member function]
cls.add_method('EnablePcap',
## pcap-helper.h: void ns3::PcapUserHelperForIpv4::EnablePcapIpv4(std::string prefix, ns3::Ipv4InterfaceContainer c) [member function]
cls.add_method('EnablePcapIpv4',
'void',
[param('std::string', 'prefix'), param('ns3::Ipv4InterfaceContainer', 'c')])
## pcap-user-helper-for-ipv4.h: void ns3::PcapUserHelperForIpv4::EnablePcap(std::string prefix, ns3::NodeContainer n) [member function]
cls.add_method('EnablePcap',
## pcap-helper.h: void ns3::PcapUserHelperForIpv4::EnablePcapIpv4(std::string prefix, ns3::NodeContainer n) [member function]
cls.add_method('EnablePcapIpv4',
'void',
[param('std::string', 'prefix'), param('ns3::NodeContainer', 'n')])
## pcap-user-helper-for-ipv4.h: void ns3::PcapUserHelperForIpv4::EnablePcap(std::string prefix, uint32_t nodeid, uint32_t interface) [member function]
cls.add_method('EnablePcap',
## pcap-helper.h: void ns3::PcapUserHelperForIpv4::EnablePcapIpv4(std::string prefix, uint32_t nodeid, uint32_t interface) [member function]
cls.add_method('EnablePcapIpv4',
'void',
[param('std::string', 'prefix'), param('uint32_t', 'nodeid'), param('uint32_t', 'interface')])
## pcap-user-helper-for-ipv4.h: void ns3::PcapUserHelperForIpv4::EnablePcapAll(std::string prefix) [member function]
cls.add_method('EnablePcapAll',
## pcap-helper.h: void ns3::PcapUserHelperForIpv4::EnablePcapIpv4All(std::string prefix) [member function]
cls.add_method('EnablePcapIpv4All',
'void',
[param('std::string', 'prefix')])
## pcap-user-helper-for-ipv4.h: void ns3::PcapUserHelperForIpv4::EnablePcapInternal(std::string prefix, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface) [member function]
cls.add_method('EnablePcapInternal',
## pcap-helper.h: void ns3::PcapUserHelperForIpv4::EnablePcapIpv4Internal(std::string prefix, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface) [member function]
cls.add_method('EnablePcapIpv4Internal',
'void',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')],
is_pure_virtual=True, is_virtual=True)
return
def register_Ns3PcapUserHelperForIpv6_methods(root_module, cls):
## pcap-helper.h: ns3::PcapUserHelperForIpv6::PcapUserHelperForIpv6() [constructor]
cls.add_constructor([])
## pcap-helper.h: ns3::PcapUserHelperForIpv6::PcapUserHelperForIpv6(ns3::PcapUserHelperForIpv6 const & arg0) [copy constructor]
cls.add_constructor([param('ns3::PcapUserHelperForIpv6 const &', 'arg0')])
## pcap-helper.h: void ns3::PcapUserHelperForIpv6::EnablePcapIpv6(std::string prefix, ns3::Ptr<ns3::Ipv6> ipv6, uint32_t interface) [member function]
cls.add_method('EnablePcapIpv6',
'void',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv6 >', 'ipv6'), param('uint32_t', 'interface')])
## pcap-helper.h: void ns3::PcapUserHelperForIpv6::EnablePcapIpv6(std::string prefix, std::string ipv6Name, uint32_t interface) [member function]
cls.add_method('EnablePcapIpv6',
'void',
[param('std::string', 'prefix'), param('std::string', 'ipv6Name'), param('uint32_t', 'interface')])
## pcap-helper.h: void ns3::PcapUserHelperForIpv6::EnablePcapIpv6(std::string prefix, ns3::Ipv6InterfaceContainer c) [member function]
cls.add_method('EnablePcapIpv6',
'void',
[param('std::string', 'prefix'), param('ns3::Ipv6InterfaceContainer', 'c')])
## pcap-helper.h: void ns3::PcapUserHelperForIpv6::EnablePcapIpv6(std::string prefix, ns3::NodeContainer n) [member function]
cls.add_method('EnablePcapIpv6',
'void',
[param('std::string', 'prefix'), param('ns3::NodeContainer', 'n')])
## pcap-helper.h: void ns3::PcapUserHelperForIpv6::EnablePcapIpv6(std::string prefix, uint32_t nodeid, uint32_t interface) [member function]
cls.add_method('EnablePcapIpv6',
'void',
[param('std::string', 'prefix'), param('uint32_t', 'nodeid'), param('uint32_t', 'interface')])
## pcap-helper.h: void ns3::PcapUserHelperForIpv6::EnablePcapIpv6All(std::string prefix) [member function]
cls.add_method('EnablePcapIpv6All',
'void',
[param('std::string', 'prefix')])
## pcap-helper.h: void ns3::PcapUserHelperForIpv6::EnablePcapIpv6Internal(std::string prefix, ns3::Ptr<ns3::Ipv6> ipv6, uint32_t interface) [member function]
cls.add_method('EnablePcapIpv6Internal',
'void',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv6 >', 'ipv6'), param('uint32_t', 'interface')],
is_pure_virtual=True, is_virtual=True)
return
def register_Ns3Ping6Helper_methods(root_module, cls):
## ping6-helper.h: ns3::Ping6Helper::Ping6Helper(ns3::Ping6Helper const & arg0) [copy constructor]
cls.add_constructor([param('ns3::Ping6Helper const &', 'arg0')])

264
bindings/python/apidefs/gcc-LP64/ns3_module_helper.py
View File

@@ -9,10 +9,12 @@ def register_types(module):
module.add_class('ApplicationContainer')
## ascii-trace-helper.h: ns3::AsciiTraceHelper [class]
module.add_class('AsciiTraceHelper', allow_subclassing=False)
## ascii-trace-user-helper-for-device.h: ns3::AsciiTraceUserHelperForDevice [class]
## ascii-trace-helper.h: ns3::AsciiTraceUserHelperForDevice [class]
module.add_class('AsciiTraceUserHelperForDevice', allow_subclassing=True)
## ascii-trace-user-helper-for-ipv4.h: ns3::AsciiTraceUserHelperForIpv4 [class]
## ascii-trace-helper.h: ns3::AsciiTraceUserHelperForIpv4 [class]
module.add_class('AsciiTraceUserHelperForIpv4', allow_subclassing=True)
## ascii-trace-helper.h: ns3::AsciiTraceUserHelperForIpv6 [class]
module.add_class('AsciiTraceUserHelperForIpv6', allow_subclassing=True)
## athstats-helper.h: ns3::AthstatsHelper [class]
module.add_class('AthstatsHelper', allow_subclassing=False)
## bridge-helper.h: ns3::BridgeHelper [class]
@@ -73,10 +75,12 @@ def register_types(module):
module.add_enum('', ['DLT_PRISM_HEADER'], outer_class=root_module['ns3::PcapHelper'])
## pcap-helper.h: ns3::PcapHelper [enumeration]
module.add_enum('', ['DLT_IEEE802_11_RADIO'], outer_class=root_module['ns3::PcapHelper'])
## pcap-user-helper-for-device.h: ns3::PcapUserHelperForDevice [class]
## pcap-helper.h: ns3::PcapUserHelperForDevice [class]
module.add_class('PcapUserHelperForDevice', allow_subclassing=True)
## pcap-user-helper-for-ipv4.h: ns3::PcapUserHelperForIpv4 [class]
## pcap-helper.h: ns3::PcapUserHelperForIpv4 [class]
module.add_class('PcapUserHelperForIpv4', allow_subclassing=True)
## pcap-helper.h: ns3::PcapUserHelperForIpv6 [class]
module.add_class('PcapUserHelperForIpv6', allow_subclassing=True)
## ping6-helper.h: ns3::Ping6Helper [class]
module.add_class('Ping6Helper', allow_subclassing=False)
## point-to-point-dumbbell-helper.h: ns3::PointToPointDumbbellHelper [class]
@@ -218,6 +222,7 @@ def register_methods(root_module):
register_Ns3AsciiTraceHelper_methods(root_module, root_module['ns3::AsciiTraceHelper'])
register_Ns3AsciiTraceUserHelperForDevice_methods(root_module, root_module['ns3::AsciiTraceUserHelperForDevice'])
register_Ns3AsciiTraceUserHelperForIpv4_methods(root_module, root_module['ns3::AsciiTraceUserHelperForIpv4'])
register_Ns3AsciiTraceUserHelperForIpv6_methods(root_module, root_module['ns3::AsciiTraceUserHelperForIpv6'])
register_Ns3AthstatsHelper_methods(root_module, root_module['ns3::AthstatsHelper'])
register_Ns3BridgeHelper_methods(root_module, root_module['ns3::BridgeHelper'])
register_Ns3CsmaStarHelper_methods(root_module, root_module['ns3::CsmaStarHelper'])
@@ -242,6 +247,7 @@ def register_methods(root_module):
register_Ns3PcapHelper_methods(root_module, root_module['ns3::PcapHelper'])
register_Ns3PcapUserHelperForDevice_methods(root_module, root_module['ns3::PcapUserHelperForDevice'])
register_Ns3PcapUserHelperForIpv4_methods(root_module, root_module['ns3::PcapUserHelperForIpv4'])
register_Ns3PcapUserHelperForIpv6_methods(root_module, root_module['ns3::PcapUserHelperForIpv6'])
register_Ns3Ping6Helper_methods(root_module, root_module['ns3::Ping6Helper'])
register_Ns3PointToPointDumbbellHelper_methods(root_module, root_module['ns3::PointToPointDumbbellHelper'])
register_Ns3PointToPointGridHelper_methods(root_module, root_module['ns3::PointToPointGridHelper'])
@@ -398,66 +404,66 @@ def register_Ns3AsciiTraceHelper_methods(root_module, cls):
cls.add_method('GetFilenameFromDevice',
'std::string',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'useObjectNames', default_value='true')])
## 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]
## 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]
cls.add_method('GetFilenameFromInterfacePair',
'std::string',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface'), param('bool', 'useObjectNames', default_value='true')])
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::Object >', 'object'), param('uint32_t', 'interface'), param('bool', 'useObjectNames', default_value='true')])
return
def register_Ns3AsciiTraceUserHelperForDevice_methods(root_module, cls):
## ascii-trace-user-helper-for-device.h: ns3::AsciiTraceUserHelperForDevice::AsciiTraceUserHelperForDevice() [constructor]
## ascii-trace-helper.h: ns3::AsciiTraceUserHelperForDevice::AsciiTraceUserHelperForDevice() [constructor]
cls.add_constructor([])
## ascii-trace-user-helper-for-device.h: ns3::AsciiTraceUserHelperForDevice::AsciiTraceUserHelperForDevice(ns3::AsciiTraceUserHelperForDevice const & arg0) [copy constructor]
## ascii-trace-helper.h: ns3::AsciiTraceUserHelperForDevice::AsciiTraceUserHelperForDevice(ns3::AsciiTraceUserHelperForDevice const & arg0) [copy constructor]
cls.add_constructor([param('ns3::AsciiTraceUserHelperForDevice const &', 'arg0')])
## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, ns3::Ptr<ns3::NetDevice> nd) [member function]
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, ns3::Ptr<ns3::NetDevice> nd) [member function]
cls.add_method('EnableAscii',
'void',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd')])
## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::Ptr<ns3::NetDevice> nd) [member function]
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::Ptr<ns3::NetDevice> nd) [member function]
cls.add_method('EnableAscii',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::Ptr< ns3::NetDevice >', 'nd')])
## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, std::string ndName) [member function]
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, std::string ndName) [member function]
cls.add_method('EnableAscii',
'void',
[param('std::string', 'prefix'), param('std::string', 'ndName')])
## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, std::string ndName) [member function]
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, std::string ndName) [member function]
cls.add_method('EnableAscii',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('std::string', 'ndName')])
## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, ns3::NetDeviceContainer d) [member function]
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, ns3::NetDeviceContainer d) [member function]
cls.add_method('EnableAscii',
'void',
[param('std::string', 'prefix'), param('ns3::NetDeviceContainer', 'd')])
## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::NetDeviceContainer d) [member function]
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::NetDeviceContainer d) [member function]
cls.add_method('EnableAscii',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::NetDeviceContainer', 'd')])
## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, ns3::NodeContainer n) [member function]
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, ns3::NodeContainer n) [member function]
cls.add_method('EnableAscii',
'void',
[param('std::string', 'prefix'), param('ns3::NodeContainer', 'n')])
## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::NodeContainer n) [member function]
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::NodeContainer n) [member function]
cls.add_method('EnableAscii',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::NodeContainer', 'n')])
## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, uint32_t nodeid, uint32_t deviceid) [member function]
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(std::string prefix, uint32_t nodeid, uint32_t deviceid) [member function]
cls.add_method('EnableAscii',
'void',
[param('std::string', 'prefix'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')])
## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, uint32_t nodeid, uint32_t deviceid) [member function]
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, uint32_t nodeid, uint32_t deviceid) [member function]
cls.add_method('EnableAscii',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')])
## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAsciiAll(std::string prefix) [member function]
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAsciiAll(std::string prefix) [member function]
cls.add_method('EnableAsciiAll',
'void',
[param('std::string', 'prefix')])
## ascii-trace-user-helper-for-device.h: void ns3::AsciiTraceUserHelperForDevice::EnableAsciiAll(ns3::Ptr<ns3::OutputStreamObject> stream) [member function]
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAsciiAll(ns3::Ptr<ns3::OutputStreamObject> stream) [member function]
cls.add_method('EnableAsciiAll',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream')])
## 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]
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForDevice::EnableAsciiInternal(ns3::Ptr<ns3::OutputStreamObject> stream, std::string prefix, ns3::Ptr<ns3::NetDevice> nd) [member function]
cls.add_method('EnableAsciiInternal',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd')],
@@ -465,65 +471,125 @@ def register_Ns3AsciiTraceUserHelperForDevice_methods(root_module, cls):
return
def register_Ns3AsciiTraceUserHelperForIpv4_methods(root_module, cls):
## ascii-trace-user-helper-for-ipv4.h: ns3::AsciiTraceUserHelperForIpv4::AsciiTraceUserHelperForIpv4() [constructor]
## ascii-trace-helper.h: ns3::AsciiTraceUserHelperForIpv4::AsciiTraceUserHelperForIpv4() [constructor]
cls.add_constructor([])
## ascii-trace-user-helper-for-ipv4.h: ns3::AsciiTraceUserHelperForIpv4::AsciiTraceUserHelperForIpv4(ns3::AsciiTraceUserHelperForIpv4 const & arg0) [copy constructor]
## ascii-trace-helper.h: ns3::AsciiTraceUserHelperForIpv4::AsciiTraceUserHelperForIpv4(ns3::AsciiTraceUserHelperForIpv4 const & arg0) [copy constructor]
cls.add_constructor([param('ns3::AsciiTraceUserHelperForIpv4 const &', 'arg0')])
## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(std::string prefix, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface) [member function]
cls.add_method('EnableAscii',
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(std::string prefix, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface) [member function]
cls.add_method('EnableAsciiIpv4',
'void',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')])
## 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]
cls.add_method('EnableAscii',
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface) [member function]
cls.add_method('EnableAsciiIpv4',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')])
## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(std::string prefix, std::string ipv4Name, uint32_t interface) [member function]
cls.add_method('EnableAscii',
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(std::string prefix, std::string ipv4Name, uint32_t interface) [member function]
cls.add_method('EnableAsciiIpv4',
'void',
[param('std::string', 'prefix'), param('std::string', 'ipv4Name'), param('uint32_t', 'interface')])
## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, std::string ipv4Name, uint32_t interface) [member function]
cls.add_method('EnableAscii',
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(ns3::Ptr<ns3::OutputStreamObject> stream, std::string ipv4Name, uint32_t interface) [member function]
cls.add_method('EnableAsciiIpv4',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('std::string', 'ipv4Name'), param('uint32_t', 'interface')])
## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(std::string prefix, ns3::Ipv4InterfaceContainer c) [member function]
cls.add_method('EnableAscii',
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(std::string prefix, ns3::Ipv4InterfaceContainer c) [member function]
cls.add_method('EnableAsciiIpv4',
'void',
[param('std::string', 'prefix'), param('ns3::Ipv4InterfaceContainer', 'c')])
## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::Ipv4InterfaceContainer c) [member function]
cls.add_method('EnableAscii',
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::Ipv4InterfaceContainer c) [member function]
cls.add_method('EnableAsciiIpv4',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::Ipv4InterfaceContainer', 'c')])
## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(std::string prefix, ns3::NodeContainer n) [member function]
cls.add_method('EnableAscii',
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(std::string prefix, ns3::NodeContainer n) [member function]
cls.add_method('EnableAsciiIpv4',
'void',
[param('std::string', 'prefix'), param('ns3::NodeContainer', 'n')])
## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::NodeContainer n) [member function]
cls.add_method('EnableAscii',
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::NodeContainer n) [member function]
cls.add_method('EnableAsciiIpv4',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::NodeContainer', 'n')])
## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(std::string prefix, uint32_t nodeid, uint32_t deviceid) [member function]
cls.add_method('EnableAscii',
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(std::string prefix, uint32_t nodeid, uint32_t deviceid) [member function]
cls.add_method('EnableAsciiIpv4',
'void',
[param('std::string', 'prefix'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')])
## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAscii(ns3::Ptr<ns3::OutputStreamObject> stream, uint32_t nodeid, uint32_t interface) [member function]
cls.add_method('EnableAscii',
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4(ns3::Ptr<ns3::OutputStreamObject> stream, uint32_t nodeid, uint32_t interface) [member function]
cls.add_method('EnableAsciiIpv4',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('uint32_t', 'nodeid'), param('uint32_t', 'interface')])
## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiAll(std::string prefix) [member function]
cls.add_method('EnableAsciiAll',
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4All(std::string prefix) [member function]
cls.add_method('EnableAsciiIpv4All',
'void',
[param('std::string', 'prefix')])
## ascii-trace-user-helper-for-ipv4.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiAll(ns3::Ptr<ns3::OutputStreamObject> stream) [member function]
cls.add_method('EnableAsciiAll',
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv4::EnableAsciiIpv4All(ns3::Ptr<ns3::OutputStreamObject> stream) [member function]
cls.add_method('EnableAsciiIpv4All',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream')])
## 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]
cls.add_method('EnableAsciiInternal',
## 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]
cls.add_method('EnableAsciiIpv4Internal',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')],
is_pure_virtual=True, is_virtual=True)
return
def register_Ns3AsciiTraceUserHelperForIpv6_methods(root_module, cls):
## ascii-trace-helper.h: ns3::AsciiTraceUserHelperForIpv6::AsciiTraceUserHelperForIpv6() [constructor]
cls.add_constructor([])
## ascii-trace-helper.h: ns3::AsciiTraceUserHelperForIpv6::AsciiTraceUserHelperForIpv6(ns3::AsciiTraceUserHelperForIpv6 const & arg0) [copy constructor]
cls.add_constructor([param('ns3::AsciiTraceUserHelperForIpv6 const &', 'arg0')])
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(std::string prefix, ns3::Ptr<ns3::Ipv6> ipv6, uint32_t interface) [member function]
cls.add_method('EnableAsciiIpv6',
'void',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv6 >', 'ipv6'), param('uint32_t', 'interface')])
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::Ptr<ns3::Ipv6> ipv6, uint32_t interface) [member function]
cls.add_method('EnableAsciiIpv6',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::Ptr< ns3::Ipv6 >', 'ipv6'), param('uint32_t', 'interface')])
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(std::string prefix, std::string ipv6Name, uint32_t interface) [member function]
cls.add_method('EnableAsciiIpv6',
'void',
[param('std::string', 'prefix'), param('std::string', 'ipv6Name'), param('uint32_t', 'interface')])
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(ns3::Ptr<ns3::OutputStreamObject> stream, std::string ipv6Name, uint32_t interface) [member function]
cls.add_method('EnableAsciiIpv6',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('std::string', 'ipv6Name'), param('uint32_t', 'interface')])
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(std::string prefix, ns3::Ipv6InterfaceContainer c) [member function]
cls.add_method('EnableAsciiIpv6',
'void',
[param('std::string', 'prefix'), param('ns3::Ipv6InterfaceContainer', 'c')])
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::Ipv6InterfaceContainer c) [member function]
cls.add_method('EnableAsciiIpv6',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::Ipv6InterfaceContainer', 'c')])
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(std::string prefix, ns3::NodeContainer n) [member function]
cls.add_method('EnableAsciiIpv6',
'void',
[param('std::string', 'prefix'), param('ns3::NodeContainer', 'n')])
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(ns3::Ptr<ns3::OutputStreamObject> stream, ns3::NodeContainer n) [member function]
cls.add_method('EnableAsciiIpv6',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('ns3::NodeContainer', 'n')])
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(std::string prefix, uint32_t nodeid, uint32_t deviceid) [member function]
cls.add_method('EnableAsciiIpv6',
'void',
[param('std::string', 'prefix'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')])
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6(ns3::Ptr<ns3::OutputStreamObject> stream, uint32_t nodeid, uint32_t interface) [member function]
cls.add_method('EnableAsciiIpv6',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('uint32_t', 'nodeid'), param('uint32_t', 'interface')])
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6All(std::string prefix) [member function]
cls.add_method('EnableAsciiIpv6All',
'void',
[param('std::string', 'prefix')])
## ascii-trace-helper.h: void ns3::AsciiTraceUserHelperForIpv6::EnableAsciiIpv6All(ns3::Ptr<ns3::OutputStreamObject> stream) [member function]
cls.add_method('EnableAsciiIpv6All',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream')])
## 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]
cls.add_method('EnableAsciiIpv6Internal',
'void',
[param('ns3::Ptr< ns3::OutputStreamObject >', 'stream'), param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv6 >', 'ipv6'), param('uint32_t', 'interface')],
is_pure_virtual=True, is_virtual=True)
return
def register_Ns3AthstatsHelper_methods(root_module, cls):
## athstats-helper.h: ns3::AthstatsHelper::AthstatsHelper(ns3::AthstatsHelper const & arg0) [copy constructor]
cls.add_constructor([param('ns3::AthstatsHelper const &', 'arg0')])
@@ -839,6 +905,16 @@ def register_Ns3Ipv6InterfaceContainer_methods(root_module, cls):
cls.add_method('Add',
'void',
[param('std::string', 'ipv6Name'), param('uint32_t', 'interface')])
## 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]
cls.add_method('Begin',
'__gnu_cxx::__normal_iterator< std::pair< ns3::Ptr< ns3::Ipv6 >, unsigned int > const, std::vector< std::pair< ns3::Ptr< ns3::Ipv6 >, unsigned int > > >',
[],
is_const=True)
## 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]
cls.add_method('End',
'__gnu_cxx::__normal_iterator< std::pair< ns3::Ptr< ns3::Ipv6 >, unsigned int > const, std::vector< std::pair< ns3::Ptr< ns3::Ipv6 >, unsigned int > > >',
[],
is_const=True)
## ipv6-interface-container.h: ns3::Ipv6Address ns3::Ipv6InterfaceContainer::GetAddress(uint32_t i, uint32_t j) const [member function]
cls.add_method('GetAddress',
'ns3::Ipv6Address',
@@ -1263,42 +1339,42 @@ def register_Ns3PcapHelper_methods(root_module, cls):
cls.add_method('GetFilenameFromDevice',
'std::string',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'useObjectNames', default_value='true')])
## pcap-helper.h: std::string ns3::PcapHelper::GetFilenameFromInterfacePair(std::string prefix, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface, bool useObjectNames=true) [member function]
## pcap-helper.h: std::string ns3::PcapHelper::GetFilenameFromInterfacePair(std::string prefix, ns3::Ptr<ns3::Object> object, uint32_t interface, bool useObjectNames=true) [member function]
cls.add_method('GetFilenameFromInterfacePair',
'std::string',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface'), param('bool', 'useObjectNames', default_value='true')])
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::Object >', 'object'), param('uint32_t', 'interface'), param('bool', 'useObjectNames', default_value='true')])
return
def register_Ns3PcapUserHelperForDevice_methods(root_module, cls):
## pcap-user-helper-for-device.h: ns3::PcapUserHelperForDevice::PcapUserHelperForDevice() [constructor]
## pcap-helper.h: ns3::PcapUserHelperForDevice::PcapUserHelperForDevice() [constructor]
cls.add_constructor([])
## pcap-user-helper-for-device.h: ns3::PcapUserHelperForDevice::PcapUserHelperForDevice(ns3::PcapUserHelperForDevice const & arg0) [copy constructor]
## pcap-helper.h: ns3::PcapUserHelperForDevice::PcapUserHelperForDevice(ns3::PcapUserHelperForDevice const & arg0) [copy constructor]
cls.add_constructor([param('ns3::PcapUserHelperForDevice const &', 'arg0')])
## pcap-user-helper-for-device.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, ns3::Ptr<ns3::NetDevice> nd, bool promiscuous=false) [member function]
## pcap-helper.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, ns3::Ptr<ns3::NetDevice> nd, bool promiscuous=false) [member function]
cls.add_method('EnablePcap',
'void',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd'), param('bool', 'promiscuous', default_value='false')])
## pcap-user-helper-for-device.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, std::string ndName, bool promiscuous=false) [member function]
## pcap-helper.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, std::string ndName, bool promiscuous=false) [member function]
cls.add_method('EnablePcap',
'void',
[param('std::string', 'prefix'), param('std::string', 'ndName'), param('bool', 'promiscuous', default_value='false')])
## pcap-user-helper-for-device.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, ns3::NetDeviceContainer d, bool promiscuous=false) [member function]
## pcap-helper.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, ns3::NetDeviceContainer d, bool promiscuous=false) [member function]
cls.add_method('EnablePcap',
'void',
[param('std::string', 'prefix'), param('ns3::NetDeviceContainer', 'd'), param('bool', 'promiscuous', default_value='false')])
## pcap-user-helper-for-device.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, ns3::NodeContainer n, bool promiscuous=false) [member function]
## pcap-helper.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, ns3::NodeContainer n, bool promiscuous=false) [member function]
cls.add_method('EnablePcap',
'void',
[param('std::string', 'prefix'), param('ns3::NodeContainer', 'n'), param('bool', 'promiscuous', default_value='false')])
## pcap-user-helper-for-device.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, uint32_t nodeid, uint32_t deviceid, bool promiscuous=false) [member function]
## pcap-helper.h: void ns3::PcapUserHelperForDevice::EnablePcap(std::string prefix, uint32_t nodeid, uint32_t deviceid, bool promiscuous=false) [member function]
cls.add_method('EnablePcap',
'void',
[param('std::string', 'prefix'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid'), param('bool', 'promiscuous', default_value='false')])
## pcap-user-helper-for-device.h: void ns3::PcapUserHelperForDevice::EnablePcapAll(std::string prefix, bool promiscuous=false) [member function]
## pcap-helper.h: void ns3::PcapUserHelperForDevice::EnablePcapAll(std::string prefix, bool promiscuous=false) [member function]
cls.add_method('EnablePcapAll',
'void',
[param('std::string', 'prefix'), param('bool', 'promiscuous', default_value='false')])
## pcap-user-helper-for-device.h: void ns3::PcapUserHelperForDevice::EnablePcapInternal(std::string prefix, ns3::Ptr<ns3::NetDevice> nd, bool promiscuous) [member function]
## pcap-helper.h: void ns3::PcapUserHelperForDevice::EnablePcapInternal(std::string prefix, ns3::Ptr<ns3::NetDevice> nd, bool promiscuous) [member function]
cls.add_method('EnablePcapInternal',
'void',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd'), param('bool', 'promiscuous')],
@@ -1306,41 +1382,77 @@ def register_Ns3PcapUserHelperForDevice_methods(root_module, cls):
return
def register_Ns3PcapUserHelperForIpv4_methods(root_module, cls):
## pcap-user-helper-for-ipv4.h: ns3::PcapUserHelperForIpv4::PcapUserHelperForIpv4() [constructor]
## pcap-helper.h: ns3::PcapUserHelperForIpv4::PcapUserHelperForIpv4() [constructor]
cls.add_constructor([])
## pcap-user-helper-for-ipv4.h: ns3::PcapUserHelperForIpv4::PcapUserHelperForIpv4(ns3::PcapUserHelperForIpv4 const & arg0) [copy constructor]
## pcap-helper.h: ns3::PcapUserHelperForIpv4::PcapUserHelperForIpv4(ns3::PcapUserHelperForIpv4 const & arg0) [copy constructor]
cls.add_constructor([param('ns3::PcapUserHelperForIpv4 const &', 'arg0')])
## pcap-user-helper-for-ipv4.h: void ns3::PcapUserHelperForIpv4::EnablePcap(std::string prefix, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface) [member function]
cls.add_method('EnablePcap',
## pcap-helper.h: void ns3::PcapUserHelperForIpv4::EnablePcapIpv4(std::string prefix, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface) [member function]
cls.add_method('EnablePcapIpv4',
'void',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')])
## pcap-user-helper-for-ipv4.h: void ns3::PcapUserHelperForIpv4::EnablePcap(std::string prefix, std::string ipv4Name, uint32_t interface) [member function]
cls.add_method('EnablePcap',
## pcap-helper.h: void ns3::PcapUserHelperForIpv4::EnablePcapIpv4(std::string prefix, std::string ipv4Name, uint32_t interface) [member function]
cls.add_method('EnablePcapIpv4',
'void',
[param('std::string', 'prefix'), param('std::string', 'ipv4Name'), param('uint32_t', 'interface')])
## pcap-user-helper-for-ipv4.h: void ns3::PcapUserHelperForIpv4::EnablePcap(std::string prefix, ns3::Ipv4InterfaceContainer c) [member function]
cls.add_method('EnablePcap',
## pcap-helper.h: void ns3::PcapUserHelperForIpv4::EnablePcapIpv4(std::string prefix, ns3::Ipv4InterfaceContainer c) [member function]
cls.add_method('EnablePcapIpv4',
'void',
[param('std::string', 'prefix'), param('ns3::Ipv4InterfaceContainer', 'c')])
## pcap-user-helper-for-ipv4.h: void ns3::PcapUserHelperForIpv4::EnablePcap(std::string prefix, ns3::NodeContainer n) [member function]
cls.add_method('EnablePcap',
## pcap-helper.h: void ns3::PcapUserHelperForIpv4::EnablePcapIpv4(std::string prefix, ns3::NodeContainer n) [member function]
cls.add_method('EnablePcapIpv4',
'void',
[param('std::string', 'prefix'), param('ns3::NodeContainer', 'n')])
## pcap-user-helper-for-ipv4.h: void ns3::PcapUserHelperForIpv4::EnablePcap(std::string prefix, uint32_t nodeid, uint32_t interface) [member function]
cls.add_method('EnablePcap',
## pcap-helper.h: void ns3::PcapUserHelperForIpv4::EnablePcapIpv4(std::string prefix, uint32_t nodeid, uint32_t interface) [member function]
cls.add_method('EnablePcapIpv4',
'void',
[param('std::string', 'prefix'), param('uint32_t', 'nodeid'), param('uint32_t', 'interface')])
## pcap-user-helper-for-ipv4.h: void ns3::PcapUserHelperForIpv4::EnablePcapAll(std::string prefix) [member function]
cls.add_method('EnablePcapAll',
## pcap-helper.h: void ns3::PcapUserHelperForIpv4::EnablePcapIpv4All(std::string prefix) [member function]
cls.add_method('EnablePcapIpv4All',
'void',
[param('std::string', 'prefix')])
## pcap-user-helper-for-ipv4.h: void ns3::PcapUserHelperForIpv4::EnablePcapInternal(std::string prefix, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface) [member function]
cls.add_method('EnablePcapInternal',
## pcap-helper.h: void ns3::PcapUserHelperForIpv4::EnablePcapIpv4Internal(std::string prefix, ns3::Ptr<ns3::Ipv4> ipv4, uint32_t interface) [member function]
cls.add_method('EnablePcapIpv4Internal',
'void',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')],
is_pure_virtual=True, is_virtual=True)
return
def register_Ns3PcapUserHelperForIpv6_methods(root_module, cls):
## pcap-helper.h: ns3::PcapUserHelperForIpv6::PcapUserHelperForIpv6() [constructor]
cls.add_constructor([])
## pcap-helper.h: ns3::PcapUserHelperForIpv6::PcapUserHelperForIpv6(ns3::PcapUserHelperForIpv6 const & arg0) [copy constructor]
cls.add_constructor([param('ns3::PcapUserHelperForIpv6 const &', 'arg0')])
## pcap-helper.h: void ns3::PcapUserHelperForIpv6::EnablePcapIpv6(std::string prefix, ns3::Ptr<ns3::Ipv6> ipv6, uint32_t interface) [member function]
cls.add_method('EnablePcapIpv6',
'void',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv6 >', 'ipv6'), param('uint32_t', 'interface')])
## pcap-helper.h: void ns3::PcapUserHelperForIpv6::EnablePcapIpv6(std::string prefix, std::string ipv6Name, uint32_t interface) [member function]
cls.add_method('EnablePcapIpv6',
'void',
[param('std::string', 'prefix'), param('std::string', 'ipv6Name'), param('uint32_t', 'interface')])
## pcap-helper.h: void ns3::PcapUserHelperForIpv6::EnablePcapIpv6(std::string prefix, ns3::Ipv6InterfaceContainer c) [member function]
cls.add_method('EnablePcapIpv6',
'void',
[param('std::string', 'prefix'), param('ns3::Ipv6InterfaceContainer', 'c')])
## pcap-helper.h: void ns3::PcapUserHelperForIpv6::EnablePcapIpv6(std::string prefix, ns3::NodeContainer n) [member function]
cls.add_method('EnablePcapIpv6',
'void',
[param('std::string', 'prefix'), param('ns3::NodeContainer', 'n')])
## pcap-helper.h: void ns3::PcapUserHelperForIpv6::EnablePcapIpv6(std::string prefix, uint32_t nodeid, uint32_t interface) [member function]
cls.add_method('EnablePcapIpv6',
'void',
[param('std::string', 'prefix'), param('uint32_t', 'nodeid'), param('uint32_t', 'interface')])
## pcap-helper.h: void ns3::PcapUserHelperForIpv6::EnablePcapIpv6All(std::string prefix) [member function]
cls.add_method('EnablePcapIpv6All',
'void',
[param('std::string', 'prefix')])
## pcap-helper.h: void ns3::PcapUserHelperForIpv6::EnablePcapIpv6Internal(std::string prefix, ns3::Ptr<ns3::Ipv6> ipv6, uint32_t interface) [member function]
cls.add_method('EnablePcapIpv6Internal',
'void',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::Ipv6 >', 'ipv6'), param('uint32_t', 'interface')],
is_pure_virtual=True, is_virtual=True)
return
def register_Ns3Ping6Helper_methods(root_module, cls):
## ping6-helper.h: ns3::Ping6Helper::Ping6Helper(ns3::Ping6Helper const & arg0) [copy constructor]
cls.add_constructor([param('ns3::Ping6Helper const &', 'arg0')])

2
examples/routing/dynamic-global-routing.cc
View File

@@ -194,7 +194,7 @@ main (int argc, char *argv[])
Ptr<OutputStreamObject> stream = ascii.CreateFileStream ("dynamic-global-routing.tr");
p2p.EnableAsciiAll (stream);
csma.EnableAsciiAll (stream);
internet.EnableAsciiAll (stream);
internet.EnableAsciiIpv4All (stream);
p2p.EnablePcapAll ("dynamic-global-routing");
csma.EnablePcapAll ("dynamic-global-routing", false);

2
examples/wireless/mixed-wireless.cc
View File

@@ -392,7 +392,7 @@ main (int argc, char *argv[])
Ptr<OutputStreamObject> stream = ascii.CreateFileStream ("mixed-wireless.tr");
wifiPhy.EnableAsciiAll (stream);
csma.EnableAsciiAll (stream);
internet.EnableAsciiAll (stream);
internet.EnableAsciiIpv4All (stream);
// Let's do a pcap trace on the application source and sink, ifIndex 0
// Csma captures in non-promiscuous mode

267
src/helper/ascii-trace-helper.cc
View File

@@ -134,28 +134,32 @@ AsciiTraceHelper::GetFilenameFromDevice (std::string prefix, Ptr<NetDevice> devi
}
std::string
AsciiTraceHelper::GetFilenameFromInterfacePair (std::string prefix, Ptr<Ipv4> ipv4, uint32_t interface, bool useObjectNames)
AsciiTraceHelper::GetFilenameFromInterfacePair (
std::string prefix,
Ptr<Object> object,
uint32_t interface,
bool useObjectNames)
{
NS_LOG_FUNCTION (prefix << ipv4 << interface << useObjectNames);
NS_LOG_FUNCTION (prefix << object << interface << useObjectNames);
NS_ABORT_MSG_UNLESS (prefix.size (), "Empty prefix string");
std::ostringstream oss;
oss << prefix << "-";
std::string ipv4name;
std::string objname;
std::string nodename;
Ptr<Node> node = ipv4->GetObject<Node> ();
Ptr<Node> node = object->GetObject<Node> ();
if (useObjectNames)
{
ipv4name = Names::FindName (ipv4);
objname = Names::FindName (object);
nodename = Names::FindName (node);
}
if (ipv4name.size ())
if (objname.size ())
{
oss << ipv4name;
oss << objname;
}
else if (nodename.size ())
{
@@ -456,80 +460,80 @@ AsciiTraceUserHelperForDevice::EnableAsciiImpl (
// Public API
//
void
AsciiTraceUserHelperForIpv4::EnableAscii (std::string prefix, Ptr<Ipv4> ipv4, uint32_t interface)
AsciiTraceUserHelperForIpv4::EnableAsciiIpv4 (std::string prefix, Ptr<Ipv4> ipv4, uint32_t interface)
{
EnableAsciiInternal (Ptr<OutputStreamObject> (), prefix, ipv4, interface);
EnableAsciiIpv4Internal (Ptr<OutputStreamObject> (), prefix, ipv4, interface);
}
//
// Public API
//
void
AsciiTraceUserHelperForIpv4::EnableAscii (Ptr<OutputStreamObject> stream, Ptr<Ipv4> ipv4, uint32_t interface)
AsciiTraceUserHelperForIpv4::EnableAsciiIpv4 (Ptr<OutputStreamObject> stream, Ptr<Ipv4> ipv4, uint32_t interface)
{
EnableAsciiInternal (stream, std::string (), ipv4, interface);
EnableAsciiIpv4Internal (stream, std::string (), ipv4, interface);
}
//
// Public API
//
void
AsciiTraceUserHelperForIpv4::EnableAscii (std::string prefix, std::string ipv4Name, uint32_t interface)
AsciiTraceUserHelperForIpv4::EnableAsciiIpv4 (std::string prefix, std::string ipv4Name, uint32_t interface)
{
EnableAsciiImpl (Ptr<OutputStreamObject> (), prefix, ipv4Name, interface);
EnableAsciiIpv4Impl (Ptr<OutputStreamObject> (), prefix, ipv4Name, interface);
}
//
// Public API
//
void
AsciiTraceUserHelperForIpv4::EnableAscii (Ptr<OutputStreamObject> stream, std::string ipv4Name, uint32_t interface)
AsciiTraceUserHelperForIpv4::EnableAsciiIpv4 (Ptr<OutputStreamObject> stream, std::string ipv4Name, uint32_t interface)
{
EnableAsciiImpl (stream, std::string (), ipv4Name, interface);
EnableAsciiIpv4Impl (stream, std::string (), ipv4Name, interface);
}
//
// Private API
//
void
AsciiTraceUserHelperForIpv4::EnableAsciiImpl (
AsciiTraceUserHelperForIpv4::EnableAsciiIpv4Impl (
Ptr<OutputStreamObject> stream,
std::string prefix,
std::string ipv4Name,
uint32_t interface)
{
Ptr<Ipv4> ipv4 = Names::Find<Ipv4> (ipv4Name);
EnableAsciiInternal (stream, prefix, ipv4, interface);
EnableAsciiIpv4Internal (stream, prefix, ipv4, interface);
}
//
// Public API
//
void
AsciiTraceUserHelperForIpv4::EnableAscii (std::string prefix, Ipv4InterfaceContainer c)
AsciiTraceUserHelperForIpv4::EnableAsciiIpv4 (std::string prefix, Ipv4InterfaceContainer c)
{
EnableAsciiImpl (Ptr<OutputStreamObject> (), prefix, c);
EnableAsciiIpv4Impl (Ptr<OutputStreamObject> (), prefix, c);
}
//
// Public API
//
void
AsciiTraceUserHelperForIpv4::EnableAscii (Ptr<OutputStreamObject> stream, Ipv4InterfaceContainer c)
AsciiTraceUserHelperForIpv4::EnableAsciiIpv4 (Ptr<OutputStreamObject> stream, Ipv4InterfaceContainer c)
{
EnableAsciiImpl (stream, std::string (), c);
EnableAsciiIpv4Impl (stream, std::string (), c);
}
//
// Private API
//
void
AsciiTraceUserHelperForIpv4::EnableAsciiImpl (Ptr<OutputStreamObject> stream, std::string prefix, Ipv4InterfaceContainer c)
AsciiTraceUserHelperForIpv4::EnableAsciiIpv4Impl (Ptr<OutputStreamObject> stream, std::string prefix, Ipv4InterfaceContainer c)
{
for (Ipv4InterfaceContainer::Iterator i = c.Begin (); i != c.End (); ++i)
{
std::pair<Ptr<Ipv4>, uint32_t> pair = *i;
EnableAsciiInternal (stream, prefix, pair.first, pair.second);
EnableAsciiIpv4Internal (stream, prefix, pair.first, pair.second);
}
}
@@ -537,25 +541,25 @@ AsciiTraceUserHelperForIpv4::EnableAsciiImpl (Ptr<OutputStreamObject> stream, st
// Public API
//
void
AsciiTraceUserHelperForIpv4::EnableAscii (std::string prefix, NodeContainer n)
AsciiTraceUserHelperForIpv4::EnableAsciiIpv4 (std::string prefix, NodeContainer n)
{
EnableAsciiImpl (Ptr<OutputStreamObject> (), prefix, n);
EnableAsciiIpv4Impl (Ptr<OutputStreamObject> (), prefix, n);
}
//
// Public API
//
void
AsciiTraceUserHelperForIpv4::EnableAscii (Ptr<OutputStreamObject> stream, NodeContainer n)
AsciiTraceUserHelperForIpv4::EnableAsciiIpv4 (Ptr<OutputStreamObject> stream, NodeContainer n)
{
EnableAsciiImpl (stream, std::string (), n);
EnableAsciiIpv4Impl (stream, std::string (), n);
}
//
// Private API
//
void
AsciiTraceUserHelperForIpv4::EnableAsciiImpl (Ptr<OutputStreamObject> stream, std::string prefix, NodeContainer n)
AsciiTraceUserHelperForIpv4::EnableAsciiIpv4Impl (Ptr<OutputStreamObject> stream, std::string prefix, NodeContainer n)
{
for (NodeContainer::Iterator i = n.Begin (); i != n.End (); ++i)
{
@@ -565,7 +569,7 @@ AsciiTraceUserHelperForIpv4::EnableAsciiImpl (Ptr<OutputStreamObject> stream, st
{
for (uint32_t j = 0; j < ipv4->GetNInterfaces (); ++j)
{
EnableAsciiInternal (stream, prefix, ipv4, j);
EnableAsciiIpv4Internal (stream, prefix, ipv4, j);
}
}
}
@@ -575,43 +579,43 @@ AsciiTraceUserHelperForIpv4::EnableAsciiImpl (Ptr<OutputStreamObject> stream, st
// Public API
//
void
AsciiTraceUserHelperForIpv4::EnableAsciiAll (std::string prefix)
AsciiTraceUserHelperForIpv4::EnableAsciiIpv4All (std::string prefix)
{
EnableAsciiImpl (Ptr<OutputStreamObject> (), prefix, NodeContainer::GetGlobal ());
EnableAsciiIpv4Impl (Ptr<OutputStreamObject> (), prefix, NodeContainer::GetGlobal ());
}
//
// Public API
//
void
AsciiTraceUserHelperForIpv4::EnableAsciiAll (Ptr<OutputStreamObject> stream)
AsciiTraceUserHelperForIpv4::EnableAsciiIpv4All (Ptr<OutputStreamObject> stream)
{
EnableAsciiImpl (stream, std::string (), NodeContainer::GetGlobal ());
EnableAsciiIpv4Impl (stream, std::string (), NodeContainer::GetGlobal ());
}
//
// Public API
//
void
AsciiTraceUserHelperForIpv4::EnableAscii (Ptr<OutputStreamObject> stream, uint32_t nodeid, uint32_t interface)
AsciiTraceUserHelperForIpv4::EnableAsciiIpv4 (Ptr<OutputStreamObject> stream, uint32_t nodeid, uint32_t interface)
{
EnableAsciiImpl (stream, std::string (), nodeid, interface);
EnableAsciiIpv4Impl (stream, std::string (), nodeid, interface);
}
//
// Public API
//
void
AsciiTraceUserHelperForIpv4::EnableAscii (std::string prefix, uint32_t nodeid, uint32_t interface)
AsciiTraceUserHelperForIpv4::EnableAsciiIpv4 (std::string prefix, uint32_t nodeid, uint32_t interface)
{
EnableAsciiImpl (Ptr<OutputStreamObject> (), prefix, nodeid, interface);
EnableAsciiIpv4Impl (Ptr<OutputStreamObject> (), prefix, nodeid, interface);
}
//
// Private API
//
void
AsciiTraceUserHelperForIpv4::EnableAsciiImpl (
AsciiTraceUserHelperForIpv4::EnableAsciiIpv4Impl (
Ptr<OutputStreamObject> stream,
std::string prefix,
uint32_t nodeid,
@@ -630,7 +634,192 @@ AsciiTraceUserHelperForIpv4::EnableAsciiImpl (
Ptr<Ipv4> ipv4 = node->GetObject<Ipv4> ();
if (ipv4)
{
EnableAsciiInternal (stream, prefix, ipv4, interface);
EnableAsciiIpv4Internal (stream, prefix, ipv4, interface);
}
return;
}
}
//
// Public API
//
void
AsciiTraceUserHelperForIpv6::EnableAsciiIpv6 (std::string prefix, Ptr<Ipv6> ipv6, uint32_t interface)
{
EnableAsciiIpv6Internal (Ptr<OutputStreamObject> (), prefix, ipv6, interface);
}
//
// Public API
//
void
AsciiTraceUserHelperForIpv6::EnableAsciiIpv6 (Ptr<OutputStreamObject> stream, Ptr<Ipv6> ipv6, uint32_t interface)
{
EnableAsciiIpv6Internal (stream, std::string (), ipv6, interface);
}
//
// Public API
//
void
AsciiTraceUserHelperForIpv6::EnableAsciiIpv6 (std::string prefix, std::string ipv6Name, uint32_t interface)
{
EnableAsciiIpv6Impl (Ptr<OutputStreamObject> (), prefix, ipv6Name, interface);
}
//
// Public API
//
void
AsciiTraceUserHelperForIpv6::EnableAsciiIpv6 (Ptr<OutputStreamObject> stream, std::string ipv6Name, uint32_t interface)
{
EnableAsciiIpv6Impl (stream, std::string (), ipv6Name, interface);
}
//
// Private API
//
void
AsciiTraceUserHelperForIpv6::EnableAsciiIpv6Impl (
Ptr<OutputStreamObject> stream,
std::string prefix,
std::string ipv6Name,
uint32_t interface)
{
Ptr<Ipv6> ipv6 = Names::Find<Ipv6> (ipv6Name);
EnableAsciiIpv6Internal (stream, prefix, ipv6, interface);
}
//
// Public API
//
void
AsciiTraceUserHelperForIpv6::EnableAsciiIpv6 (std::string prefix, Ipv6InterfaceContainer c)
{
EnableAsciiIpv6Impl (Ptr<OutputStreamObject> (), prefix, c);
}
//
// Public API
//
void
AsciiTraceUserHelperForIpv6::EnableAsciiIpv6 (Ptr<OutputStreamObject> stream, Ipv6InterfaceContainer c)
{
EnableAsciiIpv6Impl (stream, std::string (), c);
}
//
// Private API
//
void
AsciiTraceUserHelperForIpv6::EnableAsciiIpv6Impl (Ptr<OutputStreamObject> stream, std::string prefix, Ipv6InterfaceContainer c)
{
for (Ipv6InterfaceContainer::Iterator i = c.Begin (); i != c.End (); ++i)
{
std::pair<Ptr<Ipv6>, uint32_t> pair = *i;
EnableAsciiIpv6Internal (stream, prefix, pair.first, pair.second);
}
}
//
// Public API
//
void
AsciiTraceUserHelperForIpv6::EnableAsciiIpv6 (std::string prefix, NodeContainer n)
{
EnableAsciiIpv6Impl (Ptr<OutputStreamObject> (), prefix, n);
}
//
// Public API
//
void
AsciiTraceUserHelperForIpv6::EnableAsciiIpv6 (Ptr<OutputStreamObject> stream, NodeContainer n)
{
EnableAsciiIpv6Impl (stream, std::string (), n);
}
//
// Private API
//
void
AsciiTraceUserHelperForIpv6::EnableAsciiIpv6Impl (Ptr<OutputStreamObject> stream, std::string prefix, NodeContainer n)
{
for (NodeContainer::Iterator i = n.Begin (); i != n.End (); ++i)
{
Ptr<Node> node = *i;
Ptr<Ipv6> ipv6 = node->GetObject<Ipv6> ();
if (ipv6)
{
for (uint32_t j = 0; j < ipv6->GetNInterfaces (); ++j)
{
EnableAsciiIpv6Internal (stream, prefix, ipv6, j);
}
}
}
}
//
// Public API
//
void
AsciiTraceUserHelperForIpv6::EnableAsciiIpv6All (std::string prefix)
{
EnableAsciiIpv6Impl (Ptr<OutputStreamObject> (), prefix, NodeContainer::GetGlobal ());
}
//
// Public API
//
void
AsciiTraceUserHelperForIpv6::EnableAsciiIpv6All (Ptr<OutputStreamObject> stream)
{
EnableAsciiIpv6Impl (stream, std::string (), NodeContainer::GetGlobal ());
}
//
// Public API
//
void
AsciiTraceUserHelperForIpv6::EnableAsciiIpv6 (Ptr<OutputStreamObject> stream, uint32_t nodeid, uint32_t interface)
{
EnableAsciiIpv6Impl (stream, std::string (), nodeid, interface);
}
//
// Public API
//
void
AsciiTraceUserHelperForIpv6::EnableAsciiIpv6 (std::string prefix, uint32_t nodeid, uint32_t interface)
{
EnableAsciiIpv6Impl (Ptr<OutputStreamObject> (), prefix, nodeid, interface);
}
//
// Private API
//
void
AsciiTraceUserHelperForIpv6::EnableAsciiIpv6Impl (
Ptr<OutputStreamObject> stream,
std::string prefix,
uint32_t nodeid,
uint32_t interface)
{
NodeContainer n = NodeContainer::GetGlobal ();
for (NodeContainer::Iterator i = n.Begin (); i != n.End (); ++i)
{
Ptr<Node> node = *i;
if (node->GetId () != nodeid)
{
continue;
}
Ptr<Ipv6> ipv6 = node->GetObject<Ipv6> ();
if (ipv6)
{
EnableAsciiIpv6Internal (stream, prefix, ipv6, interface);
}
return;

247
src/helper/ascii-trace-helper.h
View File

@@ -21,10 +21,12 @@
#include "ns3/assert.h"
#include "ns3/net-device-container.h"
#include "ns3/ipv4.h"
#include "ns3/ipv4-interface-container.h"
#include "ns3/ipv6.h"
#include "ns3/ipv6-interface-container.h"
#include "ns3/node-container.h"
#include "ns3/simulator.h"
#include "ns3/ipv4.h"
#include "ns3/output-stream-object.h"
namespace ns3 {
@@ -59,7 +61,7 @@ public:
* @brief Let the ascii trace helper figure out a reasonable filename to use
* for an ascii trace file associated with a node.
*/
std::string GetFilenameFromInterfacePair (std::string prefix, Ptr<Ipv4> ipv4,
std::string GetFilenameFromInterfacePair (std::string prefix, Ptr<Object> object,
uint32_t interface, bool useObjectNames = true);
/**
@@ -460,7 +462,7 @@ public:
* @param ipv4 Ptr<Ipv4> on which you want to enable tracing.
* @param interface The interface on which you want to enable tracing.
*/
virtual void EnableAsciiInternal (Ptr<OutputStreamObject> stream, std::string prefix,
virtual void EnableAsciiIpv4Internal (Ptr<OutputStreamObject> stream, std::string prefix,
Ptr<Ipv4> ipv4, uint32_t interface) = 0;
/**
@@ -470,7 +472,7 @@ public:
* @param ipv4 Ptr<Ipv4> on which you want to enable tracing.
* @param interface The interface on which you want to enable tracing.
*/
void EnableAscii (std::string prefix, Ptr<Ipv4> ipv4, uint32_t interface);
void EnableAsciiIpv4 (std::string prefix, Ptr<Ipv4> ipv4, uint32_t interface);
/**
* @brief Enable ascii trace output on the indicated Ipv4 and interface pair.
@@ -480,7 +482,7 @@ public:
* @param ipv4 Ptr<Ipv4> on which you want to enable tracing.
* @param interface The interface on which you want to enable tracing.
*/
void EnableAscii (Ptr<OutputStreamObject> stream, Ptr<Ipv4> ipv4, uint32_t interface);
void EnableAsciiIpv4 (Ptr<OutputStreamObject> stream, Ptr<Ipv4> ipv4, uint32_t interface);
/**
* @brief Enable ascii trace output the indicated Ipv4 and interface pair
@@ -490,7 +492,7 @@ public:
* @param ipv4Name The name of the Ipv4 on which you want to enable tracing.
* @param interface The interface on which you want to enable tracing.
*/
void EnableAscii (std::string prefix, std::string ipv4Name, uint32_t interface);
void EnableAsciiIpv4 (std::string prefix, std::string ipv4Name, uint32_t interface);
/**
* @brief Enable ascii trace output the indicated net device using a device
@@ -501,7 +503,7 @@ public:
* @param ipv4Name The name of the Ipv4 on which you want to enable tracing.
* @param interface The interface on which you want to enable tracing.
*/
void EnableAscii (Ptr<OutputStreamObject> stream, std::string ipv4Name, uint32_t interface);
void EnableAsciiIpv4 (Ptr<OutputStreamObject> stream, std::string ipv4Name, uint32_t interface);
/**
* @brief Enable ascii trace output on each Ipv4 and interface pair in the
@@ -511,7 +513,7 @@ public:
* @param c Ipv4InterfaceContainer of Ipv4 and interface pairs on which to
* enable tracing.
*/
void EnableAscii (std::string prefix, Ipv4InterfaceContainer c);
void EnableAsciiIpv4 (std::string prefix, Ipv4InterfaceContainer c);
/**
* @brief Enable ascii trace output on each device in the container which is
@@ -522,7 +524,7 @@ public:
* @param c Ipv4InterfaceContainer of Ipv4 and interface pairs on which to
* enable tracing.
*/
void EnableAscii (Ptr<OutputStreamObject> stream, Ipv4InterfaceContainer c);
void EnableAsciiIpv4 (Ptr<OutputStreamObject> stream, Ipv4InterfaceContainer c);
/**
* @brief Enable ascii trace output on all Ipv4 and interface pairs existing
@@ -531,7 +533,7 @@ public:
* \param prefix Filename prefix to use for ascii files.
* \param n container of nodes.
*/
void EnableAscii (std::string prefix, NodeContainer n);
void EnableAsciiIpv4 (std::string prefix, NodeContainer n);
/**
* @brief Enable ascii trace output on all Ipv4 and interface pairs existing
@@ -541,7 +543,7 @@ public:
* when writing trace data.
* \param n container of nodes.
*/
void EnableAscii (Ptr<OutputStreamObject> stream, NodeContainer n);
void EnableAsciiIpv4 (Ptr<OutputStreamObject> stream, NodeContainer n);
/**
* @brief Enable ascii trace output on all Ipv4 and interface pairs existing
@@ -549,7 +551,7 @@ public:
*
* @param prefix Filename prefix to use for ascii files.
*/
void EnableAsciiAll (std::string prefix);
void EnableAsciiIpv4All (std::string prefix);
/**
* @brief Enable ascii trace output on each device (which is of the
@@ -558,7 +560,7 @@ public:
* @param stream An OutputStreamObject representing an existing file to use
* when writing trace data.
*/
void EnableAsciiAll (Ptr<OutputStreamObject> stream);
void EnableAsciiIpv4All (Ptr<OutputStreamObject> stream);
/**
* @brief Enable pcap output on the Ipv4 and interface pair specified by a
@@ -572,7 +574,7 @@ public:
* @param interface The device identifier/index of the device on which to enable
* ascii tracing
*/
void EnableAscii (std::string prefix, uint32_t nodeid, uint32_t deviceid);
void EnableAsciiIpv4 (std::string prefix, uint32_t nodeid, uint32_t deviceid);
/**
* @brief Enable pcap output on the Ipv4 and interface pair specified by a
@@ -586,33 +588,238 @@ public:
* ascii tracing
* @param interface The interface on which you want to enable tracing.
*/
void EnableAscii (Ptr<OutputStreamObject> stream, uint32_t nodeid, uint32_t interface);
void EnableAsciiIpv4 (Ptr<OutputStreamObject> stream, uint32_t nodeid, uint32_t interface);
private:
/**
* @internal Avoid code duplication.
*/
void EnableAsciiImpl (Ptr<OutputStreamObject> stream, std::string prefix, uint32_t nodeid, uint32_t interface);
void EnableAsciiIpv4Impl (Ptr<OutputStreamObject> stream, std::string prefix, uint32_t nodeid, uint32_t interface);
/**
* @internal Avoid code duplication.
*/
void EnableAsciiImpl (Ptr<OutputStreamObject> stream, std::string prefix, NodeContainer n);
void EnableAsciiIpv4Impl (Ptr<OutputStreamObject> stream, std::string prefix, NodeContainer n);
/**
* @internal Avoid code duplication.
*/
void EnableAsciiImpl (Ptr<OutputStreamObject> stream, std::string prefix, Ipv4InterfaceContainer c);
void EnableAsciiIpv4Impl (Ptr<OutputStreamObject> stream, std::string prefix, Ipv4InterfaceContainer c);
/**
* @internal Avoid code duplication.
*/
void EnableAsciiImpl (Ptr<OutputStreamObject> stream, std::string prefix, std::string ipv4Name, uint32_t interface);
void EnableAsciiIpv4Impl (Ptr<OutputStreamObject> stream, std::string prefix, std::string ipv4Name, uint32_t interface);
/**
* @internal Avoid code duplication.
*/
void EnableAsciiImpl (Ptr<OutputStreamObject> stream, std::string prefix, Ptr<Ipv4> ipv4, uint32_t interface);
void EnableAsciiIpv4Impl (Ptr<OutputStreamObject> stream, std::string prefix, Ptr<Ipv4> ipv4, uint32_t interface);
};
/**
* @brief Base class providing common ascii trace operations for helpers
* working with Ipv6 interfaces.
*
* There are two basic flavors of ascii tracing. The first kind will case a
* trace file to be created for every traced device in the form
* <file prefix>-<node number>-<device index>.tr just like the pcap trace
* helpers would do. Additionally, if the object name service is used to
* define either the node or device, the name will be substituted in the
* file name. This form of ascii tracing does not include a context string
* and makes it easier to determine the source of the event.
*
* The second kind of tracing is more like ns-2 tracing in that there is
* one trace file into which all of the specified events of the specified
* devices are written. This form of ascii tracing does include a context
* string and interleaves the trace hits from all of the devices into a
* single file.
*/
class AsciiTraceUserHelperForIpv6
{
public:
/**
* @brief Enable ascii trace output on the indicated Ipv6 and interface pair.
* @internal
*
* The implementation is expected to use a provided Ptr<OutputStreamObject>
* if it is non-null. If the OutputStreamObject is null, the implementation
* is expected to use a provided prefix to construct a new file name for
* each net device using the rules described in the class overview.
*
* If the prefix is provided, there will be one file per Ipv6 and interface pair
* created. In this case, adding a trace context to the file would be pointless,
* so the helper implementation is expected to TraceConnectWithoutContext.
*
* If the output stream object is provided, there may be many different Ipv6
* and interface pairs writing to a single file. In this case, the trace
* context could be important, so the helper implementation is expected to
* TraceConnect.
*
* @param stream An OutputStreamObject representing an existing file to use
* when writing trace data.
* @param prefix Filename prefix to use for ascii trace files.
* @param ipv6 Ptr<Ipv6> on which you want to enable tracing.
* @param interface The interface on which you want to enable tracing.
*/
virtual void EnableAsciiIpv6Internal (Ptr<OutputStreamObject> stream, std::string prefix,
Ptr<Ipv6> ipv6, uint32_t interface) = 0;
/**
* @brief Enable ascii trace output on the indicated Ipv6 and interface pair.
*
* @param prefix Filename prefix to use for ascii files.
* @param ipv6 Ptr<Ipv6> on which you want to enable tracing.
* @param interface The interface on which you want to enable tracing.
*/
void EnableAsciiIpv6 (std::string prefix,
Ptr<Ipv6> ipv6, uint32_t interface);
/**
* @brief Enable ascii trace output on the indicated Ipv6 and interface pair.
*
* @param stream An OutputStreamObject representing an existing file to use
* when writing trace data.
* @param ipv6 Ptr<Ipv6> on which you want to enable tracing.
* @param interface The interface on which you want to enable tracing.
*/
void EnableAsciiIpv6 (Ptr<OutputStreamObject> stream,
Ptr<Ipv6> ipv6, uint32_t interface);
/**
* @brief Enable ascii trace output the indicated Ipv6 and interface pair
* using an Ipv6 previously named using the ns-3 object name service.
*
* @param filename filename prefix to use for ascii files.
* @param ipv6Name The name of the Ipv6 on which you want to enable tracing.
* @param interface The interface on which you want to enable tracing.
*/
void EnableAsciiIpv6 (std::string prefix,
std::string ipv6Name, uint32_t interface);
/**
* @brief Enable ascii trace output the indicated net device using a device
* previously named using the ns-3 object name service.
*
* @param stream An OutputStreamObject representing an existing file to use
* when writing trace data.
* @param ipv6Name The name of the Ipv6 on which you want to enable tracing.
* @param interface The interface on which you want to enable tracing.
*/
void EnableAsciiIpv6 (Ptr<OutputStreamObject> stream,
std::string ipv6Name, uint32_t interface);
/**
* @brief Enable ascii trace output on each Ipv6 and interface pair in the
* container
*
* @param prefix Filename prefix to use for ascii files.
* @param c Ipv6InterfaceContainer of Ipv6 and interface pairs on which to
* enable tracing.
*/
void EnableAsciiIpv6 (std::string prefix, Ipv6InterfaceContainer c);
/**
* @brief Enable ascii trace output on each device in the container which is
* of the appropriate type.
*
* @param stream An OutputStreamObject representing an existing file to use
* when writing trace data.
* @param c Ipv6InterfaceContainer of Ipv6 and interface pairs on which to
* enable tracing.
*/
void EnableAsciiIpv6 (Ptr<OutputStreamObject> stream, Ipv6InterfaceContainer c);
/**
* @brief Enable ascii trace output on all Ipv6 and interface pairs existing
* in the nodes provided in the container.
*
* \param prefix Filename prefix to use for ascii files.
* \param n container of nodes.
*/
void EnableAsciiIpv6 (std::string prefix, NodeContainer n);
/**
* @brief Enable ascii trace output on all Ipv6 and interface pairs existing
* in the nodes provided in the container.
*
* @param stream An OutputStreamObject representing an existing file to use
* when writing trace data.
* \param n container of nodes.
*/
void EnableAsciiIpv6 (Ptr<OutputStreamObject> stream, NodeContainer n);
/**
* @brief Enable pcap output on the Ipv6 and interface pair specified by a
* global node-id (of a previously created node) and interface. Since there
* can be only one Ipv6 aggregated to a node, the node-id unambiguously
* determines the Ipv6.
*
* @param prefix Filename prefix to use when creating ascii trace files
* @param nodeid The node identifier/number of the node on which to enable
* ascii tracing
* @param interface The device identifier/index of the device on which to enable
* ascii tracing
*/
void EnableAsciiIpv6 (std::string prefix, uint32_t nodeid, uint32_t deviceid);
/**
* @brief Enable pcap output on the Ipv6 and interface pair specified by a
* global node-id (of a previously created node) and interface. Since there
* can be only one Ipv6 aggregated to a node, the node-id unambiguously
* determines the Ipv6.
*
* @param stream An OutputStreamObject representing an existing file to use
* when writing trace data.
* @param nodeid The node identifier/number of the node on which to enable
* ascii tracing
* @param interface The interface on which you want to enable tracing.
*/
void EnableAsciiIpv6 (Ptr<OutputStreamObject> stream, uint32_t nodeid, uint32_t interface);
/**
* @brief Enable ascii trace output on all Ipv6 and interface pairs existing
* in the set of all nodes created in the simulation.
*
* @param prefix Filename prefix to use for ascii files.
*/
void EnableAsciiIpv6All (std::string prefix);
/**
* @brief Enable ascii trace output on each device (which is of the
* appropriate type) in the set of all nodes created in the simulation.
*
* @param stream An OutputStreamObject representing an existing file to use
* when writing trace data.
*/
void EnableAsciiIpv6All (Ptr<OutputStreamObject> stream);
private:
/**
* @internal Avoid code duplication.
*/
void EnableAsciiIpv6Impl (Ptr<OutputStreamObject> stream, std::string prefix, uint32_t nodeid, uint32_t interface);
/**
* @internal Avoid code duplication.
*/
void EnableAsciiIpv6Impl (Ptr<OutputStreamObject> stream, std::string prefix, NodeContainer n);
/**
* @internal Avoid code duplication.
*/
void EnableAsciiIpv6Impl (Ptr<OutputStreamObject> stream, std::string prefix, Ipv6InterfaceContainer c);
/**
* @internal Avoid code duplication.
*/
void EnableAsciiIpv6Impl (Ptr<OutputStreamObject> stream, std::string prefix, std::string ipv6Name, uint32_t interface);
/**
* @internal Avoid code duplication.
*/
void EnableAsciiIpv6Impl (Ptr<OutputStreamObject> stream, std::string prefix, Ptr<Ipv6> ipv6, uint32_t interface);
};

201
src/helper/internet-stack-helper.cc
View File

@@ -191,10 +191,15 @@ namespace ns3 {
// destroyed; but must be cleaned up at the end of time to avoid leaks. A
// global map of interface pairs to pcap file objects seems to fit the bill.
//
typedef std::pair<Ptr<Ipv4>, uint32_t> InterfacePair;
typedef std::map<InterfacePair, Ptr<PcapFileObject> > InterfaceFileMap;
typedef std::pair<Ptr<Ipv4>, uint32_t> InterfacePairIpv4;
typedef std::map<InterfacePairIpv4, Ptr<PcapFileObject> > InterfaceFileMapIpv4;
static InterfaceFileMap g_interfaceFileMap;
static InterfaceFileMapIpv4 g_interfaceFileMapIpv4;
typedef std::pair<Ptr<Ipv6>, uint32_t> InterfacePairIpv6;
typedef std::map<InterfacePairIpv6, Ptr<PcapFileObject> > InterfaceFileMapIpv6;
static InterfaceFileMapIpv6 g_interfaceFileMapIpv6;
InternetStackHelper::InternetStackHelper ()
: m_routing (0),
@@ -383,27 +388,27 @@ Ipv4L3ProtocolRxTxSink (Ptr<const Packet> p, Ptr<Ipv4> ipv4, uint32_t interface)
{
NS_LOG_FUNCTION (p << ipv4 << interface);
InterfacePair pair = std::make_pair (ipv4, interface);
InterfacePairIpv4 pair = std::make_pair (ipv4, interface);
if (g_interfaceFileMap.find (pair) == g_interfaceFileMap.end ())
if (g_interfaceFileMapIpv4.find (pair) == g_interfaceFileMapIpv4.end ())
{
NS_LOG_INFO ("Ignoring packet to/from interface " << interface);
return;
}
Ptr<PcapFileObject> file = g_interfaceFileMap[pair];
Ptr<PcapFileObject> file = g_interfaceFileMapIpv4[pair];
file->Write(Simulator::Now(), p);
}
void
InternetStackHelper::EnablePcapInternal (std::string prefix, Ptr<Ipv4> ipv4, uint32_t interface)
InternetStackHelper::EnablePcapIpv4Internal (std::string prefix, Ptr<Ipv4> ipv4, uint32_t interface)
{
NS_LOG_FUNCTION (prefix << ipv4 << interface);
PcapHelper pcapHelper;
std::string filename = pcapHelper.GetFilenameFromInterfacePair (prefix, ipv4, interface);
Ptr<PcapFileObject> file = pcapHelper.CreateFile (filename, "w", PcapHelper::DLT_RAW);
g_interfaceFileMap[std::make_pair (ipv4, interface)] = file;
g_interfaceFileMapIpv4[std::make_pair (ipv4, interface)] = file;
if (m_ipv4Enabled)
{
@@ -412,14 +417,63 @@ InternetStackHelper::EnablePcapInternal (std::string prefix, Ptr<Ipv4> ipv4, uin
// node so we can get to Ipv4L3Protocol through Ipv4.
//
Ptr<Ipv4L3Protocol> ipv4L3Protocol = ipv4->GetObject<Ipv4L3Protocol> ();
NS_ASSERT_MSG (ipv4L3Protocol, "InternetStackHelper::EnablePcapInternal(): "
NS_ASSERT_MSG (ipv4L3Protocol, "InternetStackHelper::EnablePcapIpv4Internal(): "
"m_ipv4Enabled and ipv4L3Protocol inconsistent");
bool result = ipv4L3Protocol->TraceConnectWithoutContext ("Tx", MakeCallback (&Ipv4L3ProtocolRxTxSink));
NS_ASSERT_MSG (result == true, "InternetStackHelper::EnablePcapInternal(): Unable to connect ipv4L3Protocol \"Tx\"");
NS_ASSERT_MSG (result == true, "InternetStackHelper::EnablePcapIpv4Internal(): "
"Unable to connect ipv4L3Protocol \"Tx\"");
result = ipv4L3Protocol->TraceConnectWithoutContext ("Rx", MakeCallback (&Ipv4L3ProtocolRxTxSink));
NS_ASSERT_MSG (result == true, "InternetStackHelper::EnablePcapInternal(): Unable to connect ipv4L3Protocol \"Rx\"");
NS_ASSERT_MSG (result == true, "InternetStackHelper::EnablePcapIpv4Internal(): "
"Unable to connect ipv4L3Protocol \"Rx\"");
}
}
static void
Ipv6L3ProtocolRxTxSink (Ptr<const Packet> p, Ptr<Ipv6> ipv6, uint32_t interface)
{
NS_LOG_FUNCTION (p << ipv6 << interface);
InterfacePairIpv6 pair = std::make_pair (ipv6, interface);
if (g_interfaceFileMapIpv6.find (pair) == g_interfaceFileMapIpv6.end ())
{
NS_LOG_INFO ("Ignoring packet to/from interface " << interface);
return;
}
Ptr<PcapFileObject> file = g_interfaceFileMapIpv6[pair];
file->Write(Simulator::Now(), p);
}
void
InternetStackHelper::EnablePcapIpv6Internal (std::string prefix, Ptr<Ipv6> ipv6, uint32_t interface)
{
NS_LOG_FUNCTION (prefix << ipv6 << interface);
PcapHelper pcapHelper;
std::string filename = pcapHelper.GetFilenameFromInterfacePair (prefix, ipv6, interface);
Ptr<PcapFileObject> file = pcapHelper.CreateFile (filename, "w", PcapHelper::DLT_RAW);
g_interfaceFileMapIpv6[std::make_pair (ipv6, interface)] = file;
if (m_ipv6Enabled)
{
//
// Ptr<Ipv6> is aggregated to node and Ipv6L3Protocol is aggregated to
// node so we can get to Ipv6L3Protocol through Ipv6.
//
Ptr<Ipv6L3Protocol> ipv6L3Protocol = ipv6->GetObject<Ipv6L3Protocol> ();
NS_ASSERT_MSG (ipv6L3Protocol, "InternetStackHelper::EnablePcapIpv6Internal(): "
"m_ipv6Enabled and ipv6L3Protocol inconsistent");
bool result = ipv6L3Protocol->TraceConnectWithoutContext ("Tx", MakeCallback (&Ipv6L3ProtocolRxTxSink));
NS_ASSERT_MSG (result == true, "InternetStackHelper::EnablePcapIpv6Internal(): "
"Unable to connect ipv6L3Protocol \"Tx\"");
result = ipv6L3Protocol->TraceConnectWithoutContext ("Rx", MakeCallback (&Ipv6L3ProtocolRxTxSink));
NS_ASSERT_MSG (result == true, "InternetStackHelper::EnablePcapIpv6Internal(): "
"Unable to connect ipv6L3Protocol \"Rx\"");
}
}
@@ -451,12 +505,18 @@ Ipv4L3ProtocolDropSinkWithContext (
}
void
InternetStackHelper::EnableAsciiInternal (
InternetStackHelper::EnableAsciiIpv4Internal (
Ptr<OutputStreamObject> stream,
std::string prefix,
Ptr<Ipv4> ipv4,
uint32_t interface)
{
if (!m_ipv4Enabled)
{
NS_LOG_INFO ("Call to enable Ipv4 ascii tracing but Ipv4 not enabled");
return;
}
//
// Our trace sinks are going to use packet printing, so we have to
// make sure that is turned on.
@@ -497,7 +557,8 @@ InternetStackHelper::EnableAsciiInternal (
Ptr<Ipv4L3Protocol> ipv4L3Protocol = ipv4->GetObject<Ipv4L3Protocol> ();
bool result = ipv4L3Protocol->TraceConnectWithoutContext ("Drop",
MakeBoundCallback (&Ipv4L3ProtocolDropSinkWithoutContext, theStream));
NS_ASSERT_MSG (result == true, "InternetStackHelper::EnableAsciiInternal(): Unable to connect ipv4L3Protocol \"Drop\"");
NS_ASSERT_MSG (result == true, "InternetStackHelper::EnableAsciiIpv4Internal(): "
"Unable to connect ipv4L3Protocol \"Drop\"");
return;
}
@@ -523,37 +584,95 @@ InternetStackHelper::EnableAsciiInternal (
Config::Connect (oss.str (), MakeBoundCallback (&Ipv4L3ProtocolDropSinkWithContext, stream));
}
#if 0
void
InternetStackHelper::EnableAscii (std::ostream &os, NodeContainer n)
{
Ptr<AsciiWriter> writer = AsciiWriter::Get (os);
Packet::EnablePrinting ();
std::ostringstream oss;
for (NodeContainer::Iterator i = n.Begin (); i != n.End (); ++i)
{
Ptr<Node> node = *i;
oss << "/NodeList/" << node->GetId () << "/$ns3::Ipv4L3Protocol/Drop";
Config::Connect (oss.str (), MakeBoundCallback (&InternetStackHelper::AsciiDropEventIpv4, writer));
oss.str ("");
oss << "/NodeList/" << node->GetId () << "/$ns3::ArpL3Protocol/Drop";
Config::Connect (oss.str (), MakeBoundCallback (&InternetStackHelper::AsciiDropEventArp, writer));
oss.str ("");
oss << "/NodeList/" << node->GetId () << "/$ns3::Ipv6L3Protocol/Drop";
Config::Connect (oss.str (), MakeBoundCallback (&InternetStackHelper::AsciiDropEventIpv6, writer));
oss.str ("");
}
}
void
InternetStackHelper::AsciiDropEventIpv6 (Ptr<AsciiWriter> writer, std::string path,
Ipv6Header const &header, Ptr<const Packet> packet,
Ipv6L3Protocol::DropReason reason, uint32_t interface)
static void
Ipv6L3ProtocolDropSinkWithoutContext (
Ptr<OutputStreamObject> stream,
Ipv6Header const &header,
Ptr<const Packet> packet,
Ipv6L3Protocol::DropReason reason,
uint32_t interface)
{
Ptr<Packet> p = packet->Copy ();
p->AddHeader (header);
writer->WritePacket (AsciiWriter::DROP, path, p);
*stream->GetStream () << "d " << Simulator::Now ().GetSeconds () << " " << *p << std::endl;
}
static void
Ipv6L3ProtocolDropSinkWithContext (
Ptr<OutputStreamObject> stream,
std::string context,
Ipv6Header const &header,
Ptr<const Packet> packet,
Ipv6L3Protocol::DropReason reason,
uint32_t interface)
{
Ptr<Packet> p = packet->Copy ();
p->AddHeader (header);
*stream->GetStream () << "d " << Simulator::Now ().GetSeconds () << " " << context << " " << *p << std::endl;
}
void
InternetStackHelper::EnableAsciiIpv6Internal (
Ptr<OutputStreamObject> stream,
std::string prefix,
Ptr<Ipv6> ipv6,
uint32_t interface)
{
if (!m_ipv6Enabled)
{
NS_LOG_INFO ("Call to enable Ipv6 ascii tracing but Ipv6 not enabled");
return;
}
//
// Our trace sinks are going to use packet printing, so we have to
// make sure that is turned on.
//
Packet::EnablePrinting ();
//
// If we are not provided an OutputStreamObject, we are expected to create
// one using the usual trace filename conventions and do a Hook*WithoutContext
// since there will be one file per context and therefore the context would
// be redundant.
//
if (stream == 0)
{
//
// Set up an output stream object to deal with private ofstream copy
// constructor and lifetime issues. Let the helper decide the actual
// name of the file given the prefix.
//
AsciiTraceHelper asciiTraceHelper;
std::string filename = asciiTraceHelper.GetFilenameFromInterfacePair (prefix, ipv6, interface);
Ptr<OutputStreamObject> theStream = asciiTraceHelper.CreateFileStream (filename, "w");
//
// The drop sink for the Ipv6L3Protocol uses a different signature than
// the default sink, so we have to cook one up for ourselves. We can get
// to the Ptr<Ipv6L3Protocol> through our Ptr<Ipv6> since they must both
// be aggregated to the same node.
//
Ptr<Ipv6L3Protocol> ipv6L3Protocol = ipv6->GetObject<Ipv6L3Protocol> ();
bool result = ipv6L3Protocol->TraceConnectWithoutContext ("Drop",
MakeBoundCallback (&Ipv6L3ProtocolDropSinkWithoutContext, theStream));
NS_ASSERT_MSG (result == true, "InternetStackHelper::EnableAsciiIpv6Internal(): "
"Unable to connect ipv6L3Protocol \"Drop\"");
return;
}
//
// If we are provided an OutputStreamObject, we are expected to use it, and
// to providd a context. We are free to come up with our own context if we
// want, and use the AsciiTraceHelper Hook*WithContext functions, but for
// compatibility and simplicity, we just use Config::Connect and let it deal
// with the context.
//
Ptr<Node> node = ipv6->GetObject<Node> ();
std::ostringstream oss;
oss << "/NodeList/" << node->GetId () << "/$ns3::Ipv6L3Protocol/Drop";
Config::Connect (oss.str (), MakeBoundCallback (&Ipv6L3ProtocolDropSinkWithContext, stream));
}
#endif
} // namespace ns3

89
src/helper/internet-stack-helper.h
View File

@@ -53,11 +53,12 @@ class Ipv6RoutingHelper;
* encapsulates a general attribute or a set of functionality that
* may be of interest to many other classes.
*
* Since the mixins below are self-contained and are explicitly
* designed to avoid naming conflicts through explicit resolution,
* multiple inheritance problems are avoided.
* Since the mixins below are completely self-contained and are explicitly
* designed to avoid naming conflicts through explicit resolution, multiple
* inheritance problems are avoided.
*/
class InternetStackHelper : public PcapUserHelperForIpv4, public AsciiTraceUserHelperForIpv4
class InternetStackHelper : public PcapUserHelperForIpv4, public AsciiTraceUserHelperForIpv4,
public PcapUserHelperForIpv6, public AsciiTraceUserHelperForIpv6
{
public:
/**
@@ -182,7 +183,8 @@ private:
* @param ipv4 Ptr to the Ipv4 interface on which you want to enable tracing.
* @param interface Interface ID on the Ipv4 on which you want to enable tracing.
*/
virtual void EnablePcapInternal (std::string prefix, Ptr<Ipv4> ipv4, uint32_t interface);
virtual void EnablePcapIpv4Internal (std::string prefix,
Ptr<Ipv4> ipv4, uint32_t interface);
/**
* @brief Enable ascii trace output on the indicated Ipv4 and interface pair.
@@ -194,7 +196,32 @@ private:
* @param ipv4 Ptr to the Ipv4 interface on which you want to enable tracing.
* @param interface Interface ID on the Ipv4 on which you want to enable tracing.
*/
virtual void EnableAsciiInternal (Ptr<OutputStreamObject> stream, std::string prefix, Ptr<Ipv4> ipv4, uint32_t interface);
virtual void EnableAsciiIpv4Internal (Ptr<OutputStreamObject> stream, std::string prefix,
Ptr<Ipv4> ipv4, uint32_t interface);
/**
* @brief Enable pcap output the indicated Ipv4 and interface pair.
* @internal
*
* @param prefix Filename prefix to use for pcap files.
* @param ipv4 Ptr to the Ipv4 interface on which you want to enable tracing.
* @param interface Interface ID on the Ipv4 on which you want to enable tracing.
*/
virtual void EnablePcapIpv6Internal (std::string prefix,
Ptr<Ipv6> ipv6, uint32_t interface);
/**
* @brief Enable ascii trace output on the indicated Ipv4 and interface pair.
* @internal
*
* @param stream An OutputStreamObject representing an existing file to use
* when writing trace data.
* @param prefix Filename prefix to use for ascii trace files.
* @param ipv4 Ptr to the Ipv4 interface on which you want to enable tracing.
* @param interface Interface ID on the Ipv4 on which you want to enable tracing.
*/
virtual void EnableAsciiIpv6Internal (Ptr<OutputStreamObject> stream, std::string prefix,
Ptr<Ipv6> ipv6, uint32_t interface);
void Initialize (void);
ObjectFactory m_tcpFactory;
@@ -216,56 +243,6 @@ private:
*/
static void Cleanup (void);
#if 0
/**
* \internal
*/
static void LogRxIp (std::string context, Ptr<const Packet> packet, uint32_t deviceId);
/**
* \internal
*/
static void LogTxIp (std::string context, Ptr<const Packet> packet, uint32_t deviceId);
/**
* \internal
*/
static Ptr<PcapWriter> GetStream (uint32_t nodeId, uint32_t interfaceId);
struct Trace {
uint32_t nodeId;
uint32_t interfaceId;
Ptr<PcapWriter> writer;
};
/**
* \internal
*/
static void AsciiDropEventIpv4 (Ptr<AsciiWriter> writer, std::string path,
Ipv4Header const &header, Ptr<const Packet> packet,
Ipv4L3Protocol::DropReason reason, uint32_t interface);
/**
* \internal
*/
static void AsciiDropEventArp (Ptr<AsciiWriter> writer, std::string path, Ptr<const Packet> packet);
/**
* \internal
*/
static void AsciiDropEventIpv6 (Ptr<AsciiWriter> writer, std::string path,
Ipv6Header const &header, Ptr<const Packet> packet,
Ipv6L3Protocol::DropReason reason, uint32_t interface);
static std::string m_pcapBaseFilename;
/**
* \internal
*/
static uint32_t GetNodeIndex (std::string context);
static std::vector<Trace> m_traces;
#endif
/**
* \brief IPv4 install state (enabled/disabled) ?
*/

12
src/helper/ipv6-interface-container.cc
View File

@@ -31,6 +31,18 @@ Ipv6InterfaceContainer::Ipv6InterfaceContainer ()
{
}
Ipv6InterfaceContainer::Iterator
Ipv6InterfaceContainer::Begin (void) const
{
return m_interfaces.begin ();
}
Ipv6InterfaceContainer::Iterator
Ipv6InterfaceContainer::End (void) const
{
return m_interfaces.end ();
}
uint32_t Ipv6InterfaceContainer::GetN () const
{
return m_interfaces.size ();

64
src/helper/ipv6-interface-container.h
View File

@@ -38,14 +38,30 @@ namespace ns3
class Ipv6InterfaceContainer
{
public:
typedef std::vector<std::pair<Ptr<Ipv6>, uint32_t> >::const_iterator Iterator;
/**
* \brief Constructor.
*/
Ipv6InterfaceContainer ();
/**
* \brief Get the number of interfaces.
* \return the number of interfaces stored in this Ipv6InterfaceContainer.
* \returns the number of Ptr<Ipv6> and interface pairs stored in this
* Ipv4InterfaceContainer.
*
* Pairs can be retrieved from the container in two ways. First,
* directly by an index into the container, and second, using an iterator.
* This method is used in the direct method and is typically used to
* define an ending condition in a for-loop that runs through the stored
* Nodes
*
* \code
* uint32_t nNodes = container.GetN ();
* for (uint32_t i = 0 i < nNodes; ++i)
* {
* std::pair<Ptr<Ipv6>, uint32_t> pair = container.Get (i);
* method (pair.first, pair.second); // use the pair
* }
* \endcode
*/
uint32_t GetN (void) const;
@@ -71,6 +87,50 @@ public:
*/
void Add (Ptr<Ipv6> ipv6, uint32_t interface);
/**
* \brief Get an iterator which refers to the first pair in the
* container.
*
* Pairs can be retrieved from the container in two ways. First,
* directly by an index into the container, and second, using an iterator.
* This method is used in the iterator method and is typically used in a
* for-loop to run through the pairs
*
* \code
* Ipv4InterfaceContainer::Iterator i;
* for (i = container.Begin (); i != container.End (); ++i)
* {
* std::pair<Ptr<Ipv6>, uint32_t> pair = *i;
* method (pair.first, pair.second); // use the pair
* }
* \endcode
*
* \returns an iterator which refers to the first pair in the container.
*/
Iterator Begin (void) const;
/**
* \brief Get an iterator which indicates past-the-last Node in the
* container.
*
* Nodes can be retrieved from the container in two ways. First,
* directly by an index into the container, and second, using an iterator.
* This method is used in the iterator method and is typically used in a
* for-loop to run through the Nodes
*
* \code
* NodeContainer::Iterator i;
* for (i = container.Begin (); i != container.End (); ++i)
* {
* std::pair<Ptr<Ipv6>, uint32_t> pair = *i;
* method (pair.first, pair.second); // use the pair
* }
* \endcode
*
* \returns an iterator which indicates an ending condition for a loop.
*/
Iterator End (void) const;
/**
* \brief Fusion with another Ipv6InterfaceContainer.
* \param c container

106
src/helper/pcap-helper.cc
View File

@@ -122,28 +122,28 @@ PcapHelper::GetFilenameFromDevice (std::string prefix, Ptr<NetDevice> device, bo
}
std::string
PcapHelper::GetFilenameFromInterfacePair (std::string prefix, Ptr<Ipv4> ipv4, uint32_t interface, bool useObjectNames)
PcapHelper::GetFilenameFromInterfacePair (std::string prefix, Ptr<Object> object, uint32_t interface, bool useObjectNames)
{
NS_LOG_FUNCTION (prefix << ipv4 << interface << useObjectNames);
NS_LOG_FUNCTION (prefix << object << interface << useObjectNames);
NS_ABORT_MSG_UNLESS (prefix.size (), "Empty prefix string");
std::ostringstream oss;
oss << prefix << "-";
std::string ipv4name;
std::string objname;
std::string nodename;
Ptr<Node> node = ipv4->GetObject<Node> ();
Ptr<Node> node = object->GetObject<Node> ();
if (useObjectNames)
{
ipv4name = Names::FindName (ipv4);
objname = Names::FindName (object);
nodename = Names::FindName (node);
}
if (ipv4name.size ())
if (objname.size ())
{
oss << ipv4name;
oss << objname;
}
else if (nodename.size ())
{
@@ -236,30 +236,30 @@ PcapUserHelperForDevice::EnablePcap (std::string prefix, uint32_t nodeid, uint32
}
void
PcapUserHelperForIpv4::EnablePcap (std::string prefix, Ptr<Ipv4> ipv4, uint32_t interface)
PcapUserHelperForIpv4::EnablePcapIpv4 (std::string prefix, Ptr<Ipv4> ipv4, uint32_t interface)
{
EnablePcapInternal (prefix, ipv4, interface);
EnablePcapIpv4Internal (prefix, ipv4, interface);
}
void
PcapUserHelperForIpv4::EnablePcap (std::string prefix, std::string ipv4Name, uint32_t interface)
PcapUserHelperForIpv4::EnablePcapIpv4 (std::string prefix, std::string ipv4Name, uint32_t interface)
{
Ptr<Ipv4> ipv4 = Names::Find<Ipv4> (ipv4Name);
EnablePcap (prefix, ipv4, interface);
EnablePcapIpv4 (prefix, ipv4, interface);
}
void
PcapUserHelperForIpv4::EnablePcap (std::string prefix, Ipv4InterfaceContainer c)
PcapUserHelperForIpv4::EnablePcapIpv4 (std::string prefix, Ipv4InterfaceContainer c)
{
for (Ipv4InterfaceContainer::Iterator i = c.Begin (); i != c.End (); ++i)
{
std::pair<Ptr<Ipv4>, uint32_t> pair = *i;
EnablePcap (prefix, pair.first, pair.second);
EnablePcapIpv4 (prefix, pair.first, pair.second);
}
}
void
PcapUserHelperForIpv4::EnablePcap (std::string prefix, NodeContainer n)
PcapUserHelperForIpv4::EnablePcapIpv4 (std::string prefix, NodeContainer n)
{
for (NodeContainer::Iterator i = n.Begin (); i != n.End (); ++i)
{
@@ -269,20 +269,20 @@ PcapUserHelperForIpv4::EnablePcap (std::string prefix, NodeContainer n)
{
for (uint32_t j = 0; j < ipv4->GetNInterfaces (); ++j)
{
EnablePcap (prefix, ipv4, j);
EnablePcapIpv4 (prefix, ipv4, j);
}
}
}
}
void
PcapUserHelperForIpv4::EnablePcapAll (std::string prefix)
PcapUserHelperForIpv4::EnablePcapIpv4All (std::string prefix)
{
EnablePcap (prefix, NodeContainer::GetGlobal ());
EnablePcapIpv4 (prefix, NodeContainer::GetGlobal ());
}
void
PcapUserHelperForIpv4::EnablePcap (std::string prefix, uint32_t nodeid, uint32_t interface)
PcapUserHelperForIpv4::EnablePcapIpv4 (std::string prefix, uint32_t nodeid, uint32_t interface)
{
NodeContainer n = NodeContainer::GetGlobal ();
@@ -297,7 +297,75 @@ PcapUserHelperForIpv4::EnablePcap (std::string prefix, uint32_t nodeid, uint32_t
Ptr<Ipv4> ipv4 = node->GetObject<Ipv4> ();
if (ipv4)
{
EnablePcap (prefix, ipv4, interface);
EnablePcapIpv4 (prefix, ipv4, interface);
}
return;
}
}
void
PcapUserHelperForIpv6::EnablePcapIpv6 (std::string prefix, Ptr<Ipv6> ipv6, uint32_t interface)
{
EnablePcapIpv6Internal (prefix, ipv6, interface);
}
void
PcapUserHelperForIpv6::EnablePcapIpv6 (std::string prefix, std::string ipv6Name, uint32_t interface)
{
Ptr<Ipv6> ipv6 = Names::Find<Ipv6> (ipv6Name);
EnablePcapIpv6 (prefix, ipv6, interface);
}
void
PcapUserHelperForIpv6::EnablePcapIpv6 (std::string prefix, Ipv6InterfaceContainer c)
{
for (Ipv6InterfaceContainer::Iterator i = c.Begin (); i != c.End (); ++i)
{
std::pair<Ptr<Ipv6>, uint32_t> pair = *i;
EnablePcapIpv6 (prefix, pair.first, pair.second);
}
}
void
PcapUserHelperForIpv6::EnablePcapIpv6 (std::string prefix, NodeContainer n)
{
for (NodeContainer::Iterator i = n.Begin (); i != n.End (); ++i)
{
Ptr<Node> node = *i;
Ptr<Ipv6> ipv6 = node->GetObject<Ipv6> ();
if (ipv6)
{
for (uint32_t j = 0; j < ipv6->GetNInterfaces (); ++j)
{
EnablePcapIpv6 (prefix, ipv6, j);
}
}
}
}
void
PcapUserHelperForIpv6::EnablePcapIpv6All (std::string prefix)
{
EnablePcapIpv6 (prefix, NodeContainer::GetGlobal ());
}
void
PcapUserHelperForIpv6::EnablePcapIpv6 (std::string prefix, uint32_t nodeid, uint32_t interface)
{
NodeContainer n = NodeContainer::GetGlobal ();
for (NodeContainer::Iterator i = n.Begin (); i != n.End (); ++i)
{
Ptr<Node> node = *i;
if (node->GetId () != nodeid)
{
continue;
}
Ptr<Ipv6> ipv6 = node->GetObject<Ipv6> ();
if (ipv6)
{
EnablePcapIpv6 (prefix, ipv6, interface);
}
return;
}

123
src/helper/pcap-helper.h
View File

@@ -22,10 +22,12 @@
#include "ns3/assert.h"
#include "ns3/net-device-container.h"
#include "ns3/ipv4-interface-container.h"
#include "ns3/ipv6-interface-container.h"
#include "ns3/node-container.h"
#include "ns3/simulator.h"
#include "ns3/pcap-file-object.h"
#include "ns3/ipv4.h"
#include "ns3/ipv6.h"
namespace ns3 {
@@ -73,7 +75,7 @@ public:
* @brief Let the pcap helper figure out a reasonable filename to use for the
* pcap file associated with a node.
*/
std::string GetFilenameFromInterfacePair (std::string prefix, Ptr<Ipv4> ipv4,
std::string GetFilenameFromInterfacePair (std::string prefix, Ptr<Object> object,
uint32_t interface, bool useObjectNames = true);
/**
@@ -153,15 +155,6 @@ public:
*/
void EnablePcap (std::string prefix, NodeContainer n, bool promiscuous = false);
/**
* @brief Enable pcap output on each device (which is of the appropriate type)
* in the set of all nodes created in the simulation.
*
* @param prefix Filename prefix to use for pcap files.
* @param promiscuous If true capture all possible packets available at the device.
*/
void EnablePcapAll (std::string prefix, bool promiscuous = false);
/**
* @brief Enable pcap output on the device specified by a global node-id (of
* a previously created node) and associated device-id.
@@ -170,6 +163,15 @@ public:
* @param promiscuous If true capture all possible packets available at the device.
*/
void EnablePcap (std::string prefix, uint32_t nodeid, uint32_t deviceid, bool promiscuous = false);
/**
* @brief Enable pcap output on each device (which is of the appropriate type)
* in the set of all nodes created in the simulation.
*
* @param prefix Filename prefix to use for pcap files.
* @param promiscuous If true capture all possible packets available at the device.
*/
void EnablePcapAll (std::string prefix, bool promiscuous = false);
};
/**
@@ -187,7 +189,7 @@ public:
* @param ipv4 Ptr<Ipv4> on which you want to enable tracing.
* @param interface Interface on ipv4 on which you want to enable tracing.
*/
virtual void EnablePcapInternal (std::string prefix, Ptr<Ipv4> ipv4, uint32_t interface) = 0;
virtual void EnablePcapIpv4Internal (std::string prefix, Ptr<Ipv4> ipv4, uint32_t interface) = 0;
/**
* @brief Enable pcap output the indicated Ipv4 and interface pair.
@@ -196,7 +198,7 @@ public:
* @param ipv4 Ptr<Ipv4> on which you want to enable tracing.
* @param interface Interface on ipv4 on which you want to enable tracing.
*/
void EnablePcap (std::string prefix, Ptr<Ipv4> ipv4, uint32_t interface);
void EnablePcapIpv4 (std::string prefix, Ptr<Ipv4> ipv4, uint32_t interface);
/**
* @brief Enable pcap output the indicated Ipv4 and interface pair using a
@@ -206,7 +208,7 @@ public:
* @param ipv4Name Name of the Ptr<Ipv4> on which you want to enable tracing.
* @param interface Interface on ipv4 on which you want to enable tracing.
*/
void EnablePcap (std::string prefix, std::string ipv4Name, uint32_t interface);
void EnablePcapIpv4 (std::string prefix, std::string ipv4Name, uint32_t interface);
/**
* @brief Enable pcap output on each Ipv4 and interface pair in the container.
@@ -214,7 +216,7 @@ public:
* @param prefix Filename prefix to use for pcap files.
* @param c Ipv4InterfaceContainer of Ipv4 and interface pairs
*/
void EnablePcap (std::string prefix, Ipv4InterfaceContainer c);
void EnablePcapIpv4 (std::string prefix, Ipv4InterfaceContainer c);
/**
* @brief Enable pcap output on all Ipv4 and interface pairs existing in the
@@ -223,15 +225,7 @@ public:
* \param prefix Filename prefix to use for pcap files.
* \param n container of nodes.
*/
void EnablePcap (std::string prefix, NodeContainer n);
/**
* @brief Enable pcap output on all Ipv4 and interface pairs existing in the
* set of all nodes created in the simulation.
*
* @param prefix Filename prefix to use for pcap files.
*/
void EnablePcapAll (std::string prefix);
void EnablePcapIpv4 (std::string prefix, NodeContainer n);
/**
* @brief Enable pcap output on the Ipv4 and interface pair specified by a
@@ -241,7 +235,88 @@ public:
*
* @param prefix Filename prefix to use for pcap files.
*/
void EnablePcap (std::string prefix, uint32_t nodeid, uint32_t interface);
void EnablePcapIpv4 (std::string prefix, uint32_t nodeid, uint32_t interface);
/**
* @brief Enable pcap output on all Ipv4 and interface pairs existing in the
* set of all nodes created in the simulation.
*
* @param prefix Filename prefix to use for pcap files.
*/
void EnablePcapIpv4All (std::string prefix);
};
/**
* \brief Base class providing common user-level pcap operations for helpers
* representing IPv6 protocols .
*/
class PcapUserHelperForIpv6
{
public:
/**
* @brief Enable pcap output the indicated Ipv6 and interface pair.
* @internal
*
* @param prefix Filename prefix to use for pcap files.
* @param ipv6 Ptr<Ipv6> on which you want to enable tracing.
* @param interface Interface on ipv6 on which you want to enable tracing.
*/
virtual void EnablePcapIpv6Internal (std::string prefix, Ptr<Ipv6> ipv6, uint32_t interface) = 0;
/**
* @brief Enable pcap output the indicated Ipv6 and interface pair.
*
* @param prefix Filename prefix to use for pcap files.
* @param ipv6 Ptr<Ipv6> on which you want to enable tracing.
* @param interface Interface on ipv6 on which you want to enable tracing.
*/
void EnablePcapIpv6 (std::string prefix, Ptr<Ipv6> ipv6, uint32_t interface);
/**
* @brief Enable pcap output the indicated Ipv6 and interface pair using a
* Ptr<Ipv6> previously named using the ns-3 object name service.
*
* @param filename filename prefix to use for pcap files.
* @param ipv6Name Name of the Ptr<Ipv6> on which you want to enable tracing.
* @param interface Interface on ipv6 on which you want to enable tracing.
*/
void EnablePcapIpv6 (std::string prefix, std::string ipv6Name, uint32_t interface);
/**
* @brief Enable pcap output on each Ipv6 and interface pair in the container.
*
* @param prefix Filename prefix to use for pcap files.
* @param c Ipv6InterfaceContainer of Ipv6 and interface pairs
*/
void EnablePcapIpv6 (std::string prefix, Ipv6InterfaceContainer c);
/**
* @brief Enable pcap output on all Ipv6 and interface pairs existing in the
* nodes provided in the container.
*
* \param prefix Filename prefix to use for pcap files.
* \param n container of nodes.
*/
void EnablePcapIpv6 (std::string prefix, NodeContainer n);
/**
* @brief Enable pcap output on the Ipv6 and interface pair specified by a
* global node-id (of a previously created node) and interface. Since there
* can be only one Ipv6 aggregated to a node, the node-id unambiguously
* determines the Ipv6.
*
* @param prefix Filename prefix to use for pcap files.
*/
void EnablePcapIpv6 (std::string prefix, uint32_t nodeid, uint32_t interface);
/**
* @brief Enable pcap output on all Ipv6 and interface pairs existing in the
* set of all nodes created in the simulation.
*
* @param prefix Filename prefix to use for pcap files.
*/
void EnablePcapIpv6All (std::string prefix);
};
} // namespace ns3