ns-3.5: bindings/python/ns3_module

     1 from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandlers

     3 def register_types(module):

     4     root_module = module.get_root()

     6     ## ethernet-header.h: ns3::ethernet_header_t [enumeration]

     7     module.add_enum('ethernet_header_t', ['LENGTH', 'VLAN', 'QINQ'])

     8     ## address.h: ns3::Address [class]

     9     module.add_class('Address')

    10     ## address.h: ns3::Address::MaxSize_e [enumeration]

    11     module.add_enum('MaxSize_e', ['MAX_SIZE'], outer_class=root_module['ns3::Address'])

    12     ## inet6-socket-address.h: ns3::Inet6SocketAddress [class]

    13     module.add_class('Inet6SocketAddress')

    14     ## inet6-socket-address.h: ns3::Inet6SocketAddress [class]

    15     root_module['ns3::Inet6SocketAddress'].implicitly_converts_to(root_module['ns3::Address'])

    16     ## inet-socket-address.h: ns3::InetSocketAddress [class]

    17     module.add_class('InetSocketAddress')

    18     ## inet-socket-address.h: ns3::InetSocketAddress [class]

    19     root_module['ns3::InetSocketAddress'].implicitly_converts_to(root_module['ns3::Address'])

    20     ## ipv4-address.h: ns3::Ipv4Address [class]

    21     module.add_class('Ipv4Address')

    22     ## ipv4-address.h: ns3::Ipv4Address [class]

    23     root_module['ns3::Ipv4Address'].implicitly_converts_to(root_module['ns3::Address'])

    24     ## ipv4-address-generator.h: ns3::Ipv4AddressGenerator [class]

    25     module.add_class('Ipv4AddressGenerator')

    26     ## ipv4-interface-address.h: ns3::Ipv4InterfaceAddress [class]

    27     module.add_class('Ipv4InterfaceAddress')

    28     ## ipv4-interface-address.h: ns3::Ipv4InterfaceAddress::InterfaceAddressScope_e [enumeration]

    29     module.add_enum('InterfaceAddressScope_e', ['HOST', 'LINK', 'GLOBAL'], outer_class=root_module['ns3::Ipv4InterfaceAddress'])

    30     ## ipv4-address.h: ns3::Ipv4Mask [class]

    31     module.add_class('Ipv4Mask')

    32     ## ipv6-address.h: ns3::Ipv6Address [class]

    33     module.add_class('Ipv6Address')

    34     ## ipv6-address.h: ns3::Ipv6Address [class]

    35     root_module['ns3::Ipv6Address'].implicitly_converts_to(root_module['ns3::Address'])

    36     ## ipv6-address.h: ns3::Ipv6Prefix [class]

    37     module.add_class('Ipv6Prefix')

    38     ## mac48-address.h: ns3::Mac48Address [class]

    39     module.add_class('Mac48Address')

    40     ## mac48-address.h: ns3::Mac48Address [class]

    41     root_module['ns3::Mac48Address'].implicitly_converts_to(root_module['ns3::Address'])

    42     ## mac64-address.h: ns3::Mac64Address [class]

    43     module.add_class('Mac64Address')

    44     ## mac64-address.h: ns3::Mac64Address [class]

    45     root_module['ns3::Mac64Address'].implicitly_converts_to(root_module['ns3::Address'])

    46     ## node-list.h: ns3::NodeList [class]

    47     module.add_class('NodeList')

    48     ## packet-socket-address.h: ns3::PacketSocketAddress [class]

    49     module.add_class('PacketSocketAddress')

    50     ## packet-socket-address.h: ns3::PacketSocketAddress [class]

    51     root_module['ns3::PacketSocketAddress'].implicitly_converts_to(root_module['ns3::Address'])

    52     ## ipv4-address.h: ns3::Ipv4AddressChecker [class]

    53     module.add_class('Ipv4AddressChecker', parent=root_module['ns3::AttributeChecker'])

    54     ## ipv4-address.h: ns3::Ipv4AddressValue [class]

    55     module.add_class('Ipv4AddressValue', parent=root_module['ns3::AttributeValue'])

    56     ## ipv4-header.h: ns3::Ipv4Header [class]

    57     module.add_class('Ipv4Header', parent=root_module['ns3::Header'])

    58     ## ipv4-address.h: ns3::Ipv4MaskChecker [class]

    59     module.add_class('Ipv4MaskChecker', parent=root_module['ns3::AttributeChecker'])

    60     ## ipv4-address.h: ns3::Ipv4MaskValue [class]

    61     module.add_class('Ipv4MaskValue', parent=root_module['ns3::AttributeValue'])

    62     ## ipv4-route.h: ns3::Ipv4MulticastRoute [class]

    63     module.add_class('Ipv4MulticastRoute', parent=root_module['ns3::RefCountBase'])

    64     ## ipv4-route.h: ns3::Ipv4Route [class]

    65     module.add_class('Ipv4Route', parent=root_module['ns3::RefCountBase'])

    66     ## ipv6-address.h: ns3::Ipv6AddressChecker [class]

    67     module.add_class('Ipv6AddressChecker', parent=root_module['ns3::AttributeChecker'])

    68     ## ipv6-address.h: ns3::Ipv6AddressValue [class]

    69     module.add_class('Ipv6AddressValue', parent=root_module['ns3::AttributeValue'])

    70     ## ipv6-header.h: ns3::Ipv6Header [class]

    71     module.add_class('Ipv6Header', parent=root_module['ns3::Header'])

    72     ## ipv6-header.h: ns3::Ipv6Header::NextHeader_e [enumeration]

    73     module.add_enum('NextHeader_e', ['IPV6_EXT_HOP_BY_HOP', 'IPV6_IPV4', 'IPV6_TCP', 'IPV6_UDP', 'IPV6_IPV6', 'IPV6_EXT_ROUTING', 'IPV6_EXT_FRAGMENTATION', 'IPV6_EXT_CONFIDENTIALITY', 'IPV6_EXT_AUTHENTIFICATION', 'IPV6_ICMPV6', 'IPV6_EXT_END', 'IPV6_EXT_DESTINATION', 'IPV6_SCTP', 'IPV6_EXT_MOBILITY', 'IPV6_UDP_LITE'], outer_class=root_module['ns3::Ipv6Header'])

    74     ## ipv6-address.h: ns3::Ipv6PrefixChecker [class]

    75     module.add_class('Ipv6PrefixChecker', parent=root_module['ns3::AttributeChecker'])

    76     ## ipv6-address.h: ns3::Ipv6PrefixValue [class]

    77     module.add_class('Ipv6PrefixValue', parent=root_module['ns3::AttributeValue'])

    78     ## llc-snap-header.h: ns3::LlcSnapHeader [class]

    79     module.add_class('LlcSnapHeader', parent=root_module['ns3::Header'])

    80     ## mac48-address.h: ns3::Mac48AddressChecker [class]

    81     module.add_class('Mac48AddressChecker', parent=root_module['ns3::AttributeChecker'])

    82     ## mac48-address.h: ns3::Mac48AddressValue [class]

    83     module.add_class('Mac48AddressValue', parent=root_module['ns3::AttributeValue'])

    84     ## queue.h: ns3::Queue [class]

    85     module.add_class('Queue', parent=root_module['ns3::Object'])

    86     ## socket.h: ns3::Socket [class]

    87     module.add_class('Socket', parent=root_module['ns3::Object'])

    88     ## socket.h: ns3::Socket::SocketErrno [enumeration]

    89     module.add_enum('SocketErrno', ['ERROR_NOTERROR', 'ERROR_ISCONN', 'ERROR_NOTCONN', 'ERROR_MSGSIZE', 'ERROR_AGAIN', 'ERROR_SHUTDOWN', 'ERROR_OPNOTSUPP', 'ERROR_AFNOSUPPORT', 'ERROR_INVAL', 'ERROR_BADF', 'ERROR_NOROUTETOHOST', 'SOCKET_ERRNO_LAST'], outer_class=root_module['ns3::Socket'])

    90     ## socket.h: ns3::SocketAddressTag [class]

    91     module.add_class('SocketAddressTag', parent=root_module['ns3::Tag'])

    92     ## socket-factory.h: ns3::SocketFactory [class]

    93     module.add_class('SocketFactory', parent=root_module['ns3::Object'])

    94     ## socket.h: ns3::SocketIpTtlTag [class]

    95     module.add_class('SocketIpTtlTag', parent=root_module['ns3::Tag'])

    96     ## socket.h: ns3::SocketSetDontFragmentTag [class]

    97     module.add_class('SocketSetDontFragmentTag', parent=root_module['ns3::Tag'])

    98     ## tcp-socket.h: ns3::TcpSocket [class]

    99     module.add_class('TcpSocket', parent=root_module['ns3::Socket'])

   100     ## tcp-socket-factory.h: ns3::TcpSocketFactory [class]

   101     module.add_class('TcpSocketFactory', parent=root_module['ns3::SocketFactory'])

   102     ## udp-socket.h: ns3::UdpSocket [class]

   103     module.add_class('UdpSocket', parent=root_module['ns3::Socket'])

   104     ## udp-socket-factory.h: ns3::UdpSocketFactory [class]

   105     module.add_class('UdpSocketFactory', parent=root_module['ns3::SocketFactory'])

   106     ## address.h: ns3::AddressChecker [class]

   107     module.add_class('AddressChecker', parent=root_module['ns3::AttributeChecker'])

   108     ## address.h: ns3::AddressValue [class]

   109     module.add_class('AddressValue', parent=root_module['ns3::AttributeValue'])

   110     ## application.h: ns3::Application [class]

   111     module.add_class('Application', parent=root_module['ns3::Object'])

   112     ## channel.h: ns3::Channel [class]

   113     module.add_class('Channel', parent=root_module['ns3::Object'])

   114     ## drop-tail-queue.h: ns3::DropTailQueue [class]

   115     module.add_class('DropTailQueue', parent=root_module['ns3::Queue'])

   116     ## drop-tail-queue.h: ns3::DropTailQueue::Mode [enumeration]

   117     module.add_enum('Mode', ['ILLEGAL', 'PACKETS', 'BYTES'], outer_class=root_module['ns3::DropTailQueue'])

   118     ## ethernet-header.h: ns3::EthernetHeader [class]

   119     module.add_class('EthernetHeader', parent=root_module['ns3::Header'])

   120     ## ethernet-trailer.h: ns3::EthernetTrailer [class]

   121     module.add_class('EthernetTrailer', parent=root_module['ns3::Trailer'])

   122     ## ipv4.h: ns3::Ipv4 [class]

   123     module.add_class('Ipv4', parent=root_module['ns3::Object'])

   124     ## ipv4-raw-socket-factory.h: ns3::Ipv4RawSocketFactory [class]

   125     module.add_class('Ipv4RawSocketFactory', parent=root_module['ns3::SocketFactory'])

   126     ## ipv4-routing-protocol.h: ns3::Ipv4RoutingProtocol [class]

   127     module.add_class('Ipv4RoutingProtocol', parent=root_module['ns3::Object'])

   128     ## net-device.h: ns3::NetDevice [class]

   129     module.add_class('NetDevice', parent=root_module['ns3::Object'])

   130     ## net-device.h: ns3::NetDevice::PacketType [enumeration]

   131     module.add_enum('PacketType', ['PACKET_HOST', 'NS3_PACKET_HOST', 'PACKET_BROADCAST', 'NS3_PACKET_BROADCAST', 'PACKET_MULTICAST', 'NS3_PACKET_MULTICAST', 'PACKET_OTHERHOST', 'NS3_PACKET_OTHERHOST'], outer_class=root_module['ns3::NetDevice'])

   132     ## node.h: ns3::Node [class]

   133     module.add_class('Node', parent=root_module['ns3::Object'])

   134     ## packet-socket-factory.h: ns3::PacketSocketFactory [class]

   135     module.add_class('PacketSocketFactory', parent=root_module['ns3::SocketFactory'])

   136     ## simple-channel.h: ns3::SimpleChannel [class]

   137     module.add_class('SimpleChannel', parent=root_module['ns3::Channel'])

   138     ## simple-net-device.h: ns3::SimpleNetDevice [class]

   139     module.add_class('SimpleNetDevice', parent=root_module['ns3::NetDevice'])

   140     module.add_container('ns3::olsr::MprSet', 'ns3::Ipv4Address', container_type='set')

   141     module.add_container('std::vector< ns3::Ipv4Address >', 'ns3::Ipv4Address', container_type='vector')

   143     ## Register a nested module for the namespace Config

   145     nested_module = module.add_cpp_namespace('Config')

   146     register_types_ns3_Config(nested_module)

   149     ## Register a nested module for the namespace TimeStepPrecision

   151     nested_module = module.add_cpp_namespace('TimeStepPrecision')

   152     register_types_ns3_TimeStepPrecision(nested_module)

   155     ## Register a nested module for the namespace addressUtils

   157     nested_module = module.add_cpp_namespace('addressUtils')

   158     register_types_ns3_addressUtils(nested_module)

   161     ## Register a nested module for the namespace internal

   163     nested_module = module.add_cpp_namespace('internal')

   164     register_types_ns3_internal(nested_module)

   167     ## Register a nested module for the namespace olsr

   169     nested_module = module.add_cpp_namespace('olsr')

   170     register_types_ns3_olsr(nested_module)

   173 def register_types_ns3_Config(module):

   174     root_module = module.get_root()

   177 def register_types_ns3_TimeStepPrecision(module):

   178     root_module = module.get_root()

   181 def register_types_ns3_addressUtils(module):

   182     root_module = module.get_root()

   185 def register_types_ns3_internal(module):

   186     root_module = module.get_root()

   189 def register_types_ns3_olsr(module):

   190     root_module = module.get_root()

   193 def register_methods(root_module):

   194     register_Ns3Address_methods(root_module, root_module['ns3::Address'])

   195     register_Ns3Inet6SocketAddress_methods(root_module, root_module['ns3::Inet6SocketAddress'])

   196     register_Ns3InetSocketAddress_methods(root_module, root_module['ns3::InetSocketAddress'])

   197     register_Ns3Ipv4Address_methods(root_module, root_module['ns3::Ipv4Address'])

   198     register_Ns3Ipv4AddressGenerator_methods(root_module, root_module['ns3::Ipv4AddressGenerator'])

   199     register_Ns3Ipv4InterfaceAddress_methods(root_module, root_module['ns3::Ipv4InterfaceAddress'])

   200     register_Ns3Ipv4Mask_methods(root_module, root_module['ns3::Ipv4Mask'])

   201     register_Ns3Ipv6Address_methods(root_module, root_module['ns3::Ipv6Address'])

   202     register_Ns3Ipv6Prefix_methods(root_module, root_module['ns3::Ipv6Prefix'])

   203     register_Ns3Mac48Address_methods(root_module, root_module['ns3::Mac48Address'])

   204     register_Ns3Mac64Address_methods(root_module, root_module['ns3::Mac64Address'])

   205     register_Ns3NodeList_methods(root_module, root_module['ns3::NodeList'])

   206     register_Ns3PacketSocketAddress_methods(root_module, root_module['ns3::PacketSocketAddress'])

   207     register_Ns3Ipv4AddressChecker_methods(root_module, root_module['ns3::Ipv4AddressChecker'])

   208     register_Ns3Ipv4AddressValue_methods(root_module, root_module['ns3::Ipv4AddressValue'])

   209     register_Ns3Ipv4Header_methods(root_module, root_module['ns3::Ipv4Header'])

   210     register_Ns3Ipv4MaskChecker_methods(root_module, root_module['ns3::Ipv4MaskChecker'])

   211     register_Ns3Ipv4MaskValue_methods(root_module, root_module['ns3::Ipv4MaskValue'])

   212     register_Ns3Ipv4MulticastRoute_methods(root_module, root_module['ns3::Ipv4MulticastRoute'])

   213     register_Ns3Ipv4Route_methods(root_module, root_module['ns3::Ipv4Route'])

   214     register_Ns3Ipv6AddressChecker_methods(root_module, root_module['ns3::Ipv6AddressChecker'])

   215     register_Ns3Ipv6AddressValue_methods(root_module, root_module['ns3::Ipv6AddressValue'])

   216     register_Ns3Ipv6Header_methods(root_module, root_module['ns3::Ipv6Header'])

   217     register_Ns3Ipv6PrefixChecker_methods(root_module, root_module['ns3::Ipv6PrefixChecker'])

   218     register_Ns3Ipv6PrefixValue_methods(root_module, root_module['ns3::Ipv6PrefixValue'])

   219     register_Ns3LlcSnapHeader_methods(root_module, root_module['ns3::LlcSnapHeader'])

   220     register_Ns3Mac48AddressChecker_methods(root_module, root_module['ns3::Mac48AddressChecker'])

   221     register_Ns3Mac48AddressValue_methods(root_module, root_module['ns3::Mac48AddressValue'])

   222     register_Ns3Queue_methods(root_module, root_module['ns3::Queue'])

   223     register_Ns3Socket_methods(root_module, root_module['ns3::Socket'])

   224     register_Ns3SocketAddressTag_methods(root_module, root_module['ns3::SocketAddressTag'])

   225     register_Ns3SocketFactory_methods(root_module, root_module['ns3::SocketFactory'])

   226     register_Ns3SocketIpTtlTag_methods(root_module, root_module['ns3::SocketIpTtlTag'])

   227     register_Ns3SocketSetDontFragmentTag_methods(root_module, root_module['ns3::SocketSetDontFragmentTag'])

   228     register_Ns3TcpSocket_methods(root_module, root_module['ns3::TcpSocket'])

   229     register_Ns3TcpSocketFactory_methods(root_module, root_module['ns3::TcpSocketFactory'])

   230     register_Ns3UdpSocket_methods(root_module, root_module['ns3::UdpSocket'])

   231     register_Ns3UdpSocketFactory_methods(root_module, root_module['ns3::UdpSocketFactory'])

   232     register_Ns3AddressChecker_methods(root_module, root_module['ns3::AddressChecker'])

   233     register_Ns3AddressValue_methods(root_module, root_module['ns3::AddressValue'])

   234     register_Ns3Application_methods(root_module, root_module['ns3::Application'])

   235     register_Ns3Channel_methods(root_module, root_module['ns3::Channel'])

   236     register_Ns3DropTailQueue_methods(root_module, root_module['ns3::DropTailQueue'])

   237     register_Ns3EthernetHeader_methods(root_module, root_module['ns3::EthernetHeader'])

   238     register_Ns3EthernetTrailer_methods(root_module, root_module['ns3::EthernetTrailer'])

   239     register_Ns3Ipv4_methods(root_module, root_module['ns3::Ipv4'])

   240     register_Ns3Ipv4RawSocketFactory_methods(root_module, root_module['ns3::Ipv4RawSocketFactory'])

   241     register_Ns3Ipv4RoutingProtocol_methods(root_module, root_module['ns3::Ipv4RoutingProtocol'])

   242     register_Ns3NetDevice_methods(root_module, root_module['ns3::NetDevice'])

   243     register_Ns3Node_methods(root_module, root_module['ns3::Node'])

   244     register_Ns3PacketSocketFactory_methods(root_module, root_module['ns3::PacketSocketFactory'])

   245     register_Ns3SimpleChannel_methods(root_module, root_module['ns3::SimpleChannel'])

   246     register_Ns3SimpleNetDevice_methods(root_module, root_module['ns3::SimpleNetDevice'])

   247     return

   249 def register_Ns3Address_methods(root_module, cls):

   250     cls.add_binary_comparison_operator('!=')

   251     cls.add_binary_comparison_operator('<')

   252     cls.add_output_stream_operator()

   253     cls.add_binary_comparison_operator('==')

   254     ## address.h: ns3::Address::Address() [constructor]

   255     cls.add_constructor([])

   256     ## address.h: ns3::Address::Address(uint8_t type, uint8_t const * buffer, uint8_t len) [constructor]

   257     cls.add_constructor([param('uint8_t', 'type'), param('uint8_t const *', 'buffer'), param('uint8_t', 'len')])

   258     ## address.h: ns3::Address::Address(ns3::Address const & address) [copy constructor]

   259     cls.add_constructor([param('ns3::Address const &', 'address')])

   260     ## address.h: bool ns3::Address::CheckCompatible(uint8_t type, uint8_t len) const [member function]

   261     cls.add_method('CheckCompatible',

   262                    'bool',

   263                    [param('uint8_t', 'type'), param('uint8_t', 'len')],

   264                    is_const=True)

   265     ## address.h: uint32_t ns3::Address::CopyAllFrom(uint8_t const * buffer, uint8_t len) [member function]

   266     cls.add_method('CopyAllFrom',

   267                    'uint32_t',

   268                    [param('uint8_t const *', 'buffer'), param('uint8_t', 'len')])

   269     ## address.h: uint32_t ns3::Address::CopyAllTo(uint8_t * buffer, uint8_t len) const [member function]

   270     cls.add_method('CopyAllTo',

   271                    'uint32_t',

   272                    [param('uint8_t *', 'buffer'), param('uint8_t', 'len')],

   273                    is_const=True)

   274     ## address.h: uint32_t ns3::Address::CopyFrom(uint8_t const * buffer, uint8_t len) [member function]

   275     cls.add_method('CopyFrom',

   276                    'uint32_t',

   277                    [param('uint8_t const *', 'buffer'), param('uint8_t', 'len')])

   278     ## address.h: uint32_t ns3::Address::CopyTo(uint8_t * buffer) const [member function]

   279     cls.add_method('CopyTo',

   280                    'uint32_t',

   281                    [param('uint8_t *', 'buffer')],

   282                    is_const=True)

   283     ## address.h: void ns3::Address::Deserialize(ns3::TagBuffer buffer) [member function]

   284     cls.add_method('Deserialize',

   285                    'void',

   286                    [param('ns3::TagBuffer', 'buffer')])

   287     ## address.h: uint8_t ns3::Address::GetLength() const [member function]

   288     cls.add_method('GetLength',

   289                    'uint8_t',

   290                    [],

   291                    is_const=True)

   292     ## address.h: uint32_t ns3::Address::GetSerializedSize() const [member function]

   293     cls.add_method('GetSerializedSize',

   294                    'uint32_t',

   295                    [],

   296                    is_const=True)

   297     ## address.h: bool ns3::Address::IsInvalid() const [member function]

   298     cls.add_method('IsInvalid',

   299                    'bool',

   300                    [],

   301                    is_const=True)

   302     ## address.h: bool ns3::Address::IsMatchingType(uint8_t type) const [member function]

   303     cls.add_method('IsMatchingType',

   304                    'bool',

   305                    [param('uint8_t', 'type')],

   306                    is_const=True)

   307     ## address.h: static uint8_t ns3::Address::Register() [member function]

   308     cls.add_method('Register',

   309                    'uint8_t',

   310                    [],

   311                    is_static=True)

   312     ## address.h: void ns3::Address::Serialize(ns3::TagBuffer buffer) const [member function]

   313     cls.add_method('Serialize',

   314                    'void',

   315                    [param('ns3::TagBuffer', 'buffer')],

   316                    is_const=True)

   317     return

   319 def register_Ns3Inet6SocketAddress_methods(root_module, cls):

   320     ## inet6-socket-address.h: ns3::Inet6SocketAddress::Inet6SocketAddress(ns3::Inet6SocketAddress const & arg0) [copy constructor]

   321     cls.add_constructor([param('ns3::Inet6SocketAddress const &', 'arg0')])

   322     ## inet6-socket-address.h: ns3::Inet6SocketAddress::Inet6SocketAddress(ns3::Ipv6Address ipv6, uint16_t port) [constructor]

   323     cls.add_constructor([param('ns3::Ipv6Address', 'ipv6'), param('uint16_t', 'port')])

   324     ## inet6-socket-address.h: ns3::Inet6SocketAddress::Inet6SocketAddress(ns3::Ipv6Address ipv6) [constructor]

   325     cls.add_constructor([param('ns3::Ipv6Address', 'ipv6')])

   326     ## inet6-socket-address.h: ns3::Inet6SocketAddress::Inet6SocketAddress(uint16_t port) [constructor]

   327     cls.add_constructor([param('uint16_t', 'port')])

   328     ## inet6-socket-address.h: ns3::Inet6SocketAddress::Inet6SocketAddress(char const * ipv6, uint16_t port) [constructor]

   329     cls.add_constructor([param('char const *', 'ipv6'), param('uint16_t', 'port')])

   330     ## inet6-socket-address.h: ns3::Inet6SocketAddress::Inet6SocketAddress(char const * ipv6) [constructor]

   331     cls.add_constructor([param('char const *', 'ipv6')])

   332     ## inet6-socket-address.h: uint16_t ns3::Inet6SocketAddress::GetPort() const [member function]

   333     cls.add_method('GetPort',

   334                    'uint16_t',

   335                    [],

   336                    is_const=True)

   337     ## inet6-socket-address.h: void ns3::Inet6SocketAddress::SetPort(uint16_t port) [member function]

   338     cls.add_method('SetPort',

   339                    'void',

   340                    [param('uint16_t', 'port')])

   341     ## inet6-socket-address.h: ns3::Ipv6Address ns3::Inet6SocketAddress::GetIpv6() const [member function]

   342     cls.add_method('GetIpv6',

   343                    'ns3::Ipv6Address',

   344                    [],

   345                    is_const=True)

   346     ## inet6-socket-address.h: void ns3::Inet6SocketAddress::SetIpv6(ns3::Ipv6Address ipv6) [member function]

   347     cls.add_method('SetIpv6',

   348                    'void',

   349                    [param('ns3::Ipv6Address', 'ipv6')])

   350     ## inet6-socket-address.h: static bool ns3::Inet6SocketAddress::IsMatchingType(ns3::Address const & addr) [member function]

   351     cls.add_method('IsMatchingType',

   352                    'bool',

   353                    [param('ns3::Address const &', 'addr')],

   354                    is_static=True)

   355     ## inet6-socket-address.h: static ns3::Inet6SocketAddress ns3::Inet6SocketAddress::ConvertFrom(ns3::Address const & addr) [member function]

   356     cls.add_method('ConvertFrom',

   357                    'ns3::Inet6SocketAddress',

   358                    [param('ns3::Address const &', 'addr')],

   359                    is_static=True)

   360     return

   362 def register_Ns3InetSocketAddress_methods(root_module, cls):

   363     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(ns3::InetSocketAddress const & arg0) [copy constructor]

   364     cls.add_constructor([param('ns3::InetSocketAddress const &', 'arg0')])

   365     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(ns3::Ipv4Address ipv4, uint16_t port) [constructor]

   366     cls.add_constructor([param('ns3::Ipv4Address', 'ipv4'), param('uint16_t', 'port')])

   367     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(ns3::Ipv4Address ipv4) [constructor]

   368     cls.add_constructor([param('ns3::Ipv4Address', 'ipv4')])

   369     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(uint16_t port) [constructor]

   370     cls.add_constructor([param('uint16_t', 'port')])

   371     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(char const * ipv4, uint16_t port) [constructor]

   372     cls.add_constructor([param('char const *', 'ipv4'), param('uint16_t', 'port')])

   373     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(char const * ipv4) [constructor]

   374     cls.add_constructor([param('char const *', 'ipv4')])

   375     ## inet-socket-address.h: uint16_t ns3::InetSocketAddress::GetPort() const [member function]

   376     cls.add_method('GetPort',

   377                    'uint16_t',

   378                    [],

   379                    is_const=True)

   380     ## inet-socket-address.h: ns3::Ipv4Address ns3::InetSocketAddress::GetIpv4() const [member function]

   381     cls.add_method('GetIpv4',

   382                    'ns3::Ipv4Address',

   383                    [],

   384                    is_const=True)

   385     ## inet-socket-address.h: void ns3::InetSocketAddress::SetPort(uint16_t port) [member function]

   386     cls.add_method('SetPort',

   387                    'void',

   388                    [param('uint16_t', 'port')])

   389     ## inet-socket-address.h: void ns3::InetSocketAddress::SetIpv4(ns3::Ipv4Address address) [member function]

   390     cls.add_method('SetIpv4',

   391                    'void',

   392                    [param('ns3::Ipv4Address', 'address')])

   393     ## inet-socket-address.h: static bool ns3::InetSocketAddress::IsMatchingType(ns3::Address const & address) [member function]

   394     cls.add_method('IsMatchingType',

   395                    'bool',

   396                    [param('ns3::Address const &', 'address')],

   397                    is_static=True)

   398     ## inet-socket-address.h: static ns3::InetSocketAddress ns3::InetSocketAddress::ConvertFrom(ns3::Address const & address) [member function]

   399     cls.add_method('ConvertFrom',

   400                    'ns3::InetSocketAddress',

   401                    [param('ns3::Address const &', 'address')],

   402                    is_static=True)

   403     return

   405 def register_Ns3Ipv4Address_methods(root_module, cls):

   406     cls.add_binary_comparison_operator('!=')

   407     cls.add_binary_comparison_operator('<')

   408     cls.add_output_stream_operator()

   409     cls.add_binary_comparison_operator('==')

   410     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [copy constructor]

   411     cls.add_constructor([param('ns3::Ipv4Address const &', 'arg0')])

   412     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address() [constructor]

   413     cls.add_constructor([])

   414     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(uint32_t address) [constructor]

   415     cls.add_constructor([param('uint32_t', 'address')])

   416     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(char const * address) [constructor]

   417     cls.add_constructor([param('char const *', 'address')])

   418     ## ipv4-address.h: ns3::Ipv4Address ns3::Ipv4Address::CombineMask(ns3::Ipv4Mask const & mask) const [member function]

   419     cls.add_method('CombineMask',

   420                    'ns3::Ipv4Address',

   421                    [param('ns3::Ipv4Mask const &', 'mask')],

   422                    is_const=True)

   423     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::ConvertFrom(ns3::Address const & address) [member function]

   424     cls.add_method('ConvertFrom',

   425                    'ns3::Ipv4Address',

   426                    [param('ns3::Address const &', 'address')],

   427                    is_static=True)

   428     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::Deserialize(uint8_t const * buf) [member function]

   429     cls.add_method('Deserialize',

   430                    'ns3::Ipv4Address',

   431                    [param('uint8_t const *', 'buf')],

   432                    is_static=True)

   433     ## ipv4-address.h: uint32_t ns3::Ipv4Address::Get() const [member function]

   434     cls.add_method('Get',

   435                    'uint32_t',

   436                    [],

   437                    is_const=True)

   438     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetAny() [member function]

   439     cls.add_method('GetAny',

   440                    'ns3::Ipv4Address',

   441                    [],

   442                    is_static=True)

   443     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetBroadcast() [member function]

   444     cls.add_method('GetBroadcast',

   445                    'ns3::Ipv4Address',

   446                    [],

   447                    is_static=True)

   448     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetLoopback() [member function]

   449     cls.add_method('GetLoopback',

   450                    'ns3::Ipv4Address',

   451                    [],

   452                    is_static=True)

   453     ## ipv4-address.h: ns3::Ipv4Address ns3::Ipv4Address::GetSubnetDirectedBroadcast(ns3::Ipv4Mask const & mask) const [member function]

   454     cls.add_method('GetSubnetDirectedBroadcast',

   455                    'ns3::Ipv4Address',

   456                    [param('ns3::Ipv4Mask const &', 'mask')],

   457                    is_const=True)

   458     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetZero() [member function]

   459     cls.add_method('GetZero',

   460                    'ns3::Ipv4Address',

   461                    [],

   462                    is_static=True)

   463     ## ipv4-address.h: bool ns3::Ipv4Address::IsBroadcast() const [member function]

   464     cls.add_method('IsBroadcast',

   465                    'bool',

   466                    [],

   467                    is_const=True)

   468     ## ipv4-address.h: bool ns3::Ipv4Address::IsEqual(ns3::Ipv4Address const & other) const [member function]

   469     cls.add_method('IsEqual',

   470                    'bool',

   471                    [param('ns3::Ipv4Address const &', 'other')],

   472                    is_const=True)

   473     ## ipv4-address.h: static bool ns3::Ipv4Address::IsMatchingType(ns3::Address const & address) [member function]

   474     cls.add_method('IsMatchingType',

   475                    'bool',

   476                    [param('ns3::Address const &', 'address')],

   477                    is_static=True)

   478     ## ipv4-address.h: bool ns3::Ipv4Address::IsMulticast() const [member function]

   479     cls.add_method('IsMulticast',

   480                    'bool',

   481                    [],

   482                    is_const=True)

   483     ## ipv4-address.h: bool ns3::Ipv4Address::IsSubnetDirectedBroadcast(ns3::Ipv4Mask const & mask) const [member function]

   484     cls.add_method('IsSubnetDirectedBroadcast',

   485                    'bool',

   486                    [param('ns3::Ipv4Mask const &', 'mask')],

   487                    is_const=True)

   488     ## ipv4-address.h: void ns3::Ipv4Address::Print(std::ostream & os) const [member function]

   489     cls.add_method('Print',

   490                    'void',

   491                    [param('std::ostream &', 'os')],

   492                    is_const=True)

   493     ## ipv4-address.h: void ns3::Ipv4Address::Serialize(uint8_t * buf) const [member function]

   494     cls.add_method('Serialize',

   495                    'void',

   496                    [param('uint8_t *', 'buf')],

   497                    is_const=True)

   498     ## ipv4-address.h: void ns3::Ipv4Address::Set(uint32_t address) [member function]

   499     cls.add_method('Set',

   500                    'void',

   501                    [param('uint32_t', 'address')])

   502     ## ipv4-address.h: void ns3::Ipv4Address::Set(char const * address) [member function]

   503     cls.add_method('Set',

   504                    'void',

   505                    [param('char const *', 'address')])

   506     return

   508 def register_Ns3Ipv4AddressGenerator_methods(root_module, cls):

   509     ## ipv4-address-generator.h: ns3::Ipv4AddressGenerator::Ipv4AddressGenerator(ns3::Ipv4AddressGenerator const & arg0) [copy constructor]

   510     cls.add_constructor([param('ns3::Ipv4AddressGenerator const &', 'arg0')])

   511     ## ipv4-address-generator.h: ns3::Ipv4AddressGenerator::Ipv4AddressGenerator() [constructor]

   512     cls.add_constructor([])

   513     ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::Init(ns3::Ipv4Address const net, ns3::Ipv4Mask const mask, ns3::Ipv4Address const addr="0.0.0.1") [member function]

   514     cls.add_method('Init',

   515                    'void',

   516                    [param('ns3::Ipv4Address const', 'net'), param('ns3::Ipv4Mask const', 'mask'), param('ns3::Ipv4Address const', 'addr', default_value='"0.0.0.1"')],

   517                    is_static=True)

   518     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::NextNetwork(ns3::Ipv4Mask const mask) [member function]

   519     cls.add_method('NextNetwork',

   520                    'ns3::Ipv4Address',

   521                    [param('ns3::Ipv4Mask const', 'mask')],

   522                    is_static=True)

   523     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::GetNetwork(ns3::Ipv4Mask const mask) [member function]

   524     cls.add_method('GetNetwork',

   525                    'ns3::Ipv4Address',

   526                    [param('ns3::Ipv4Mask const', 'mask')],

   527                    is_static=True)

   528     ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::InitAddress(ns3::Ipv4Address const addr, ns3::Ipv4Mask const mask) [member function]

   529     cls.add_method('InitAddress',

   530                    'void',

   531                    [param('ns3::Ipv4Address const', 'addr'), param('ns3::Ipv4Mask const', 'mask')],

   532                    is_static=True)

   533     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::NextAddress(ns3::Ipv4Mask const mask) [member function]

   534     cls.add_method('NextAddress',

   535                    'ns3::Ipv4Address',

   536                    [param('ns3::Ipv4Mask const', 'mask')],

   537                    is_static=True)

   538     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::GetAddress(ns3::Ipv4Mask const mask) [member function]

   539     cls.add_method('GetAddress',

   540                    'ns3::Ipv4Address',

   541                    [param('ns3::Ipv4Mask const', 'mask')],

   542                    is_static=True)

   543     ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::Reset() [member function]

   544     cls.add_method('Reset',

   545                    'void',

   546                    [],

   547                    is_static=True)

   548     ## ipv4-address-generator.h: static bool ns3::Ipv4AddressGenerator::AddAllocated(ns3::Ipv4Address const addr) [member function]

   549     cls.add_method('AddAllocated',

   550                    'bool',

   551                    [param('ns3::Ipv4Address const', 'addr')],

   552                    is_static=True)

   553     ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::TestMode() [member function]

   554     cls.add_method('TestMode',

   555                    'void',

   556                    [],

   557                    is_static=True)

   558     return

   560 def register_Ns3Ipv4InterfaceAddress_methods(root_module, cls):

   561     cls.add_binary_comparison_operator('!=')

   562     cls.add_output_stream_operator()

   563     cls.add_binary_comparison_operator('==')

   564     ## ipv4-interface-address.h: ns3::Ipv4InterfaceAddress::Ipv4InterfaceAddress() [constructor]

   565     cls.add_constructor([])

   566     ## ipv4-interface-address.h: ns3::Ipv4InterfaceAddress::Ipv4InterfaceAddress(ns3::Ipv4Address local, ns3::Ipv4Mask mask) [constructor]

   567     cls.add_constructor([param('ns3::Ipv4Address', 'local'), param('ns3::Ipv4Mask', 'mask')])

   568     ## ipv4-interface-address.h: ns3::Ipv4InterfaceAddress::Ipv4InterfaceAddress(ns3::Ipv4InterfaceAddress const & o) [copy constructor]

   569     cls.add_constructor([param('ns3::Ipv4InterfaceAddress const &', 'o')])

   570     ## ipv4-interface-address.h: ns3::Ipv4Address ns3::Ipv4InterfaceAddress::GetBroadcast() const [member function]

   571     cls.add_method('GetBroadcast',

   572                    'ns3::Ipv4Address',

   573                    [],

   574                    is_const=True)

   575     ## ipv4-interface-address.h: ns3::Ipv4Address ns3::Ipv4InterfaceAddress::GetLocal() const [member function]

   576     cls.add_method('GetLocal',

   577                    'ns3::Ipv4Address',

   578                    [],

   579                    is_const=True)

   580     ## ipv4-interface-address.h: ns3::Ipv4Mask ns3::Ipv4InterfaceAddress::GetMask() const [member function]

   581     cls.add_method('GetMask',

   582                    'ns3::Ipv4Mask',

   583                    [],

   584                    is_const=True)

   585     ## ipv4-interface-address.h: ns3::Ipv4InterfaceAddress::InterfaceAddressScope_e ns3::Ipv4InterfaceAddress::GetScope() const [member function]

   586     cls.add_method('GetScope',

   587                    'ns3::Ipv4InterfaceAddress::InterfaceAddressScope_e',

   588                    [],

   589                    is_const=True)

   590     ## ipv4-interface-address.h: bool ns3::Ipv4InterfaceAddress::IsSecondary() const [member function]

   591     cls.add_method('IsSecondary',

   592                    'bool',

   593                    [],

   594                    is_const=True)

   595     ## ipv4-interface-address.h: void ns3::Ipv4InterfaceAddress::SetBroadcast(ns3::Ipv4Address broadcast) [member function]

   596     cls.add_method('SetBroadcast',

   597                    'void',

   598                    [param('ns3::Ipv4Address', 'broadcast')])

   599     ## ipv4-interface-address.h: void ns3::Ipv4InterfaceAddress::SetLocal(ns3::Ipv4Address local) [member function]

   600     cls.add_method('SetLocal',

   601                    'void',

   602                    [param('ns3::Ipv4Address', 'local')])

   603     ## ipv4-interface-address.h: void ns3::Ipv4InterfaceAddress::SetMask(ns3::Ipv4Mask mask) [member function]

   604     cls.add_method('SetMask',

   605                    'void',

   606                    [param('ns3::Ipv4Mask', 'mask')])

   607     ## ipv4-interface-address.h: void ns3::Ipv4InterfaceAddress::SetPrimary() [member function]

   608     cls.add_method('SetPrimary',

   609                    'void',

   610                    [])

   611     ## ipv4-interface-address.h: void ns3::Ipv4InterfaceAddress::SetScope(ns3::Ipv4InterfaceAddress::InterfaceAddressScope_e scope) [member function]

   612     cls.add_method('SetScope',

   613                    'void',

   614                    [param('ns3::Ipv4InterfaceAddress::InterfaceAddressScope_e', 'scope')])

   615     ## ipv4-interface-address.h: void ns3::Ipv4InterfaceAddress::SetSecondary() [member function]

   616     cls.add_method('SetSecondary',

   617                    'void',

   618                    [])

   619     return

   621 def register_Ns3Ipv4Mask_methods(root_module, cls):

   622     cls.add_binary_comparison_operator('!=')

   623     cls.add_output_stream_operator()

   624     cls.add_binary_comparison_operator('==')

   625     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [copy constructor]

   626     cls.add_constructor([param('ns3::Ipv4Mask const &', 'arg0')])

   627     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask() [constructor]

   628     cls.add_constructor([])

   629     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(uint32_t mask) [constructor]

   630     cls.add_constructor([param('uint32_t', 'mask')])

   631     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(char const * mask) [constructor]

   632     cls.add_constructor([param('char const *', 'mask')])

   633     ## ipv4-address.h: uint32_t ns3::Ipv4Mask::Get() const [member function]

   634     cls.add_method('Get',

   635                    'uint32_t',

   636                    [],

   637                    is_const=True)

   638     ## ipv4-address.h: uint32_t ns3::Ipv4Mask::GetInverse() const [member function]

   639     cls.add_method('GetInverse',

   640                    'uint32_t',

   641                    [],

   642                    is_const=True)

   643     ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetLoopback() [member function]

   644     cls.add_method('GetLoopback',

   645                    'ns3::Ipv4Mask',

   646                    [],

   647                    is_static=True)

   648     ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetOnes() [member function]

   649     cls.add_method('GetOnes',

   650                    'ns3::Ipv4Mask',

   651                    [],

   652                    is_static=True)

   653     ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetZero() [member function]

   654     cls.add_method('GetZero',

   655                    'ns3::Ipv4Mask',

   656                    [],

   657                    is_static=True)

   658     ## ipv4-address.h: bool ns3::Ipv4Mask::IsEqual(ns3::Ipv4Mask other) const [member function]

   659     cls.add_method('IsEqual',

   660                    'bool',

   661                    [param('ns3::Ipv4Mask', 'other')],

   662                    is_const=True)

   663     ## ipv4-address.h: bool ns3::Ipv4Mask::IsMatch(ns3::Ipv4Address a, ns3::Ipv4Address b) const [member function]

   664     cls.add_method('IsMatch',

   665                    'bool',

   666                    [param('ns3::Ipv4Address', 'a'), param('ns3::Ipv4Address', 'b')],

   667                    is_const=True)

   668     ## ipv4-address.h: void ns3::Ipv4Mask::Print(std::ostream & os) const [member function]

   669     cls.add_method('Print',

   670                    'void',

   671                    [param('std::ostream &', 'os')],

   672                    is_const=True)

   673     ## ipv4-address.h: void ns3::Ipv4Mask::Set(uint32_t mask) [member function]

   674     cls.add_method('Set',

   675                    'void',

   676                    [param('uint32_t', 'mask')])

   677     return

   679 def register_Ns3Ipv6Address_methods(root_module, cls):

   680     cls.add_binary_comparison_operator('!=')

   681     cls.add_binary_comparison_operator('<')

   682     cls.add_output_stream_operator()

   683     cls.add_binary_comparison_operator('==')

   684     ## ipv6-address.h: ns3::Ipv6Address::Ipv6Address() [constructor]

   685     cls.add_constructor([])

   686     ## ipv6-address.h: ns3::Ipv6Address::Ipv6Address(char const * address) [constructor]

   687     cls.add_constructor([param('char const *', 'address')])

   688     ## ipv6-address.h: ns3::Ipv6Address::Ipv6Address(uint8_t * address) [constructor]

   689     cls.add_constructor([param('uint8_t *', 'address')])

   690     ## ipv6-address.h: ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const & addr) [copy constructor]

   691     cls.add_constructor([param('ns3::Ipv6Address const &', 'addr')])

   692     ## ipv6-address.h: ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const * addr) [constructor]

   693     cls.add_constructor([param('ns3::Ipv6Address const *', 'addr')])

   694     ## ipv6-address.h: ns3::Ipv6Address ns3::Ipv6Address::CombinePrefix(ns3::Ipv6Prefix const & prefix) [member function]

   695     cls.add_method('CombinePrefix',

   696                    'ns3::Ipv6Address',

   697                    [param('ns3::Ipv6Prefix const &', 'prefix')])

   698     ## ipv6-address.h: static ns3::Ipv6Address ns3::Ipv6Address::ConvertFrom(ns3::Address const & address) [member function]

   699     cls.add_method('ConvertFrom',

   700                    'ns3::Ipv6Address',

   701                    [param('ns3::Address const &', 'address')],

   702                    is_static=True)

   703     ## ipv6-address.h: static ns3::Ipv6Address ns3::Ipv6Address::Deserialize(uint8_t const * buf) [member function]

   704     cls.add_method('Deserialize',

   705                    'ns3::Ipv6Address',

   706                    [param('uint8_t const *', 'buf')],

   707                    is_static=True)

   708     ## ipv6-address.h: static ns3::Ipv6Address ns3::Ipv6Address::GetAllHostsMulticast() [member function]

   709     cls.add_method('GetAllHostsMulticast',

   710                    'ns3::Ipv6Address',

   711                    [],

   712                    is_static=True)

   713     ## ipv6-address.h: static ns3::Ipv6Address ns3::Ipv6Address::GetAllNodesMulticast() [member function]

   714     cls.add_method('GetAllNodesMulticast',

   715                    'ns3::Ipv6Address',

   716                    [],

   717                    is_static=True)

   718     ## ipv6-address.h: static ns3::Ipv6Address ns3::Ipv6Address::GetAllRoutersMulticast() [member function]

   719     cls.add_method('GetAllRoutersMulticast',

   720                    'ns3::Ipv6Address',

   721                    [],

   722                    is_static=True)

   723     ## ipv6-address.h: static ns3::Ipv6Address ns3::Ipv6Address::GetAny() [member function]

   724     cls.add_method('GetAny',

   725                    'ns3::Ipv6Address',

   726                    [],

   727                    is_static=True)

   728     ## ipv6-address.h: void ns3::Ipv6Address::GetBytes(uint8_t * buf) const [member function]

   729     cls.add_method('GetBytes',

   730                    'void',

   731                    [param('uint8_t *', 'buf')],

   732                    is_const=True)

   733     ## ipv6-address.h: static ns3::Ipv6Address ns3::Ipv6Address::GetLoopback() [member function]

   734     cls.add_method('GetLoopback',

   735                    'ns3::Ipv6Address',

   736                    [],

   737                    is_static=True)

   738     ## ipv6-address.h: static ns3::Ipv6Address ns3::Ipv6Address::GetZero() [member function]

   739     cls.add_method('GetZero',

   740                    'ns3::Ipv6Address',

   741                    [],

   742                    is_static=True)

   743     ## ipv6-address.h: bool ns3::Ipv6Address::IsAllHostsMulticast() const [member function]

   744     cls.add_method('IsAllHostsMulticast',

   745                    'bool',

   746                    [],

   747                    is_const=True)

   748     ## ipv6-address.h: bool ns3::Ipv6Address::IsAllNodesMulticast() const [member function]

   749     cls.add_method('IsAllNodesMulticast',

   750                    'bool',

   751                    [],

   752                    is_const=True)

   753     ## ipv6-address.h: bool ns3::Ipv6Address::IsAllRoutersMulticast() const [member function]

   754     cls.add_method('IsAllRoutersMulticast',

   755                    'bool',

   756                    [],

   757                    is_const=True)

   758     ## ipv6-address.h: bool ns3::Ipv6Address::IsAny() const [member function]

   759     cls.add_method('IsAny',

   760                    'bool',

   761                    [],

   762                    is_const=True)

   763     ## ipv6-address.h: bool ns3::Ipv6Address::IsEqual(ns3::Ipv6Address const & other) const [member function]

   764     cls.add_method('IsEqual',

   765                    'bool',

   766                    [param('ns3::Ipv6Address const &', 'other')],

   767                    is_const=True)

   768     ## ipv6-address.h: bool ns3::Ipv6Address::IsLinkLocal() const [member function]

   769     cls.add_method('IsLinkLocal',

   770                    'bool',

   771                    [],

   772                    is_const=True)

   773     ## ipv6-address.h: bool ns3::Ipv6Address::IsLocalhost() const [member function]

   774     cls.add_method('IsLocalhost',

   775                    'bool',

   776                    [],

   777                    is_const=True)

   778     ## ipv6-address.h: static bool ns3::Ipv6Address::IsMatchingType(ns3::Address const & address) [member function]

   779     cls.add_method('IsMatchingType',

   780                    'bool',

   781                    [param('ns3::Address const &', 'address')],

   782                    is_static=True)

   783     ## ipv6-address.h: bool ns3::Ipv6Address::IsMulticast() const [member function]

   784     cls.add_method('IsMulticast',

   785                    'bool',

   786                    [],

   787                    is_const=True)

   788     ## ipv6-address.h: bool ns3::Ipv6Address::IsSolicitedMulticast() const [member function]

   789     cls.add_method('IsSolicitedMulticast',

   790                    'bool',

   791                    [],

   792                    is_const=True)

   793     ## ipv6-address.h: static ns3::Ipv6Address ns3::Ipv6Address::MakeAutoconfiguredAddress(ns3::Mac48Address addr, ns3::Ipv6Address prefix) [member function]

   794     cls.add_method('MakeAutoconfiguredAddress',

   795                    'ns3::Ipv6Address',

   796                    [param('ns3::Mac48Address', 'addr'), param('ns3::Ipv6Address', 'prefix')],

   797                    is_static=True)

   798     ## ipv6-address.h: static ns3::Ipv6Address ns3::Ipv6Address::MakeAutoconfiguredLinkLocalAddress(ns3::Mac48Address mac) [member function]

   799     cls.add_method('MakeAutoconfiguredLinkLocalAddress',

   800                    'ns3::Ipv6Address',

   801                    [param('ns3::Mac48Address', 'mac')],

   802                    is_static=True)

   803     ## ipv6-address.h: static ns3::Ipv6Address ns3::Ipv6Address::MakeSolicitedAddress(ns3::Ipv6Address addr) [member function]

   804     cls.add_method('MakeSolicitedAddress',

   805                    'ns3::Ipv6Address',

   806                    [param('ns3::Ipv6Address', 'addr')],

   807                    is_static=True)

   808     ## ipv6-address.h: void ns3::Ipv6Address::Print(std::ostream & os) const [member function]

   809     cls.add_method('Print',

   810                    'void',

   811                    [param('std::ostream &', 'os')],

   812                    is_const=True)

   813     ## ipv6-address.h: void ns3::Ipv6Address::Serialize(uint8_t * buf) const [member function]

   814     cls.add_method('Serialize',

   815                    'void',

   816                    [param('uint8_t *', 'buf')],

   817                    is_const=True)

   818     ## ipv6-address.h: void ns3::Ipv6Address::Set(char const * address) [member function]

   819     cls.add_method('Set',

   820                    'void',

   821                    [param('char const *', 'address')])

   822     ## ipv6-address.h: void ns3::Ipv6Address::Set(uint8_t * address) [member function]

   823     cls.add_method('Set',

   824                    'void',

   825                    [param('uint8_t *', 'address')])

   826     return

   828 def register_Ns3Ipv6Prefix_methods(root_module, cls):

   829     cls.add_binary_comparison_operator('!=')

   830     cls.add_output_stream_operator()

   831     cls.add_binary_comparison_operator('==')

   832     ## ipv6-address.h: ns3::Ipv6Prefix::Ipv6Prefix() [constructor]

   833     cls.add_constructor([])

   834     ## ipv6-address.h: ns3::Ipv6Prefix::Ipv6Prefix(uint8_t * prefix) [constructor]

   835     cls.add_constructor([param('uint8_t *', 'prefix')])

   836     ## ipv6-address.h: ns3::Ipv6Prefix::Ipv6Prefix(char const * prefix) [constructor]

   837     cls.add_constructor([param('char const *', 'prefix')])

   838     ## ipv6-address.h: ns3::Ipv6Prefix::Ipv6Prefix(uint8_t prefix) [constructor]

   839     cls.add_constructor([param('uint8_t', 'prefix')])

   840     ## ipv6-address.h: ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const & prefix) [copy constructor]

   841     cls.add_constructor([param('ns3::Ipv6Prefix const &', 'prefix')])

   842     ## ipv6-address.h: ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const * prefix) [constructor]

   843     cls.add_constructor([param('ns3::Ipv6Prefix const *', 'prefix')])

   844     ## ipv6-address.h: void ns3::Ipv6Prefix::GetBytes(uint8_t * buf) const [member function]

   845     cls.add_method('GetBytes',

   846                    'void',

   847                    [param('uint8_t *', 'buf')],

   848                    is_const=True)

   849     ## ipv6-address.h: static ns3::Ipv6Prefix ns3::Ipv6Prefix::GetLoopback() [member function]

   850     cls.add_method('GetLoopback',

   851                    'ns3::Ipv6Prefix',

   852                    [],

   853                    is_static=True)

   854     ## ipv6-address.h: static ns3::Ipv6Prefix ns3::Ipv6Prefix::GetZero() [member function]

   855     cls.add_method('GetZero',

   856                    'ns3::Ipv6Prefix',

   857                    [],

   858                    is_static=True)

   859     ## ipv6-address.h: bool ns3::Ipv6Prefix::IsEqual(ns3::Ipv6Prefix const & other) const [member function]

   860     cls.add_method('IsEqual',

   861                    'bool',

   862                    [param('ns3::Ipv6Prefix const &', 'other')],

   863                    is_const=True)

   864     ## ipv6-address.h: bool ns3::Ipv6Prefix::IsMatch(ns3::Ipv6Address a, ns3::Ipv6Address b) const [member function]

   865     cls.add_method('IsMatch',

   866                    'bool',

   867                    [param('ns3::Ipv6Address', 'a'), param('ns3::Ipv6Address', 'b')],

   868                    is_const=True)

   869     ## ipv6-address.h: void ns3::Ipv6Prefix::Print(std::ostream & os) const [member function]

   870     cls.add_method('Print',

   871                    'void',

   872                    [param('std::ostream &', 'os')],

   873                    is_const=True)

   874     return

   876 def register_Ns3Mac48Address_methods(root_module, cls):

   877     cls.add_binary_comparison_operator('!=')

   878     cls.add_binary_comparison_operator('<')

   879     cls.add_output_stream_operator()

   880     cls.add_binary_comparison_operator('==')

   881     ## mac48-address.h: ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [copy constructor]

   882     cls.add_constructor([param('ns3::Mac48Address const &', 'arg0')])

   883     ## mac48-address.h: ns3::Mac48Address::Mac48Address() [constructor]

   884     cls.add_constructor([])

   885     ## mac48-address.h: ns3::Mac48Address::Mac48Address(char const * str) [constructor]

   886     cls.add_constructor([param('char const *', 'str')])

   887     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::Allocate() [member function]

   888     cls.add_method('Allocate',

   889                    'ns3::Mac48Address',

   890                    [],

   891                    is_static=True)

   892     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::ConvertFrom(ns3::Address const & address) [member function]

   893     cls.add_method('ConvertFrom',

   894                    'ns3::Mac48Address',

   895                    [param('ns3::Address const &', 'address')],

   896                    is_static=True)

   897     ## mac48-address.h: void ns3::Mac48Address::CopyFrom(uint8_t const * buffer) [member function]

   898     cls.add_method('CopyFrom',

   899                    'void',

   900                    [param('uint8_t const *', 'buffer')])

   901     ## mac48-address.h: void ns3::Mac48Address::CopyTo(uint8_t * buffer) const [member function]

   902     cls.add_method('CopyTo',

   903                    'void',

   904                    [param('uint8_t *', 'buffer')],

   905                    is_const=True)

   906     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::GetBroadcast() [member function]

   907     cls.add_method('GetBroadcast',

   908                    'ns3::Mac48Address',

   909                    [],

   910                    is_static=True)

   911     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::GetMulticast(ns3::Ipv4Address address) [member function]

   912     cls.add_method('GetMulticast',

   913                    'ns3::Mac48Address',

   914                    [param('ns3::Ipv4Address', 'address')],

   915                    is_static=True)

   916     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::GetMulticast(ns3::Ipv6Address address) [member function]

   917     cls.add_method('GetMulticast',

   918                    'ns3::Mac48Address',

   919                    [param('ns3::Ipv6Address', 'address')],

   920                    is_static=True)

   921     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::GetMulticast6Prefix() [member function]

   922     cls.add_method('GetMulticast6Prefix',

   923                    'ns3::Mac48Address',

   924                    [],

   925                    is_static=True)

   926     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::GetMulticastPrefix() [member function]

   927     cls.add_method('GetMulticastPrefix',

   928                    'ns3::Mac48Address',

   929                    [],

   930                    is_static=True)

   931     ## mac48-address.h: bool ns3::Mac48Address::IsBroadcast() const [member function]

   932     cls.add_method('IsBroadcast',

   933                    'bool',

   934                    [],

   935                    is_const=True)

   936     ## mac48-address.h: bool ns3::Mac48Address::IsGroup() const [member function]

   937     cls.add_method('IsGroup',

   938                    'bool',

   939                    [],

   940                    is_const=True)

   941     ## mac48-address.h: static bool ns3::Mac48Address::IsMatchingType(ns3::Address const & address) [member function]

   942     cls.add_method('IsMatchingType',

   943                    'bool',

   944                    [param('ns3::Address const &', 'address')],

   945                    is_static=True)

   946     return

   948 def register_Ns3Mac64Address_methods(root_module, cls):

   949     cls.add_binary_comparison_operator('!=')

   950     cls.add_output_stream_operator()

   951     cls.add_binary_comparison_operator('==')

   952     ## mac64-address.h: ns3::Mac64Address::Mac64Address(ns3::Mac64Address const & arg0) [copy constructor]

   953     cls.add_constructor([param('ns3::Mac64Address const &', 'arg0')])

   954     ## mac64-address.h: ns3::Mac64Address::Mac64Address() [constructor]

   955     cls.add_constructor([])

   956     ## mac64-address.h: ns3::Mac64Address::Mac64Address(char const * str) [constructor]

   957     cls.add_constructor([param('char const *', 'str')])

   958     ## mac64-address.h: static ns3::Mac64Address ns3::Mac64Address::Allocate() [member function]

   959     cls.add_method('Allocate',

   960                    'ns3::Mac64Address',

   961                    [],

   962                    is_static=True)

   963     ## mac64-address.h: static ns3::Mac64Address ns3::Mac64Address::ConvertFrom(ns3::Address const & address) [member function]

   964     cls.add_method('ConvertFrom',

   965                    'ns3::Mac64Address',

   966                    [param('ns3::Address const &', 'address')],

   967                    is_static=True)

   968     ## mac64-address.h: void ns3::Mac64Address::CopyFrom(uint8_t const * buffer) [member function]

   969     cls.add_method('CopyFrom',

   970                    'void',

   971                    [param('uint8_t const *', 'buffer')])

   972     ## mac64-address.h: void ns3::Mac64Address::CopyTo(uint8_t * buffer) const [member function]

   973     cls.add_method('CopyTo',

   974                    'void',

   975                    [param('uint8_t *', 'buffer')],

   976                    is_const=True)

   977     ## mac64-address.h: static bool ns3::Mac64Address::IsMatchingType(ns3::Address const & address) [member function]

   978     cls.add_method('IsMatchingType',

   979                    'bool',

   980                    [param('ns3::Address const &', 'address')],

   981                    is_static=True)

   982     return

   984 def register_Ns3NodeList_methods(root_module, cls):

   985     ## node-list.h: ns3::NodeList::NodeList(ns3::NodeList const & arg0) [copy constructor]

   986     cls.add_constructor([param('ns3::NodeList const &', 'arg0')])

   987     ## node-list.h: ns3::NodeList::NodeList() [constructor]

   988     cls.add_constructor([])

   989     ## node-list.h: static uint32_t ns3::NodeList::Add(ns3::Ptr<ns3::Node> node) [member function]

   990     cls.add_method('Add',

   991                    'uint32_t',

   992                    [param('ns3::Ptr< ns3::Node >', 'node')],

   993                    is_static=True)

   994     ## node-list.h: static __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Node>*,std::vector<ns3::Ptr<ns3::Node>, std::allocator<ns3::Ptr<ns3::Node> > > > ns3::NodeList::Begin() [member function]

   995     cls.add_method('Begin',

   996                    '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Node > const, std::vector< ns3::Ptr< ns3::Node > > >',

   997                    [],

   998                    is_static=True)

   999     ## node-list.h: static __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Node>*,std::vector<ns3::Ptr<ns3::Node>, std::allocator<ns3::Ptr<ns3::Node> > > > ns3::NodeList::End() [member function]

  1000     cls.add_method('End',

  1001                    '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Node > const, std::vector< ns3::Ptr< ns3::Node > > >',

  1002                    [],

  1003                    is_static=True)

  1004     ## node-list.h: static ns3::Ptr<ns3::Node> ns3::NodeList::GetNode(uint32_t n) [member function]

  1005     cls.add_method('GetNode',

  1006                    'ns3::Ptr< ns3::Node >',

  1007                    [param('uint32_t', 'n')],

  1008                    is_static=True)

  1009     ## node-list.h: static uint32_t ns3::NodeList::GetNNodes() [member function]

  1010     cls.add_method('GetNNodes',

  1011                    'uint32_t',

  1012                    [],

  1013                    is_static=True)

  1014     return

  1016 def register_Ns3PacketSocketAddress_methods(root_module, cls):

  1017     ## packet-socket-address.h: ns3::PacketSocketAddress::PacketSocketAddress(ns3::PacketSocketAddress const & arg0) [copy constructor]

  1018     cls.add_constructor([param('ns3::PacketSocketAddress const &', 'arg0')])

  1019     ## packet-socket-address.h: ns3::PacketSocketAddress::PacketSocketAddress() [constructor]

  1020     cls.add_constructor([])

  1021     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetProtocol(uint16_t protocol) [member function]

  1022     cls.add_method('SetProtocol',

  1023                    'void',

  1024                    [param('uint16_t', 'protocol')])

  1025     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetAllDevices() [member function]

  1026     cls.add_method('SetAllDevices',

  1027                    'void',

  1028                    [])

  1029     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetSingleDevice(uint32_t device) [member function]

  1030     cls.add_method('SetSingleDevice',

  1031                    'void',

  1032                    [param('uint32_t', 'device')])

  1033     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetPhysicalAddress(ns3::Address const address) [member function]

  1034     cls.add_method('SetPhysicalAddress',

  1035                    'void',

  1036                    [param('ns3::Address const', 'address')])

  1037     ## packet-socket-address.h: uint16_t ns3::PacketSocketAddress::GetProtocol() const [member function]

  1038     cls.add_method('GetProtocol',

  1039                    'uint16_t',

  1040                    [],

  1041                    is_const=True)

  1042     ## packet-socket-address.h: uint32_t ns3::PacketSocketAddress::GetSingleDevice() const [member function]

  1043     cls.add_method('GetSingleDevice',

  1044                    'uint32_t',

  1045                    [],

  1046                    is_const=True)

  1047     ## packet-socket-address.h: bool ns3::PacketSocketAddress::IsSingleDevice() const [member function]

  1048     cls.add_method('IsSingleDevice',

  1049                    'bool',

  1050                    [],

  1051                    is_const=True)

  1052     ## packet-socket-address.h: ns3::Address ns3::PacketSocketAddress::GetPhysicalAddress() const [member function]

  1053     cls.add_method('GetPhysicalAddress',

  1054                    'ns3::Address',

  1055                    [],

  1056                    is_const=True)

  1057     ## packet-socket-address.h: static ns3::PacketSocketAddress ns3::PacketSocketAddress::ConvertFrom(ns3::Address const & address) [member function]

  1058     cls.add_method('ConvertFrom',

  1059                    'ns3::PacketSocketAddress',

  1060                    [param('ns3::Address const &', 'address')],

  1061                    is_static=True)

  1062     ## packet-socket-address.h: static bool ns3::PacketSocketAddress::IsMatchingType(ns3::Address const & address) [member function]

  1063     cls.add_method('IsMatchingType',

  1064                    'bool',

  1065                    [param('ns3::Address const &', 'address')],

  1066                    is_static=True)

  1067     return

  1069 def register_Ns3Ipv4AddressChecker_methods(root_module, cls):

  1070     ## ipv4-address.h: ns3::Ipv4AddressChecker::Ipv4AddressChecker(ns3::Ipv4AddressChecker const & arg0) [copy constructor]

  1071     cls.add_constructor([param('ns3::Ipv4AddressChecker const &', 'arg0')])

  1072     ## ipv4-address.h: ns3::Ipv4AddressChecker::Ipv4AddressChecker() [constructor]

  1073     cls.add_constructor([])

  1074     return

  1076 def register_Ns3Ipv4AddressValue_methods(root_module, cls):

  1077     ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4AddressValue const & arg0) [copy constructor]

  1078     cls.add_constructor([param('ns3::Ipv4AddressValue const &', 'arg0')])

  1079     ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue() [constructor]

  1080     cls.add_constructor([])

  1081     ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4Address const & value) [constructor]

  1082     cls.add_constructor([param('ns3::Ipv4Address const &', 'value')])

  1083     ## ipv4-address.h: void ns3::Ipv4AddressValue::Set(ns3::Ipv4Address const & value) [member function]

  1084     cls.add_method('Set',

  1085                    'void',

  1086                    [param('ns3::Ipv4Address const &', 'value')])

  1087     ## ipv4-address.h: ns3::Ipv4Address ns3::Ipv4AddressValue::Get() const [member function]

  1088     cls.add_method('Get',

  1089                    'ns3::Ipv4Address',

  1090                    [],

  1091                    is_const=True)

  1092     ## ipv4-address.h: ns3::Ptr<ns3::AttributeValue> ns3::Ipv4AddressValue::Copy() const [member function]

  1093     cls.add_method('Copy',

  1094                    'ns3::Ptr< ns3::AttributeValue >',

  1095                    [],

  1096                    is_const=True, is_virtual=True)

  1097     ## ipv4-address.h: std::string ns3::Ipv4AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

  1098     cls.add_method('SerializeToString',

  1099                    'std::string',

  1100                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],

  1101                    is_const=True, is_virtual=True)

  1102     ## ipv4-address.h: bool ns3::Ipv4AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

  1103     cls.add_method('DeserializeFromString',

  1104                    'bool',

  1105                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],

  1106                    is_virtual=True)

  1107     return

  1109 def register_Ns3Ipv4Header_methods(root_module, cls):

  1110     ## ipv4-header.h: ns3::Ipv4Header::Ipv4Header(ns3::Ipv4Header const & arg0) [copy constructor]

  1111     cls.add_constructor([param('ns3::Ipv4Header const &', 'arg0')])

  1112     ## ipv4-header.h: ns3::Ipv4Header::Ipv4Header() [constructor]

  1113     cls.add_constructor([])

  1114     ## ipv4-header.h: void ns3::Ipv4Header::EnableChecksum() [member function]

  1115     cls.add_method('EnableChecksum',

  1116                    'void',

  1117                    [])

  1118     ## ipv4-header.h: void ns3::Ipv4Header::SetPayloadSize(uint16_t size) [member function]

  1119     cls.add_method('SetPayloadSize',

  1120                    'void',

  1121                    [param('uint16_t', 'size')])

  1122     ## ipv4-header.h: void ns3::Ipv4Header::SetIdentification(uint16_t identification) [member function]

  1123     cls.add_method('SetIdentification',

  1124                    'void',

  1125                    [param('uint16_t', 'identification')])

  1126     ## ipv4-header.h: void ns3::Ipv4Header::SetTos(uint8_t tos) [member function]

  1127     cls.add_method('SetTos',

  1128                    'void',

  1129                    [param('uint8_t', 'tos')])

  1130     ## ipv4-header.h: void ns3::Ipv4Header::SetMoreFragments() [member function]

  1131     cls.add_method('SetMoreFragments',

  1132                    'void',

  1133                    [])

  1134     ## ipv4-header.h: void ns3::Ipv4Header::SetLastFragment() [member function]

  1135     cls.add_method('SetLastFragment',

  1136                    'void',

  1137                    [])

  1138     ## ipv4-header.h: void ns3::Ipv4Header::SetDontFragment() [member function]

  1139     cls.add_method('SetDontFragment',

  1140                    'void',

  1141                    [])

  1142     ## ipv4-header.h: void ns3::Ipv4Header::SetMayFragment() [member function]

  1143     cls.add_method('SetMayFragment',

  1144                    'void',

  1145                    [])

  1146     ## ipv4-header.h: void ns3::Ipv4Header::SetFragmentOffset(uint16_t offset) [member function]

  1147     cls.add_method('SetFragmentOffset',

  1148                    'void',

  1149                    [param('uint16_t', 'offset')])

  1150     ## ipv4-header.h: void ns3::Ipv4Header::SetTtl(uint8_t ttl) [member function]

  1151     cls.add_method('SetTtl',

  1152                    'void',

  1153                    [param('uint8_t', 'ttl')])

  1154     ## ipv4-header.h: void ns3::Ipv4Header::SetProtocol(uint8_t num) [member function]

  1155     cls.add_method('SetProtocol',

  1156                    'void',

  1157                    [param('uint8_t', 'num')])

  1158     ## ipv4-header.h: void ns3::Ipv4Header::SetSource(ns3::Ipv4Address source) [member function]

  1159     cls.add_method('SetSource',

  1160                    'void',

  1161                    [param('ns3::Ipv4Address', 'source')])

  1162     ## ipv4-header.h: void ns3::Ipv4Header::SetDestination(ns3::Ipv4Address destination) [member function]

  1163     cls.add_method('SetDestination',

  1164                    'void',

  1165                    [param('ns3::Ipv4Address', 'destination')])

  1166     ## ipv4-header.h: uint16_t ns3::Ipv4Header::GetPayloadSize() const [member function]

  1167     cls.add_method('GetPayloadSize',

  1168                    'uint16_t',

  1169                    [],

  1170                    is_const=True)

  1171     ## ipv4-header.h: uint16_t ns3::Ipv4Header::GetIdentification() const [member function]

  1172     cls.add_method('GetIdentification',

  1173                    'uint16_t',

  1174                    [],

  1175                    is_const=True)

  1176     ## ipv4-header.h: uint8_t ns3::Ipv4Header::GetTos() const [member function]

  1177     cls.add_method('GetTos',

  1178                    'uint8_t',

  1179                    [],

  1180                    is_const=True)

  1181     ## ipv4-header.h: bool ns3::Ipv4Header::IsLastFragment() const [member function]

  1182     cls.add_method('IsLastFragment',

  1183                    'bool',

  1184                    [],

  1185                    is_const=True)

  1186     ## ipv4-header.h: bool ns3::Ipv4Header::IsDontFragment() const [member function]

  1187     cls.add_method('IsDontFragment',

  1188                    'bool',

  1189                    [],

  1190                    is_const=True)

  1191     ## ipv4-header.h: uint16_t ns3::Ipv4Header::GetFragmentOffset() const [member function]

  1192     cls.add_method('GetFragmentOffset',

  1193                    'uint16_t',

  1194                    [],

  1195                    is_const=True)

  1196     ## ipv4-header.h: uint8_t ns3::Ipv4Header::GetTtl() const [member function]

  1197     cls.add_method('GetTtl',

  1198                    'uint8_t',

  1199                    [],

  1200                    is_const=True)

  1201     ## ipv4-header.h: uint8_t ns3::Ipv4Header::GetProtocol() const [member function]

  1202     cls.add_method('GetProtocol',

  1203                    'uint8_t',

  1204                    [],

  1205                    is_const=True)

  1206     ## ipv4-header.h: ns3::Ipv4Address ns3::Ipv4Header::GetSource() const [member function]

  1207     cls.add_method('GetSource',

  1208                    'ns3::Ipv4Address',

  1209                    [],

  1210                    is_const=True)

  1211     ## ipv4-header.h: ns3::Ipv4Address ns3::Ipv4Header::GetDestination() const [member function]

  1212     cls.add_method('GetDestination',

  1213                    'ns3::Ipv4Address',

  1214                    [],

  1215                    is_const=True)

  1216     ## ipv4-header.h: bool ns3::Ipv4Header::IsChecksumOk() const [member function]

  1217     cls.add_method('IsChecksumOk',

  1218                    'bool',

  1219                    [],

  1220                    is_const=True)

  1221     ## ipv4-header.h: static ns3::TypeId ns3::Ipv4Header::GetTypeId() [member function]

  1222     cls.add_method('GetTypeId',

  1223                    'ns3::TypeId',

  1224                    [],

  1225                    is_static=True)

  1226     ## ipv4-header.h: ns3::TypeId ns3::Ipv4Header::GetInstanceTypeId() const [member function]

  1227     cls.add_method('GetInstanceTypeId',

  1228                    'ns3::TypeId',

  1229                    [],

  1230                    is_const=True, is_virtual=True)

  1231     ## ipv4-header.h: void ns3::Ipv4Header::Print(std::ostream & os) const [member function]

  1232     cls.add_method('Print',

  1233                    'void',

  1234                    [param('std::ostream &', 'os')],

  1235                    is_const=True, is_virtual=True)

  1236     ## ipv4-header.h: uint32_t ns3::Ipv4Header::GetSerializedSize() const [member function]

  1237     cls.add_method('GetSerializedSize',

  1238                    'uint32_t',

  1239                    [],

  1240                    is_const=True, is_virtual=True)

  1241     ## ipv4-header.h: void ns3::Ipv4Header::Serialize(ns3::Buffer::Iterator start) const [member function]

  1242     cls.add_method('Serialize',

  1243                    'void',

  1244                    [param('ns3::Buffer::Iterator', 'start')],

  1245                    is_const=True, is_virtual=True)

  1246     ## ipv4-header.h: uint32_t ns3::Ipv4Header::Deserialize(ns3::Buffer::Iterator start) [member function]

  1247     cls.add_method('Deserialize',

  1248                    'uint32_t',

  1249                    [param('ns3::Buffer::Iterator', 'start')],

  1250                    is_virtual=True)

  1251     return

  1253 def register_Ns3Ipv4MaskChecker_methods(root_module, cls):

  1254     ## ipv4-address.h: ns3::Ipv4MaskChecker::Ipv4MaskChecker(ns3::Ipv4MaskChecker const & arg0) [copy constructor]

  1255     cls.add_constructor([param('ns3::Ipv4MaskChecker const &', 'arg0')])

  1256     ## ipv4-address.h: ns3::Ipv4MaskChecker::Ipv4MaskChecker() [constructor]

  1257     cls.add_constructor([])

  1258     return

  1260 def register_Ns3Ipv4MaskValue_methods(root_module, cls):

  1261     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4MaskValue const & arg0) [copy constructor]

  1262     cls.add_constructor([param('ns3::Ipv4MaskValue const &', 'arg0')])

  1263     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue() [constructor]

  1264     cls.add_constructor([])

  1265     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4Mask const & value) [constructor]

  1266     cls.add_constructor([param('ns3::Ipv4Mask const &', 'value')])

  1267     ## ipv4-address.h: void ns3::Ipv4MaskValue::Set(ns3::Ipv4Mask const & value) [member function]

  1268     cls.add_method('Set',

  1269                    'void',

  1270                    [param('ns3::Ipv4Mask const &', 'value')])

  1271     ## ipv4-address.h: ns3::Ipv4Mask ns3::Ipv4MaskValue::Get() const [member function]

  1272     cls.add_method('Get',

  1273                    'ns3::Ipv4Mask',

  1274                    [],

  1275                    is_const=True)

  1276     ## ipv4-address.h: ns3::Ptr<ns3::AttributeValue> ns3::Ipv4MaskValue::Copy() const [member function]

  1277     cls.add_method('Copy',

  1278                    'ns3::Ptr< ns3::AttributeValue >',

  1279                    [],

  1280                    is_const=True, is_virtual=True)

  1281     ## ipv4-address.h: std::string ns3::Ipv4MaskValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

  1282     cls.add_method('SerializeToString',

  1283                    'std::string',

  1284                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],

  1285                    is_const=True, is_virtual=True)

  1286     ## ipv4-address.h: bool ns3::Ipv4MaskValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

  1287     cls.add_method('DeserializeFromString',

  1288                    'bool',

  1289                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],

  1290                    is_virtual=True)

  1291     return

  1293 def register_Ns3Ipv4MulticastRoute_methods(root_module, cls):

  1294     ## ipv4-route.h: ns3::Ipv4MulticastRoute::MAX_INTERFACES [variable]

  1295     cls.add_static_attribute('MAX_INTERFACES', 'uint32_t const', is_const=True)

  1296     ## ipv4-route.h: ns3::Ipv4MulticastRoute::MAX_TTL [variable]

  1297     cls.add_static_attribute('MAX_TTL', 'uint32_t const', is_const=True)

  1298     ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute(ns3::Ipv4MulticastRoute const & arg0) [copy constructor]

  1299     cls.add_constructor([param('ns3::Ipv4MulticastRoute const &', 'arg0')])

  1300     ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute() [constructor]

  1301     cls.add_constructor([])

  1302     ## ipv4-route.h: void ns3::Ipv4MulticastRoute::SetGroup(ns3::Ipv4Address const group) [member function]

  1303     cls.add_method('SetGroup',

  1304                    'void',

  1305                    [param('ns3::Ipv4Address const', 'group')])

  1306     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4MulticastRoute::GetGroup() const [member function]

  1307     cls.add_method('GetGroup',

  1308                    'ns3::Ipv4Address',

  1309                    [],

  1310                    is_const=True)

  1311     ## ipv4-route.h: void ns3::Ipv4MulticastRoute::SetOrigin(ns3::Ipv4Address const origin) [member function]

  1312     cls.add_method('SetOrigin',

  1313                    'void',

  1314                    [param('ns3::Ipv4Address const', 'origin')])

  1315     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4MulticastRoute::GetOrigin() const [member function]

  1316     cls.add_method('GetOrigin',

  1317                    'ns3::Ipv4Address',

  1318                    [],

  1319                    is_const=True)

  1320     ## ipv4-route.h: void ns3::Ipv4MulticastRoute::SetParent(uint32_t iif) [member function]

  1321     cls.add_method('SetParent',

  1322                    'void',

  1323                    [param('uint32_t', 'iif')])

  1324     ## ipv4-route.h: uint32_t ns3::Ipv4MulticastRoute::GetParent() const [member function]

  1325     cls.add_method('GetParent',

  1326                    'uint32_t',

  1327                    [],

  1328                    is_const=True)

  1329     ## ipv4-route.h: void ns3::Ipv4MulticastRoute::SetOutputTtl(uint32_t oif, uint32_t ttl) [member function]

  1330     cls.add_method('SetOutputTtl',

  1331                    'void',

  1332                    [param('uint32_t', 'oif'), param('uint32_t', 'ttl')])

  1333     ## ipv4-route.h: uint32_t ns3::Ipv4MulticastRoute::GetOutputTtl(uint32_t oif) const [member function]

  1334     cls.add_method('GetOutputTtl',

  1335                    'uint32_t',

  1336                    [param('uint32_t', 'oif')],

  1337                    is_const=True)

  1338     return

  1340 def register_Ns3Ipv4Route_methods(root_module, cls):

  1341     cls.add_output_stream_operator()

  1342     ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route(ns3::Ipv4Route const & arg0) [copy constructor]

  1343     cls.add_constructor([param('ns3::Ipv4Route const &', 'arg0')])

  1344     ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route() [constructor]

  1345     cls.add_constructor([])

  1346     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4Route::GetDestination() const [member function]

  1347     cls.add_method('GetDestination',

  1348                    'ns3::Ipv4Address',

  1349                    [],

  1350                    is_const=True)

  1351     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4Route::GetGateway() const [member function]

  1352     cls.add_method('GetGateway',

  1353                    'ns3::Ipv4Address',

  1354                    [],

  1355                    is_const=True)

  1356     ## ipv4-route.h: ns3::Ptr<ns3::NetDevice> ns3::Ipv4Route::GetOutputDevice() const [member function]

  1357     cls.add_method('GetOutputDevice',

  1358                    'ns3::Ptr< ns3::NetDevice >',

  1359                    [],

  1360                    is_const=True)

  1361     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4Route::GetSource() const [member function]

  1362     cls.add_method('GetSource',

  1363                    'ns3::Ipv4Address',

  1364                    [],

  1365                    is_const=True)

  1366     ## ipv4-route.h: void ns3::Ipv4Route::SetDestination(ns3::Ipv4Address dest) [member function]

  1367     cls.add_method('SetDestination',

  1368                    'void',

  1369                    [param('ns3::Ipv4Address', 'dest')])

  1370     ## ipv4-route.h: void ns3::Ipv4Route::SetGateway(ns3::Ipv4Address gw) [member function]

  1371     cls.add_method('SetGateway',

  1372                    'void',

  1373                    [param('ns3::Ipv4Address', 'gw')])

  1374     ## ipv4-route.h: void ns3::Ipv4Route::SetOutputDevice(ns3::Ptr<ns3::NetDevice> outputDevice) [member function]

  1375     cls.add_method('SetOutputDevice',

  1376                    'void',

  1377                    [param('ns3::Ptr< ns3::NetDevice >', 'outputDevice')])

  1378     ## ipv4-route.h: void ns3::Ipv4Route::SetSource(ns3::Ipv4Address src) [member function]

  1379     cls.add_method('SetSource',

  1380                    'void',

  1381                    [param('ns3::Ipv4Address', 'src')])

  1382     return

  1384 def register_Ns3Ipv6AddressChecker_methods(root_module, cls):

  1385     ## ipv6-address.h: ns3::Ipv6AddressChecker::Ipv6AddressChecker(ns3::Ipv6AddressChecker const & arg0) [copy constructor]

  1386     cls.add_constructor([param('ns3::Ipv6AddressChecker const &', 'arg0')])

  1387     ## ipv6-address.h: ns3::Ipv6AddressChecker::Ipv6AddressChecker() [constructor]

  1388     cls.add_constructor([])

  1389     return

  1391 def register_Ns3Ipv6AddressValue_methods(root_module, cls):

  1392     ## ipv6-address.h: ns3::Ipv6AddressValue::Ipv6AddressValue(ns3::Ipv6AddressValue const & arg0) [copy constructor]

  1393     cls.add_constructor([param('ns3::Ipv6AddressValue const &', 'arg0')])

  1394     ## ipv6-address.h: ns3::Ipv6AddressValue::Ipv6AddressValue() [constructor]

  1395     cls.add_constructor([])

  1396     ## ipv6-address.h: ns3::Ipv6AddressValue::Ipv6AddressValue(ns3::Ipv6Address const & value) [constructor]

  1397     cls.add_constructor([param('ns3::Ipv6Address const &', 'value')])

  1398     ## ipv6-address.h: void ns3::Ipv6AddressValue::Set(ns3::Ipv6Address const & value) [member function]

  1399     cls.add_method('Set',

  1400                    'void',

  1401                    [param('ns3::Ipv6Address const &', 'value')])

  1402     ## ipv6-address.h: ns3::Ipv6Address ns3::Ipv6AddressValue::Get() const [member function]

  1403     cls.add_method('Get',

  1404                    'ns3::Ipv6Address',

  1405                    [],

  1406                    is_const=True)

  1407     ## ipv6-address.h: ns3::Ptr<ns3::AttributeValue> ns3::Ipv6AddressValue::Copy() const [member function]

  1408     cls.add_method('Copy',

  1409                    'ns3::Ptr< ns3::AttributeValue >',

  1410                    [],

  1411                    is_const=True, is_virtual=True)

  1412     ## ipv6-address.h: std::string ns3::Ipv6AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

  1413     cls.add_method('SerializeToString',

  1414                    'std::string',

  1415                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],

  1416                    is_const=True, is_virtual=True)

  1417     ## ipv6-address.h: bool ns3::Ipv6AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

  1418     cls.add_method('DeserializeFromString',

  1419                    'bool',

  1420                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],

  1421                    is_virtual=True)

  1422     return

  1424 def register_Ns3Ipv6Header_methods(root_module, cls):

  1425     ## ipv6-header.h: ns3::Ipv6Header::Ipv6Header(ns3::Ipv6Header const & arg0) [copy constructor]

  1426     cls.add_constructor([param('ns3::Ipv6Header const &', 'arg0')])

  1427     ## ipv6-header.h: static ns3::TypeId ns3::Ipv6Header::GetTypeId() [member function]

  1428     cls.add_method('GetTypeId',

  1429                    'ns3::TypeId',

  1430                    [],

  1431                    is_static=True)

  1432     ## ipv6-header.h: ns3::TypeId ns3::Ipv6Header::GetInstanceTypeId() const [member function]

  1433     cls.add_method('GetInstanceTypeId',

  1434                    'ns3::TypeId',

  1435                    [],

  1436                    is_const=True, is_virtual=True)

  1437     ## ipv6-header.h: ns3::Ipv6Header::Ipv6Header() [constructor]

  1438     cls.add_constructor([])

  1439     ## ipv6-header.h: void ns3::Ipv6Header::SetTrafficClass(uint8_t traffic) [member function]

  1440     cls.add_method('SetTrafficClass',

  1441                    'void',

  1442                    [param('uint8_t', 'traffic')])

  1443     ## ipv6-header.h: uint8_t ns3::Ipv6Header::GetTrafficClass() const [member function]

  1444     cls.add_method('GetTrafficClass',

  1445                    'uint8_t',

  1446                    [],

  1447                    is_const=True)

  1448     ## ipv6-header.h: void ns3::Ipv6Header::SetFlowLabel(uint32_t flow) [member function]

  1449     cls.add_method('SetFlowLabel',

  1450                    'void',

  1451                    [param('uint32_t', 'flow')])

  1452     ## ipv6-header.h: uint32_t ns3::Ipv6Header::GetFlowLabel() const [member function]

  1453     cls.add_method('GetFlowLabel',

  1454                    'uint32_t',

  1455                    [],

  1456                    is_const=True)

  1457     ## ipv6-header.h: void ns3::Ipv6Header::SetPayloadLength(uint16_t len) [member function]

  1458     cls.add_method('SetPayloadLength',

  1459                    'void',

  1460                    [param('uint16_t', 'len')])

  1461     ## ipv6-header.h: uint16_t ns3::Ipv6Header::GetPayloadLength() const [member function]

  1462     cls.add_method('GetPayloadLength',

  1463                    'uint16_t',

  1464                    [],

  1465                    is_const=True)

  1466     ## ipv6-header.h: void ns3::Ipv6Header::SetNextHeader(uint8_t next) [member function]

  1467     cls.add_method('SetNextHeader',

  1468                    'void',

  1469                    [param('uint8_t', 'next')])

  1470     ## ipv6-header.h: uint8_t ns3::Ipv6Header::GetNextHeader() const [member function]

  1471     cls.add_method('GetNextHeader',

  1472                    'uint8_t',

  1473                    [],

  1474                    is_const=True)

  1475     ## ipv6-header.h: void ns3::Ipv6Header::SetHopLimit(uint8_t limit) [member function]

  1476     cls.add_method('SetHopLimit',

  1477                    'void',

  1478                    [param('uint8_t', 'limit')])

  1479     ## ipv6-header.h: uint8_t ns3::Ipv6Header::GetHopLimit() const [member function]

  1480     cls.add_method('GetHopLimit',

  1481                    'uint8_t',

  1482                    [],

  1483                    is_const=True)

  1484     ## ipv6-header.h: void ns3::Ipv6Header::SetSourceAddress(ns3::Ipv6Address src) [member function]

  1485     cls.add_method('SetSourceAddress',

  1486                    'void',

  1487                    [param('ns3::Ipv6Address', 'src')])

  1488     ## ipv6-header.h: ns3::Ipv6Address ns3::Ipv6Header::GetSourceAddress() const [member function]

  1489     cls.add_method('GetSourceAddress',

  1490                    'ns3::Ipv6Address',

  1491                    [],

  1492                    is_const=True)

  1493     ## ipv6-header.h: void ns3::Ipv6Header::SetDestinationAddress(ns3::Ipv6Address dst) [member function]

  1494     cls.add_method('SetDestinationAddress',

  1495                    'void',

  1496                    [param('ns3::Ipv6Address', 'dst')])

  1497     ## ipv6-header.h: ns3::Ipv6Address ns3::Ipv6Header::GetDestinationAddress() const [member function]

  1498     cls.add_method('GetDestinationAddress',

  1499                    'ns3::Ipv6Address',

  1500                    [],

  1501                    is_const=True)

  1502     ## ipv6-header.h: void ns3::Ipv6Header::Print(std::ostream & os) const [member function]

  1503     cls.add_method('Print',

  1504                    'void',

  1505                    [param('std::ostream &', 'os')],

  1506                    is_const=True, is_virtual=True)

  1507     ## ipv6-header.h: uint32_t ns3::Ipv6Header::GetSerializedSize() const [member function]

  1508     cls.add_method('GetSerializedSize',

  1509                    'uint32_t',

  1510                    [],

  1511                    is_const=True, is_virtual=True)

  1512     ## ipv6-header.h: void ns3::Ipv6Header::Serialize(ns3::Buffer::Iterator start) const [member function]

  1513     cls.add_method('Serialize',

  1514                    'void',

  1515                    [param('ns3::Buffer::Iterator', 'start')],

  1516                    is_const=True, is_virtual=True)

  1517     ## ipv6-header.h: uint32_t ns3::Ipv6Header::Deserialize(ns3::Buffer::Iterator start) [member function]

  1518     cls.add_method('Deserialize',

  1519                    'uint32_t',

  1520                    [param('ns3::Buffer::Iterator', 'start')],

  1521                    is_virtual=True)

  1522     return

  1524 def register_Ns3Ipv6PrefixChecker_methods(root_module, cls):

  1525     ## ipv6-address.h: ns3::Ipv6PrefixChecker::Ipv6PrefixChecker(ns3::Ipv6PrefixChecker const & arg0) [copy constructor]

  1526     cls.add_constructor([param('ns3::Ipv6PrefixChecker const &', 'arg0')])

  1527     ## ipv6-address.h: ns3::Ipv6PrefixChecker::Ipv6PrefixChecker() [constructor]

  1528     cls.add_constructor([])

  1529     return

  1531 def register_Ns3Ipv6PrefixValue_methods(root_module, cls):

  1532     ## ipv6-address.h: ns3::Ipv6PrefixValue::Ipv6PrefixValue(ns3::Ipv6PrefixValue const & arg0) [copy constructor]

  1533     cls.add_constructor([param('ns3::Ipv6PrefixValue const &', 'arg0')])

  1534     ## ipv6-address.h: ns3::Ipv6PrefixValue::Ipv6PrefixValue() [constructor]

  1535     cls.add_constructor([])

  1536     ## ipv6-address.h: ns3::Ipv6PrefixValue::Ipv6PrefixValue(ns3::Ipv6Prefix const & value) [constructor]

  1537     cls.add_constructor([param('ns3::Ipv6Prefix const &', 'value')])

  1538     ## ipv6-address.h: void ns3::Ipv6PrefixValue::Set(ns3::Ipv6Prefix const & value) [member function]

  1539     cls.add_method('Set',

  1540                    'void',

  1541                    [param('ns3::Ipv6Prefix const &', 'value')])

  1542     ## ipv6-address.h: ns3::Ipv6Prefix ns3::Ipv6PrefixValue::Get() const [member function]

  1543     cls.add_method('Get',

  1544                    'ns3::Ipv6Prefix',

  1545                    [],

  1546                    is_const=True)

  1547     ## ipv6-address.h: ns3::Ptr<ns3::AttributeValue> ns3::Ipv6PrefixValue::Copy() const [member function]

  1548     cls.add_method('Copy',

  1549                    'ns3::Ptr< ns3::AttributeValue >',

  1550                    [],

  1551                    is_const=True, is_virtual=True)

  1552     ## ipv6-address.h: std::string ns3::Ipv6PrefixValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

  1553     cls.add_method('SerializeToString',

  1554                    'std::string',

  1555                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],

  1556                    is_const=True, is_virtual=True)

  1557     ## ipv6-address.h: bool ns3::Ipv6PrefixValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

  1558     cls.add_method('DeserializeFromString',

  1559                    'bool',

  1560                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],

  1561                    is_virtual=True)

  1562     return

  1564 def register_Ns3LlcSnapHeader_methods(root_module, cls):

  1565     ## llc-snap-header.h: ns3::LlcSnapHeader::LlcSnapHeader(ns3::LlcSnapHeader const & arg0) [copy constructor]

  1566     cls.add_constructor([param('ns3::LlcSnapHeader const &', 'arg0')])

  1567     ## llc-snap-header.h: ns3::LlcSnapHeader::LlcSnapHeader() [constructor]

  1568     cls.add_constructor([])

  1569     ## llc-snap-header.h: void ns3::LlcSnapHeader::SetType(uint16_t type) [member function]

  1570     cls.add_method('SetType',

  1571                    'void',

  1572                    [param('uint16_t', 'type')])

  1573     ## llc-snap-header.h: uint16_t ns3::LlcSnapHeader::GetType() [member function]

  1574     cls.add_method('GetType',

  1575                    'uint16_t',

  1576                    [])

  1577     ## llc-snap-header.h: static ns3::TypeId ns3::LlcSnapHeader::GetTypeId() [member function]

  1578     cls.add_method('GetTypeId',

  1579                    'ns3::TypeId',

  1580                    [],

  1581                    is_static=True)

  1582     ## llc-snap-header.h: ns3::TypeId ns3::LlcSnapHeader::GetInstanceTypeId() const [member function]

  1583     cls.add_method('GetInstanceTypeId',

  1584                    'ns3::TypeId',

  1585                    [],

  1586                    is_const=True, is_virtual=True)

  1587     ## llc-snap-header.h: void ns3::LlcSnapHeader::Print(std::ostream & os) const [member function]

  1588     cls.add_method('Print',

  1589                    'void',

  1590                    [param('std::ostream &', 'os')],

  1591                    is_const=True, is_virtual=True)

  1592     ## llc-snap-header.h: uint32_t ns3::LlcSnapHeader::GetSerializedSize() const [member function]

  1593     cls.add_method('GetSerializedSize',

  1594                    'uint32_t',

  1595                    [],

  1596                    is_const=True, is_virtual=True)

  1597     ## llc-snap-header.h: void ns3::LlcSnapHeader::Serialize(ns3::Buffer::Iterator start) const [member function]

  1598     cls.add_method('Serialize',

  1599                    'void',

  1600                    [param('ns3::Buffer::Iterator', 'start')],

  1601                    is_const=True, is_virtual=True)

  1602     ## llc-snap-header.h: uint32_t ns3::LlcSnapHeader::Deserialize(ns3::Buffer::Iterator start) [member function]

  1603     cls.add_method('Deserialize',

  1604                    'uint32_t',

  1605                    [param('ns3::Buffer::Iterator', 'start')],

  1606                    is_virtual=True)

  1607     return

  1609 def register_Ns3Mac48AddressChecker_methods(root_module, cls):

  1610     ## mac48-address.h: ns3::Mac48AddressChecker::Mac48AddressChecker(ns3::Mac48AddressChecker const & arg0) [copy constructor]

  1611     cls.add_constructor([param('ns3::Mac48AddressChecker const &', 'arg0')])

  1612     ## mac48-address.h: ns3::Mac48AddressChecker::Mac48AddressChecker() [constructor]

  1613     cls.add_constructor([])

  1614     return

  1616 def register_Ns3Mac48AddressValue_methods(root_module, cls):

  1617     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48AddressValue const & arg0) [copy constructor]

  1618     cls.add_constructor([param('ns3::Mac48AddressValue const &', 'arg0')])

  1619     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue() [constructor]

  1620     cls.add_constructor([])

  1621     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48Address const & value) [constructor]

  1622     cls.add_constructor([param('ns3::Mac48Address const &', 'value')])

  1623     ## mac48-address.h: void ns3::Mac48AddressValue::Set(ns3::Mac48Address const & value) [member function]

  1624     cls.add_method('Set',

  1625                    'void',

  1626                    [param('ns3::Mac48Address const &', 'value')])

  1627     ## mac48-address.h: ns3::Mac48Address ns3::Mac48AddressValue::Get() const [member function]

  1628     cls.add_method('Get',

  1629                    'ns3::Mac48Address',

  1630                    [],

  1631                    is_const=True)

  1632     ## mac48-address.h: ns3::Ptr<ns3::AttributeValue> ns3::Mac48AddressValue::Copy() const [member function]

  1633     cls.add_method('Copy',

  1634                    'ns3::Ptr< ns3::AttributeValue >',

  1635                    [],

  1636                    is_const=True, is_virtual=True)

  1637     ## mac48-address.h: std::string ns3::Mac48AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

  1638     cls.add_method('SerializeToString',

  1639                    'std::string',

  1640                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],

  1641                    is_const=True, is_virtual=True)

  1642     ## mac48-address.h: bool ns3::Mac48AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

  1643     cls.add_method('DeserializeFromString',

  1644                    'bool',

  1645                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],

  1646                    is_virtual=True)

  1647     return

  1649 def register_Ns3Queue_methods(root_module, cls):

  1650     ## queue.h: ns3::Queue::Queue(ns3::Queue const & arg0) [copy constructor]

  1651     cls.add_constructor([param('ns3::Queue const &', 'arg0')])

  1652     ## queue.h: static ns3::TypeId ns3::Queue::GetTypeId() [member function]

  1653     cls.add_method('GetTypeId',

  1654                    'ns3::TypeId',

  1655                    [],

  1656                    is_static=True)

  1657     ## queue.h: ns3::Queue::Queue() [constructor]

  1658     cls.add_constructor([])

  1659     ## queue.h: bool ns3::Queue::IsEmpty() const [member function]

  1660     cls.add_method('IsEmpty',

  1661                    'bool',

  1662                    [],

  1663                    is_const=True)

  1664     ## queue.h: bool ns3::Queue::Enqueue(ns3::Ptr<ns3::Packet> p) [member function]

  1665     cls.add_method('Enqueue',

  1666                    'bool',

  1667                    [param('ns3::Ptr< ns3::Packet >', 'p')])

  1668     ## queue.h: ns3::Ptr<ns3::Packet> ns3::Queue::Dequeue() [member function]

  1669     cls.add_method('Dequeue',

  1670                    'ns3::Ptr< ns3::Packet >',

  1671                    [])

  1672     ## queue.h: ns3::Ptr<ns3::Packet const> ns3::Queue::Peek() const [member function]

  1673     cls.add_method('Peek',

  1674                    'ns3::Ptr< ns3::Packet const >',

  1675                    [],

  1676                    is_const=True)

  1677     ## queue.h: void ns3::Queue::DequeueAll() [member function]

  1678     cls.add_method('DequeueAll',

  1679                    'void',

  1680                    [])

  1681     ## queue.h: uint32_t ns3::Queue::GetNPackets() const [member function]

  1682     cls.add_method('GetNPackets',

  1683                    'uint32_t',

  1684                    [],

  1685                    is_const=True)

  1686     ## queue.h: uint32_t ns3::Queue::GetNBytes() const [member function]

  1687     cls.add_method('GetNBytes',

  1688                    'uint32_t',

  1689                    [],

  1690                    is_const=True)

  1691     ## queue.h: uint32_t ns3::Queue::GetTotalReceivedBytes() const [member function]

  1692     cls.add_method('GetTotalReceivedBytes',

  1693                    'uint32_t',

  1694                    [],

  1695                    is_const=True)

  1696     ## queue.h: uint32_t ns3::Queue::GetTotalReceivedPackets() const [member function]

  1697     cls.add_method('GetTotalReceivedPackets',

  1698                    'uint32_t',

  1699                    [],

  1700                    is_const=True)

  1701     ## queue.h: uint32_t ns3::Queue::GetTotalDroppedBytes() const [member function]

  1702     cls.add_method('GetTotalDroppedBytes',

  1703                    'uint32_t',

  1704                    [],

  1705                    is_const=True)

  1706     ## queue.h: uint32_t ns3::Queue::GetTotalDroppedPackets() const [member function]

  1707     cls.add_method('GetTotalDroppedPackets',

  1708                    'uint32_t',

  1709                    [],

  1710                    is_const=True)

  1711     ## queue.h: void ns3::Queue::ResetStatistics() [member function]

  1712     cls.add_method('ResetStatistics',

  1713                    'void',

  1714                    [])

  1715     ## queue.h: void ns3::Queue::Drop(ns3::Ptr<ns3::Packet> packet) [member function]

  1716     cls.add_method('Drop',

  1717                    'void',

  1718                    [param('ns3::Ptr< ns3::Packet >', 'packet')],

  1719                    visibility='protected')

  1720     ## queue.h: bool ns3::Queue::DoEnqueue(ns3::Ptr<ns3::Packet> p) [member function]

  1721     cls.add_method('DoEnqueue',

  1722                    'bool',

  1723                    [param('ns3::Ptr< ns3::Packet >', 'p')],

  1724                    is_pure_virtual=True, visibility='private', is_virtual=True)

  1725     ## queue.h: ns3::Ptr<ns3::Packet> ns3::Queue::DoDequeue() [member function]

  1726     cls.add_method('DoDequeue',

  1727                    'ns3::Ptr< ns3::Packet >',

  1728                    [],

  1729                    is_pure_virtual=True, visibility='private', is_virtual=True)

  1730     ## queue.h: ns3::Ptr<ns3::Packet const> ns3::Queue::DoPeek() const [member function]

  1731     cls.add_method('DoPeek',

  1732                    'ns3::Ptr< ns3::Packet const >',

  1733                    [],

  1734                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)

  1735     return

  1737 def register_Ns3Socket_methods(root_module, cls):

  1738     ## socket.h: ns3::Socket::Socket(ns3::Socket const & arg0) [copy constructor]

  1739     cls.add_constructor([param('ns3::Socket const &', 'arg0')])

  1740     ## socket.h: ns3::Socket::Socket() [constructor]

  1741     cls.add_constructor([])

  1742     ## socket.h: static ns3::Ptr<ns3::Socket> ns3::Socket::CreateSocket(ns3::Ptr<ns3::Node> node, ns3::TypeId tid) [member function]

  1743     cls.add_method('CreateSocket',

  1744                    'ns3::Ptr< ns3::Socket >',

  1745                    [param('ns3::Ptr< ns3::Node >', 'node'), param('ns3::TypeId', 'tid')],

  1746                    is_static=True)

  1747     ## socket.h: ns3::Socket::SocketErrno ns3::Socket::GetErrno() const [member function]

  1748     cls.add_method('GetErrno',

  1749                    'ns3::Socket::SocketErrno',

  1750                    [],

  1751                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1752     ## socket.h: ns3::Ptr<ns3::Node> ns3::Socket::GetNode() const [member function]

  1753     cls.add_method('GetNode',

  1754                    'ns3::Ptr< ns3::Node >',

  1755                    [],

  1756                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1757     ## socket.h: void ns3::Socket::SetConnectCallback(ns3::Callback<void, ns3::Ptr<ns3::Socket>, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> connectionSucceeded, ns3::Callback<void, ns3::Ptr<ns3::Socket>, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> connectionFailed) [member function]

  1758     cls.add_method('SetConnectCallback',

  1759                    'void',

  1760                    [param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'connectionSucceeded'), param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'connectionFailed')])

  1761     ## socket.h: void ns3::Socket::SetAcceptCallback(ns3::Callback<bool, ns3::Ptr<ns3::Socket>, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> connectionRequest, ns3::Callback<void, ns3::Ptr<ns3::Socket>, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> newConnectionCreated) [member function]

  1762     cls.add_method('SetAcceptCallback',

  1763                    'void',

  1764                    [param('ns3::Callback< bool, ns3::Ptr< ns3::Socket >, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'connectionRequest'), param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'newConnectionCreated')])

  1765     ## socket.h: void ns3::Socket::SetDataSentCallback(ns3::Callback<void, ns3::Ptr<ns3::Socket>, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> dataSent) [member function]

  1766     cls.add_method('SetDataSentCallback',

  1767                    'void',

  1768                    [param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'dataSent')])

  1769     ## socket.h: void ns3::Socket::SetSendCallback(ns3::Callback<void, ns3::Ptr<ns3::Socket>, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> sendCb) [member function]

  1770     cls.add_method('SetSendCallback',

  1771                    'void',

  1772                    [param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'sendCb')])

  1773     ## socket.h: void ns3::Socket::SetRecvCallback(ns3::Callback<void, ns3::Ptr<ns3::Socket>, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> arg0) [member function]

  1774     cls.add_method('SetRecvCallback',

  1775                    'void',

  1776                    [param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'arg0')])

  1777     ## socket.h: int ns3::Socket::Bind(ns3::Address const & address) [member function]

  1778     cls.add_method('Bind',

  1779                    'int',

  1780                    [param('ns3::Address const &', 'address')],

  1781                    is_pure_virtual=True, is_virtual=True)

  1782     ## socket.h: int ns3::Socket::Bind() [member function]

  1783     cls.add_method('Bind',

  1784                    'int',

  1785                    [],

  1786                    is_pure_virtual=True, is_virtual=True)

  1787     ## socket.h: int ns3::Socket::Close() [member function]

  1788     cls.add_method('Close',

  1789                    'int',

  1790                    [],

  1791                    is_pure_virtual=True, is_virtual=True)

  1792     ## socket.h: int ns3::Socket::ShutdownSend() [member function]

  1793     cls.add_method('ShutdownSend',

  1794                    'int',

  1795                    [],

  1796                    is_pure_virtual=True, is_virtual=True)

  1797     ## socket.h: int ns3::Socket::ShutdownRecv() [member function]

  1798     cls.add_method('ShutdownRecv',

  1799                    'int',

  1800                    [],

  1801                    is_pure_virtual=True, is_virtual=True)

  1802     ## socket.h: int ns3::Socket::Connect(ns3::Address const & address) [member function]

  1803     cls.add_method('Connect',

  1804                    'int',

  1805                    [param('ns3::Address const &', 'address')],

  1806                    is_pure_virtual=True, is_virtual=True)

  1807     ## socket.h: int ns3::Socket::Listen() [member function]

  1808     cls.add_method('Listen',

  1809                    'int',

  1810                    [],

  1811                    is_pure_virtual=True, is_virtual=True)

  1812     ## socket.h: uint32_t ns3::Socket::GetTxAvailable() const [member function]

  1813     cls.add_method('GetTxAvailable',

  1814                    'uint32_t',

  1815                    [],

  1816                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1817     ## socket.h: int ns3::Socket::Send(ns3::Ptr<ns3::Packet> p, uint32_t flags) [member function]

  1818     cls.add_method('Send',

  1819                    'int',

  1820                    [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'flags')],

  1821                    is_pure_virtual=True, is_virtual=True)

  1822     ## socket.h: int ns3::Socket::SendTo(ns3::Ptr<ns3::Packet> p, uint32_t flags, ns3::Address const & toAddress) [member function]

  1823     cls.add_method('SendTo',

  1824                    'int',

  1825                    [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'flags'), param('ns3::Address const &', 'toAddress')],

  1826                    is_pure_virtual=True, is_virtual=True)

  1827     ## socket.h: uint32_t ns3::Socket::GetRxAvailable() const [member function]

  1828     cls.add_method('GetRxAvailable',

  1829                    'uint32_t',

  1830                    [],

  1831                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1832     ## socket.h: ns3::Ptr<ns3::Packet> ns3::Socket::Recv(uint32_t maxSize, uint32_t flags) [member function]

  1833     cls.add_method('Recv',

  1834                    'ns3::Ptr< ns3::Packet >',

  1835                    [param('uint32_t', 'maxSize'), param('uint32_t', 'flags')],

  1836                    is_pure_virtual=True, is_virtual=True)

  1837     ## socket.h: ns3::Ptr<ns3::Packet> ns3::Socket::RecvFrom(uint32_t maxSize, uint32_t flags, ns3::Address & fromAddress) [member function]

  1838     cls.add_method('RecvFrom',

  1839                    'ns3::Ptr< ns3::Packet >',

  1840                    [param('uint32_t', 'maxSize'), param('uint32_t', 'flags'), param('ns3::Address &', 'fromAddress')],

  1841                    is_pure_virtual=True, is_virtual=True)

  1842     ## socket.h: int ns3::Socket::Send(ns3::Ptr<ns3::Packet> p) [member function]

  1843     cls.add_method('Send',

  1844                    'int',

  1845                    [param('ns3::Ptr< ns3::Packet >', 'p')])

  1846     ## socket.h: int ns3::Socket::Send(uint8_t const * buf, uint32_t size, uint32_t flags) [member function]

  1847     cls.add_method('Send',

  1848                    'int',

  1849                    [param('uint8_t const *', 'buf'), param('uint32_t', 'size'), param('uint32_t', 'flags')])

  1850     ## socket.h: int ns3::Socket::SendTo(uint8_t const * buf, uint32_t size, uint32_t flags, ns3::Address const & address) [member function]

  1851     cls.add_method('SendTo',

  1852                    'int',

  1853                    [param('uint8_t const *', 'buf'), param('uint32_t', 'size'), param('uint32_t', 'flags'), param('ns3::Address const &', 'address')])

  1854     ## socket.h: ns3::Ptr<ns3::Packet> ns3::Socket::Recv() [member function]

  1855     cls.add_method('Recv',

  1856                    'ns3::Ptr< ns3::Packet >',

  1857                    [])

  1858     ## socket.h: int ns3::Socket::Recv(uint8_t * buf, uint32_t size, uint32_t flags) [member function]

  1859     cls.add_method('Recv',

  1860                    'int',

  1861                    [param('uint8_t *', 'buf'), param('uint32_t', 'size'), param('uint32_t', 'flags')])

  1862     ## socket.h: ns3::Ptr<ns3::Packet> ns3::Socket::RecvFrom(ns3::Address & fromAddress) [member function]

  1863     cls.add_method('RecvFrom',

  1864                    'ns3::Ptr< ns3::Packet >',

  1865                    [param('ns3::Address &', 'fromAddress')])

  1866     ## socket.h: int ns3::Socket::RecvFrom(uint8_t * buf, uint32_t size, uint32_t flags, ns3::Address & fromAddress) [member function]

  1867     cls.add_method('RecvFrom',

  1868                    'int',

  1869                    [param('uint8_t *', 'buf'), param('uint32_t', 'size'), param('uint32_t', 'flags'), param('ns3::Address &', 'fromAddress')])

  1870     ## socket.h: int ns3::Socket::GetSockName(ns3::Address & address) const [member function]

  1871     cls.add_method('GetSockName',

  1872                    'int',

  1873                    [param('ns3::Address &', 'address')],

  1874                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1875     ## socket.h: void ns3::Socket::NotifyConnectionSucceeded() [member function]

  1876     cls.add_method('NotifyConnectionSucceeded',

  1877                    'void',

  1878                    [],

  1879                    visibility='protected')

  1880     ## socket.h: void ns3::Socket::NotifyConnectionFailed() [member function]

  1881     cls.add_method('NotifyConnectionFailed',

  1882                    'void',

  1883                    [],

  1884                    visibility='protected')

  1885     ## socket.h: bool ns3::Socket::NotifyConnectionRequest(ns3::Address const & from) [member function]

  1886     cls.add_method('NotifyConnectionRequest',

  1887                    'bool',

  1888                    [param('ns3::Address const &', 'from')],

  1889                    visibility='protected')

  1890     ## socket.h: void ns3::Socket::NotifyNewConnectionCreated(ns3::Ptr<ns3::Socket> socket, ns3::Address const & from) [member function]

  1891     cls.add_method('NotifyNewConnectionCreated',

  1892                    'void',

  1893                    [param('ns3::Ptr< ns3::Socket >', 'socket'), param('ns3::Address const &', 'from')],

  1894                    visibility='protected')

  1895     ## socket.h: void ns3::Socket::NotifyDataSent(uint32_t size) [member function]

  1896     cls.add_method('NotifyDataSent',

  1897                    'void',

  1898                    [param('uint32_t', 'size')],

  1899                    visibility='protected')

  1900     ## socket.h: void ns3::Socket::NotifySend(uint32_t spaceAvailable) [member function]

  1901     cls.add_method('NotifySend',

  1902                    'void',

  1903                    [param('uint32_t', 'spaceAvailable')],

  1904                    visibility='protected')

  1905     ## socket.h: void ns3::Socket::NotifyDataRecv() [member function]

  1906     cls.add_method('NotifyDataRecv',

  1907                    'void',

  1908                    [],

  1909                    visibility='protected')

  1910     ## socket.h: void ns3::Socket::DoDispose() [member function]

  1911     cls.add_method('DoDispose',

  1912                    'void',

  1913                    [],

  1914                    visibility='protected', is_virtual=True)

  1915     return

  1917 def register_Ns3SocketAddressTag_methods(root_module, cls):

  1918     ## socket.h: ns3::SocketAddressTag::SocketAddressTag(ns3::SocketAddressTag const & arg0) [copy constructor]

  1919     cls.add_constructor([param('ns3::SocketAddressTag const &', 'arg0')])

  1920     ## socket.h: ns3::SocketAddressTag::SocketAddressTag() [constructor]

  1921     cls.add_constructor([])

  1922     ## socket.h: void ns3::SocketAddressTag::SetAddress(ns3::Address addr) [member function]

  1923     cls.add_method('SetAddress',

  1924                    'void',

  1925                    [param('ns3::Address', 'addr')])

  1926     ## socket.h: ns3::Address ns3::SocketAddressTag::GetAddress() const [member function]

  1927     cls.add_method('GetAddress',

  1928                    'ns3::Address',

  1929                    [],

  1930                    is_const=True)

  1931     ## socket.h: static ns3::TypeId ns3::SocketAddressTag::GetTypeId() [member function]

  1932     cls.add_method('GetTypeId',

  1933                    'ns3::TypeId',

  1934                    [],

  1935                    is_static=True)

  1936     ## socket.h: ns3::TypeId ns3::SocketAddressTag::GetInstanceTypeId() const [member function]

  1937     cls.add_method('GetInstanceTypeId',

  1938                    'ns3::TypeId',

  1939                    [],

  1940                    is_const=True, is_virtual=True)

  1941     ## socket.h: uint32_t ns3::SocketAddressTag::GetSerializedSize() const [member function]

  1942     cls.add_method('GetSerializedSize',

  1943                    'uint32_t',

  1944                    [],

  1945                    is_const=True, is_virtual=True)

  1946     ## socket.h: void ns3::SocketAddressTag::Serialize(ns3::TagBuffer i) const [member function]

  1947     cls.add_method('Serialize',

  1948                    'void',

  1949                    [param('ns3::TagBuffer', 'i')],

  1950                    is_const=True, is_virtual=True)

  1951     ## socket.h: void ns3::SocketAddressTag::Deserialize(ns3::TagBuffer i) [member function]

  1952     cls.add_method('Deserialize',

  1953                    'void',

  1954                    [param('ns3::TagBuffer', 'i')],

  1955                    is_virtual=True)

  1956     ## socket.h: void ns3::SocketAddressTag::Print(std::ostream & os) const [member function]

  1957     cls.add_method('Print',

  1958                    'void',

  1959                    [param('std::ostream &', 'os')],

  1960                    is_const=True, is_virtual=True)

  1961     return

  1963 def register_Ns3SocketFactory_methods(root_module, cls):

  1964     ## socket-factory.h: ns3::SocketFactory::SocketFactory(ns3::SocketFactory const & arg0) [copy constructor]

  1965     cls.add_constructor([param('ns3::SocketFactory const &', 'arg0')])

  1966     ## socket-factory.h: static ns3::TypeId ns3::SocketFactory::GetTypeId() [member function]

  1967     cls.add_method('GetTypeId',

  1968                    'ns3::TypeId',

  1969                    [],

  1970                    is_static=True)

  1971     ## socket-factory.h: ns3::SocketFactory::SocketFactory() [constructor]

  1972     cls.add_constructor([])

  1973     ## socket-factory.h: ns3::Ptr<ns3::Socket> ns3::SocketFactory::CreateSocket() [member function]

  1974     cls.add_method('CreateSocket',

  1975                    'ns3::Ptr< ns3::Socket >',

  1976                    [],

  1977                    is_pure_virtual=True, is_virtual=True)

  1978     return

  1980 def register_Ns3SocketIpTtlTag_methods(root_module, cls):

  1981     ## socket.h: ns3::SocketIpTtlTag::SocketIpTtlTag(ns3::SocketIpTtlTag const & arg0) [copy constructor]

  1982     cls.add_constructor([param('ns3::SocketIpTtlTag const &', 'arg0')])

  1983     ## socket.h: ns3::SocketIpTtlTag::SocketIpTtlTag() [constructor]

  1984     cls.add_constructor([])

  1985     ## socket.h: void ns3::SocketIpTtlTag::SetTtl(uint8_t ttl) [member function]

  1986     cls.add_method('SetTtl',

  1987                    'void',

  1988                    [param('uint8_t', 'ttl')])

  1989     ## socket.h: uint8_t ns3::SocketIpTtlTag::GetTtl() const [member function]

  1990     cls.add_method('GetTtl',

  1991                    'uint8_t',

  1992                    [],

  1993                    is_const=True)

  1994     ## socket.h: static ns3::TypeId ns3::SocketIpTtlTag::GetTypeId() [member function]

  1995     cls.add_method('GetTypeId',

  1996                    'ns3::TypeId',

  1997                    [],

  1998                    is_static=True)

  1999     ## socket.h: ns3::TypeId ns3::SocketIpTtlTag::GetInstanceTypeId() const [member function]

  2000     cls.add_method('GetInstanceTypeId',

  2001                    'ns3::TypeId',

  2002                    [],

  2003                    is_const=True, is_virtual=True)

  2004     ## socket.h: uint32_t ns3::SocketIpTtlTag::GetSerializedSize() const [member function]

  2005     cls.add_method('GetSerializedSize',

  2006                    'uint32_t',

  2007                    [],

  2008                    is_const=True, is_virtual=True)

  2009     ## socket.h: void ns3::SocketIpTtlTag::Serialize(ns3::TagBuffer i) const [member function]

  2010     cls.add_method('Serialize',

  2011                    'void',

  2012                    [param('ns3::TagBuffer', 'i')],

  2013                    is_const=True, is_virtual=True)

  2014     ## socket.h: void ns3::SocketIpTtlTag::Deserialize(ns3::TagBuffer i) [member function]

  2015     cls.add_method('Deserialize',

  2016                    'void',

  2017                    [param('ns3::TagBuffer', 'i')],

  2018                    is_virtual=True)

  2019     ## socket.h: void ns3::SocketIpTtlTag::Print(std::ostream & os) const [member function]

  2020     cls.add_method('Print',

  2021                    'void',

  2022                    [param('std::ostream &', 'os')],

  2023                    is_const=True, is_virtual=True)

  2024     return

  2026 def register_Ns3SocketSetDontFragmentTag_methods(root_module, cls):

  2027     ## socket.h: ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag(ns3::SocketSetDontFragmentTag const & arg0) [copy constructor]

  2028     cls.add_constructor([param('ns3::SocketSetDontFragmentTag const &', 'arg0')])

  2029     ## socket.h: ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag() [constructor]

  2030     cls.add_constructor([])

  2031     ## socket.h: void ns3::SocketSetDontFragmentTag::Enable() [member function]

  2032     cls.add_method('Enable',

  2033                    'void',

  2034                    [])

  2035     ## socket.h: void ns3::SocketSetDontFragmentTag::Disable() [member function]

  2036     cls.add_method('Disable',

  2037                    'void',

  2038                    [])

  2039     ## socket.h: bool ns3::SocketSetDontFragmentTag::IsEnabled() const [member function]

  2040     cls.add_method('IsEnabled',

  2041                    'bool',

  2042                    [],

  2043                    is_const=True)

  2044     ## socket.h: static ns3::TypeId ns3::SocketSetDontFragmentTag::GetTypeId() [member function]

  2045     cls.add_method('GetTypeId',

  2046                    'ns3::TypeId',

  2047                    [],

  2048                    is_static=True)

  2049     ## socket.h: ns3::TypeId ns3::SocketSetDontFragmentTag::GetInstanceTypeId() const [member function]

  2050     cls.add_method('GetInstanceTypeId',

  2051                    'ns3::TypeId',

  2052                    [],

  2053                    is_const=True, is_virtual=True)

  2054     ## socket.h: uint32_t ns3::SocketSetDontFragmentTag::GetSerializedSize() const [member function]

  2055     cls.add_method('GetSerializedSize',

  2056                    'uint32_t',

  2057                    [],

  2058                    is_const=True, is_virtual=True)

  2059     ## socket.h: void ns3::SocketSetDontFragmentTag::Serialize(ns3::TagBuffer i) const [member function]

  2060     cls.add_method('Serialize',

  2061                    'void',

  2062                    [param('ns3::TagBuffer', 'i')],

  2063                    is_const=True, is_virtual=True)

  2064     ## socket.h: void ns3::SocketSetDontFragmentTag::Deserialize(ns3::TagBuffer i) [member function]

  2065     cls.add_method('Deserialize',

  2066                    'void',

  2067                    [param('ns3::TagBuffer', 'i')],

  2068                    is_virtual=True)

  2069     ## socket.h: void ns3::SocketSetDontFragmentTag::Print(std::ostream & os) const [member function]

  2070     cls.add_method('Print',

  2071                    'void',

  2072                    [param('std::ostream &', 'os')],

  2073                    is_const=True, is_virtual=True)

  2074     return

  2076 def register_Ns3TcpSocket_methods(root_module, cls):

  2077     ## tcp-socket.h: ns3::TcpSocket::TcpSocket(ns3::TcpSocket const & arg0) [copy constructor]

  2078     cls.add_constructor([param('ns3::TcpSocket const &', 'arg0')])

  2079     ## tcp-socket.h: static ns3::TypeId ns3::TcpSocket::GetTypeId() [member function]

  2080     cls.add_method('GetTypeId',

  2081                    'ns3::TypeId',

  2082                    [],

  2083                    is_static=True)

  2084     ## tcp-socket.h: ns3::TcpSocket::TcpSocket() [constructor]

  2085     cls.add_constructor([])

  2086     ## tcp-socket.h: void ns3::TcpSocket::SetSndBufSize(uint32_t size) [member function]

  2087     cls.add_method('SetSndBufSize',

  2088                    'void',

  2089                    [param('uint32_t', 'size')],

  2090                    is_pure_virtual=True, visibility='private', is_virtual=True)

  2091     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetSndBufSize() const [member function]

  2092     cls.add_method('GetSndBufSize',

  2093                    'uint32_t',

  2094                    [],

  2095                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)

  2096     ## tcp-socket.h: void ns3::TcpSocket::SetRcvBufSize(uint32_t size) [member function]

  2097     cls.add_method('SetRcvBufSize',

  2098                    'void',

  2099                    [param('uint32_t', 'size')],

  2100                    is_pure_virtual=True, visibility='private', is_virtual=True)

  2101     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetRcvBufSize() const [member function]

  2102     cls.add_method('GetRcvBufSize',

  2103                    'uint32_t',

  2104                    [],

  2105                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)

  2106     ## tcp-socket.h: void ns3::TcpSocket::SetSegSize(uint32_t size) [member function]

  2107     cls.add_method('SetSegSize',

  2108                    'void',

  2109                    [param('uint32_t', 'size')],

  2110                    is_pure_virtual=True, visibility='private', is_virtual=True)

  2111     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetSegSize() const [member function]

  2112     cls.add_method('GetSegSize',

  2113                    'uint32_t',

  2114                    [],

  2115                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)

  2116     ## tcp-socket.h: void ns3::TcpSocket::SetSSThresh(uint32_t threshold) [member function]

  2117     cls.add_method('SetSSThresh',

  2118                    'void',

  2119                    [param('uint32_t', 'threshold')],

  2120                    is_pure_virtual=True, visibility='private', is_virtual=True)

  2121     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetSSThresh() const [member function]

  2122     cls.add_method('GetSSThresh',

  2123                    'uint32_t',

  2124                    [],

  2125                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)

  2126     ## tcp-socket.h: void ns3::TcpSocket::SetInitialCwnd(uint32_t count) [member function]

  2127     cls.add_method('SetInitialCwnd',

  2128                    'void',

  2129                    [param('uint32_t', 'count')],

  2130                    is_pure_virtual=True, visibility='private', is_virtual=True)

  2131     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetInitialCwnd() const [member function]

  2132     cls.add_method('GetInitialCwnd',

  2133                    'uint32_t',

  2134                    [],

  2135                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)

  2136     ## tcp-socket.h: void ns3::TcpSocket::SetConnTimeout(ns3::Time timeout) [member function]

  2137     cls.add_method('SetConnTimeout',

  2138                    'void',

  2139                    [param('ns3::Time', 'timeout')],

  2140                    is_pure_virtual=True, visibility='private', is_virtual=True)

  2141     ## tcp-socket.h: ns3::Time ns3::TcpSocket::GetConnTimeout() const [member function]

  2142     cls.add_method('GetConnTimeout',

  2143                    'ns3::Time',

  2144                    [],

  2145                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)

  2146     ## tcp-socket.h: void ns3::TcpSocket::SetConnCount(uint32_t count) [member function]

  2147     cls.add_method('SetConnCount',

  2148                    'void',

  2149                    [param('uint32_t', 'count')],

  2150                    is_pure_virtual=True, visibility='private', is_virtual=True)

  2151     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetConnCount() const [member function]

  2152     cls.add_method('GetConnCount',

  2153                    'uint32_t',

  2154                    [],

  2155                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)

  2156     ## tcp-socket.h: void ns3::TcpSocket::SetDelAckTimeout(ns3::Time timeout) [member function]

  2157     cls.add_method('SetDelAckTimeout',

  2158                    'void',

  2159                    [param('ns3::Time', 'timeout')],

  2160                    is_pure_virtual=True, visibility='private', is_virtual=True)

  2161     ## tcp-socket.h: ns3::Time ns3::TcpSocket::GetDelAckTimeout() const [member function]

  2162     cls.add_method('GetDelAckTimeout',

  2163                    'ns3::Time',

  2164                    [],

  2165                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)

  2166     ## tcp-socket.h: void ns3::TcpSocket::SetDelAckMaxCount(uint32_t count) [member function]

  2167     cls.add_method('SetDelAckMaxCount',

  2168                    'void',

  2169                    [param('uint32_t', 'count')],

  2170                    is_pure_virtual=True, visibility='private', is_virtual=True)

  2171     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetDelAckMaxCount() const [member function]

  2172     cls.add_method('GetDelAckMaxCount',

  2173                    'uint32_t',

  2174                    [],

  2175                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)

  2176     return

  2178 def register_Ns3TcpSocketFactory_methods(root_module, cls):

  2179     ## tcp-socket-factory.h: ns3::TcpSocketFactory::TcpSocketFactory(ns3::TcpSocketFactory const & arg0) [copy constructor]

  2180     cls.add_constructor([param('ns3::TcpSocketFactory const &', 'arg0')])

  2181     ## tcp-socket-factory.h: ns3::TcpSocketFactory::TcpSocketFactory() [constructor]

  2182     cls.add_constructor([])

  2183     ## tcp-socket-factory.h: static ns3::TypeId ns3::TcpSocketFactory::GetTypeId() [member function]

  2184     cls.add_method('GetTypeId',

  2185                    'ns3::TypeId',

  2186                    [],

  2187                    is_static=True)

  2188     return

  2190 def register_Ns3UdpSocket_methods(root_module, cls):

  2191     ## udp-socket.h: ns3::UdpSocket::UdpSocket(ns3::UdpSocket const & arg0) [copy constructor]

  2192     cls.add_constructor([param('ns3::UdpSocket const &', 'arg0')])

  2193     ## udp-socket.h: static ns3::TypeId ns3::UdpSocket::GetTypeId() [member function]

  2194     cls.add_method('GetTypeId',

  2195                    'ns3::TypeId',

  2196                    [],

  2197                    is_static=True)

  2198     ## udp-socket.h: ns3::UdpSocket::UdpSocket() [constructor]

  2199     cls.add_constructor([])

  2200     ## udp-socket.h: int ns3::UdpSocket::MulticastJoinGroup(uint32_t interface, ns3::Address const & groupAddress) [member function]

  2201     cls.add_method('MulticastJoinGroup',

  2202                    'int',

  2203                    [param('uint32_t', 'interface'), param('ns3::Address const &', 'groupAddress')],

  2204                    is_pure_virtual=True, is_virtual=True)

  2205     ## udp-socket.h: int ns3::UdpSocket::MulticastLeaveGroup(uint32_t interface, ns3::Address const & groupAddress) [member function]

  2206     cls.add_method('MulticastLeaveGroup',

  2207                    'int',

  2208                    [param('uint32_t', 'interface'), param('ns3::Address const &', 'groupAddress')],

  2209                    is_pure_virtual=True, is_virtual=True)

  2210     ## udp-socket.h: void ns3::UdpSocket::SetRcvBufSize(uint32_t size) [member function]

  2211     cls.add_method('SetRcvBufSize',

  2212                    'void',

  2213                    [param('uint32_t', 'size')],

  2214                    is_pure_virtual=True, visibility='private', is_virtual=True)

  2215     ## udp-socket.h: uint32_t ns3::UdpSocket::GetRcvBufSize() const [member function]

  2216     cls.add_method('GetRcvBufSize',

  2217                    'uint32_t',

  2218                    [],

  2219                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)

  2220     ## udp-socket.h: void ns3::UdpSocket::SetIpTtl(uint8_t ipTtl) [member function]

  2221     cls.add_method('SetIpTtl',

  2222                    'void',

  2223                    [param('uint8_t', 'ipTtl')],

  2224                    is_pure_virtual=True, visibility='private', is_virtual=True)

  2225     ## udp-socket.h: uint8_t ns3::UdpSocket::GetIpTtl() const [member function]

  2226     cls.add_method('GetIpTtl',

  2227                    'uint8_t',

  2228                    [],

  2229                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)

  2230     ## udp-socket.h: void ns3::UdpSocket::SetIpMulticastTtl(uint8_t ipTtl) [member function]

  2231     cls.add_method('SetIpMulticastTtl',

  2232                    'void',

  2233                    [param('uint8_t', 'ipTtl')],

  2234                    is_pure_virtual=True, visibility='private', is_virtual=True)

  2235     ## udp-socket.h: uint8_t ns3::UdpSocket::GetIpMulticastTtl() const [member function]

  2236     cls.add_method('GetIpMulticastTtl',

  2237                    'uint8_t',

  2238                    [],

  2239                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)

  2240     ## udp-socket.h: void ns3::UdpSocket::SetIpMulticastIf(int32_t ipIf) [member function]

  2241     cls.add_method('SetIpMulticastIf',

  2242                    'void',

  2243                    [param('int32_t', 'ipIf')],

  2244                    is_pure_virtual=True, visibility='private', is_virtual=True)

  2245     ## udp-socket.h: int32_t ns3::UdpSocket::GetIpMulticastIf() const [member function]

  2246     cls.add_method('GetIpMulticastIf',

  2247                    'int32_t',

  2248                    [],

  2249                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)

  2250     ## udp-socket.h: void ns3::UdpSocket::SetIpMulticastLoop(bool loop) [member function]

  2251     cls.add_method('SetIpMulticastLoop',

  2252                    'void',

  2253                    [param('bool', 'loop')],

  2254                    is_pure_virtual=True, visibility='private', is_virtual=True)

  2255     ## udp-socket.h: bool ns3::UdpSocket::GetIpMulticastLoop() const [member function]

  2256     cls.add_method('GetIpMulticastLoop',

  2257                    'bool',

  2258                    [],

  2259                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)

  2260     ## udp-socket.h: void ns3::UdpSocket::SetMtuDiscover(bool discover) [member function]

  2261     cls.add_method('SetMtuDiscover',

  2262                    'void',

  2263                    [param('bool', 'discover')],

  2264                    is_pure_virtual=True, visibility='private', is_virtual=True)

  2265     ## udp-socket.h: bool ns3::UdpSocket::GetMtuDiscover() const [member function]

  2266     cls.add_method('GetMtuDiscover',

  2267                    'bool',

  2268                    [],

  2269                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)

  2270     return

  2272 def register_Ns3UdpSocketFactory_methods(root_module, cls):

  2273     ## udp-socket-factory.h: ns3::UdpSocketFactory::UdpSocketFactory(ns3::UdpSocketFactory const & arg0) [copy constructor]

  2274     cls.add_constructor([param('ns3::UdpSocketFactory const &', 'arg0')])

  2275     ## udp-socket-factory.h: ns3::UdpSocketFactory::UdpSocketFactory() [constructor]

  2276     cls.add_constructor([])

  2277     ## udp-socket-factory.h: static ns3::TypeId ns3::UdpSocketFactory::GetTypeId() [member function]

  2278     cls.add_method('GetTypeId',

  2279                    'ns3::TypeId',

  2280                    [],

  2281                    is_static=True)

  2282     return

  2284 def register_Ns3AddressChecker_methods(root_module, cls):

  2285     ## address.h: ns3::AddressChecker::AddressChecker(ns3::AddressChecker const & arg0) [copy constructor]

  2286     cls.add_constructor([param('ns3::AddressChecker const &', 'arg0')])

  2287     ## address.h: ns3::AddressChecker::AddressChecker() [constructor]

  2288     cls.add_constructor([])

  2289     return

  2291 def register_Ns3AddressValue_methods(root_module, cls):

  2292     ## address.h: ns3::AddressValue::AddressValue(ns3::AddressValue const & arg0) [copy constructor]

  2293     cls.add_constructor([param('ns3::AddressValue const &', 'arg0')])

  2294     ## address.h: ns3::AddressValue::AddressValue() [constructor]

  2295     cls.add_constructor([])

  2296     ## address.h: ns3::AddressValue::AddressValue(ns3::Address const & value) [constructor]

  2297     cls.add_constructor([param('ns3::Address const &', 'value')])

  2298     ## address.h: void ns3::AddressValue::Set(ns3::Address const & value) [member function]

  2299     cls.add_method('Set',

  2300                    'void',

  2301                    [param('ns3::Address const &', 'value')])

  2302     ## address.h: ns3::Address ns3::AddressValue::Get() const [member function]

  2303     cls.add_method('Get',

  2304                    'ns3::Address',

  2305                    [],

  2306                    is_const=True)

  2307     ## address.h: ns3::Ptr<ns3::AttributeValue> ns3::AddressValue::Copy() const [member function]

  2308     cls.add_method('Copy',

  2309                    'ns3::Ptr< ns3::AttributeValue >',

  2310                    [],

  2311                    is_const=True, is_virtual=True)

  2312     ## address.h: std::string ns3::AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

  2313     cls.add_method('SerializeToString',

  2314                    'std::string',

  2315                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],

  2316                    is_const=True, is_virtual=True)

  2317     ## address.h: bool ns3::AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

  2318     cls.add_method('DeserializeFromString',

  2319                    'bool',

  2320                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],

  2321                    is_virtual=True)

  2322     return

  2324 def register_Ns3Application_methods(root_module, cls):

  2325     ## application.h: ns3::Application::Application(ns3::Application const & arg0) [copy constructor]

  2326     cls.add_constructor([param('ns3::Application const &', 'arg0')])

  2327     ## application.h: static ns3::TypeId ns3::Application::GetTypeId() [member function]

  2328     cls.add_method('GetTypeId',

  2329                    'ns3::TypeId',

  2330                    [],

  2331                    is_static=True)

  2332     ## application.h: ns3::Application::Application() [constructor]

  2333     cls.add_constructor([])

  2334     ## application.h: void ns3::Application::Start(ns3::Time const & startTime) [member function]

  2335     cls.add_method('Start',

  2336                    'void',

  2337                    [param('ns3::Time const &', 'startTime')])

  2338     ## application.h: void ns3::Application::Start(ns3::RandomVariable const & startVariable) [member function]

  2339     cls.add_method('Start',

  2340                    'void',

  2341                    [param('ns3::RandomVariable const &', 'startVariable')])

  2342     ## application.h: void ns3::Application::Stop(ns3::Time const & stopTime) [member function]

  2343     cls.add_method('Stop',

  2344                    'void',

  2345                    [param('ns3::Time const &', 'stopTime')])

  2346     ## application.h: void ns3::Application::Stop(ns3::RandomVariable const & stopVariable) [member function]

  2347     cls.add_method('Stop',

  2348                    'void',

  2349                    [param('ns3::RandomVariable const &', 'stopVariable')])

  2350     ## application.h: ns3::Ptr<ns3::Node> ns3::Application::GetNode() const [member function]

  2351     cls.add_method('GetNode',

  2352                    'ns3::Ptr< ns3::Node >',

  2353                    [],

  2354                    is_const=True)

  2355     ## application.h: void ns3::Application::SetNode(ns3::Ptr<ns3::Node> node) [member function]

  2356     cls.add_method('SetNode',

  2357                    'void',

  2358                    [param('ns3::Ptr< ns3::Node >', 'node')])

  2359     ## application.h: void ns3::Application::DoDispose() [member function]

  2360     cls.add_method('DoDispose',

  2361                    'void',

  2362                    [],

  2363                    visibility='protected', is_virtual=True)

  2364     ## application.h: void ns3::Application::StartApplication() [member function]

  2365     cls.add_method('StartApplication',

  2366                    'void',

  2367                    [],

  2368                    visibility='private', is_virtual=True)

  2369     ## application.h: void ns3::Application::StopApplication() [member function]

  2370     cls.add_method('StopApplication',

  2371                    'void',

  2372                    [],

  2373                    visibility='private', is_virtual=True)

  2374     return

  2376 def register_Ns3Channel_methods(root_module, cls):

  2377     ## channel.h: ns3::Channel::Channel(ns3::Channel const & arg0) [copy constructor]

  2378     cls.add_constructor([param('ns3::Channel const &', 'arg0')])

  2379     ## channel.h: static ns3::TypeId ns3::Channel::GetTypeId() [member function]

  2380     cls.add_method('GetTypeId',

  2381                    'ns3::TypeId',

  2382                    [],

  2383                    is_static=True)

  2384     ## channel.h: ns3::Channel::Channel() [constructor]

  2385     cls.add_constructor([])

  2386     ## channel.h: uint32_t ns3::Channel::GetNDevices() const [member function]

  2387     cls.add_method('GetNDevices',

  2388                    'uint32_t',

  2389                    [],

  2390                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2391     ## channel.h: ns3::Ptr<ns3::NetDevice> ns3::Channel::GetDevice(uint32_t i) const [member function]

  2392     cls.add_method('GetDevice',

  2393                    'ns3::Ptr< ns3::NetDevice >',

  2394                    [param('uint32_t', 'i')],

  2395                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2396     return

  2398 def register_Ns3DropTailQueue_methods(root_module, cls):

  2399     ## drop-tail-queue.h: ns3::DropTailQueue::DropTailQueue(ns3::DropTailQueue const & arg0) [copy constructor]

  2400     cls.add_constructor([param('ns3::DropTailQueue const &', 'arg0')])

  2401     ## drop-tail-queue.h: static ns3::TypeId ns3::DropTailQueue::GetTypeId() [member function]

  2402     cls.add_method('GetTypeId',

  2403                    'ns3::TypeId',

  2404                    [],

  2405                    is_static=True)

  2406     ## drop-tail-queue.h: ns3::DropTailQueue::DropTailQueue() [constructor]

  2407     cls.add_constructor([])

  2408     ## drop-tail-queue.h: void ns3::DropTailQueue::SetMode(ns3::DropTailQueue::Mode mode) [member function]

  2409     cls.add_method('SetMode',

  2410                    'void',

  2411                    [param('ns3::DropTailQueue::Mode', 'mode')])

  2412     ## drop-tail-queue.h: ns3::DropTailQueue::Mode ns3::DropTailQueue::GetMode() [member function]

  2413     cls.add_method('GetMode',

  2414                    'ns3::DropTailQueue::Mode',

  2415                    [])

  2416     ## drop-tail-queue.h: bool ns3::DropTailQueue::DoEnqueue(ns3::Ptr<ns3::Packet> p) [member function]

  2417     cls.add_method('DoEnqueue',

  2418                    'bool',

  2419                    [param('ns3::Ptr< ns3::Packet >', 'p')],

  2420                    visibility='private', is_virtual=True)

  2421     ## drop-tail-queue.h: ns3::Ptr<ns3::Packet> ns3::DropTailQueue::DoDequeue() [member function]

  2422     cls.add_method('DoDequeue',

  2423                    'ns3::Ptr< ns3::Packet >',

  2424                    [],

  2425                    visibility='private', is_virtual=True)

  2426     ## drop-tail-queue.h: ns3::Ptr<ns3::Packet const> ns3::DropTailQueue::DoPeek() const [member function]

  2427     cls.add_method('DoPeek',

  2428                    'ns3::Ptr< ns3::Packet const >',

  2429                    [],

  2430                    is_const=True, visibility='private', is_virtual=True)

  2431     return

  2433 def register_Ns3EthernetHeader_methods(root_module, cls):

  2434     ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader(ns3::EthernetHeader const & arg0) [copy constructor]

  2435     cls.add_constructor([param('ns3::EthernetHeader const &', 'arg0')])

  2436     ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader(bool hasPreamble) [constructor]

  2437     cls.add_constructor([param('bool', 'hasPreamble')])

  2438     ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader() [constructor]

  2439     cls.add_constructor([])

  2440     ## ethernet-header.h: void ns3::EthernetHeader::SetLengthType(uint16_t size) [member function]

  2441     cls.add_method('SetLengthType',

  2442                    'void',

  2443                    [param('uint16_t', 'size')])

  2444     ## ethernet-header.h: void ns3::EthernetHeader::SetSource(ns3::Mac48Address source) [member function]

  2445     cls.add_method('SetSource',

  2446                    'void',

  2447                    [param('ns3::Mac48Address', 'source')])

  2448     ## ethernet-header.h: void ns3::EthernetHeader::SetDestination(ns3::Mac48Address destination) [member function]

  2449     cls.add_method('SetDestination',

  2450                    'void',

  2451                    [param('ns3::Mac48Address', 'destination')])

  2452     ## ethernet-header.h: void ns3::EthernetHeader::SetPreambleSfd(uint64_t preambleSfd) [member function]

  2453     cls.add_method('SetPreambleSfd',

  2454                    'void',

  2455                    [param('uint64_t', 'preambleSfd')])

  2456     ## ethernet-header.h: uint16_t ns3::EthernetHeader::GetLengthType() const [member function]

  2457     cls.add_method('GetLengthType',

  2458                    'uint16_t',

  2459                    [],

  2460                    is_const=True)

  2461     ## ethernet-header.h: ns3::ethernet_header_t ns3::EthernetHeader::GetPacketType() const [member function]

  2462     cls.add_method('GetPacketType',

  2463                    'ns3::ethernet_header_t',

  2464                    [],

  2465                    is_const=True)

  2466     ## ethernet-header.h: ns3::Mac48Address ns3::EthernetHeader::GetSource() const [member function]

  2467     cls.add_method('GetSource',

  2468                    'ns3::Mac48Address',

  2469                    [],

  2470                    is_const=True)

  2471     ## ethernet-header.h: ns3::Mac48Address ns3::EthernetHeader::GetDestination() const [member function]

  2472     cls.add_method('GetDestination',

  2473                    'ns3::Mac48Address',

  2474                    [],

  2475                    is_const=True)

  2476     ## ethernet-header.h: uint64_t ns3::EthernetHeader::GetPreambleSfd() const [member function]

  2477     cls.add_method('GetPreambleSfd',

  2478                    'uint64_t',

  2479                    [],

  2480                    is_const=True)

  2481     ## ethernet-header.h: uint32_t ns3::EthernetHeader::GetHeaderSize() const [member function]

  2482     cls.add_method('GetHeaderSize',

  2483                    'uint32_t',

  2484                    [],

  2485                    is_const=True)

  2486     ## ethernet-header.h: static ns3::TypeId ns3::EthernetHeader::GetTypeId() [member function]

  2487     cls.add_method('GetTypeId',

  2488                    'ns3::TypeId',

  2489                    [],

  2490                    is_static=True)

  2491     ## ethernet-header.h: ns3::TypeId ns3::EthernetHeader::GetInstanceTypeId() const [member function]

  2492     cls.add_method('GetInstanceTypeId',

  2493                    'ns3::TypeId',

  2494                    [],

  2495                    is_const=True, is_virtual=True)

  2496     ## ethernet-header.h: void ns3::EthernetHeader::Print(std::ostream & os) const [member function]

  2497     cls.add_method('Print',

  2498                    'void',

  2499                    [param('std::ostream &', 'os')],

  2500                    is_const=True, is_virtual=True)

  2501     ## ethernet-header.h: uint32_t ns3::EthernetHeader::GetSerializedSize() const [member function]

  2502     cls.add_method('GetSerializedSize',

  2503                    'uint32_t',

  2504                    [],

  2505                    is_const=True, is_virtual=True)

  2506     ## ethernet-header.h: void ns3::EthernetHeader::Serialize(ns3::Buffer::Iterator start) const [member function]

  2507     cls.add_method('Serialize',

  2508                    'void',

  2509                    [param('ns3::Buffer::Iterator', 'start')],

  2510                    is_const=True, is_virtual=True)

  2511     ## ethernet-header.h: uint32_t ns3::EthernetHeader::Deserialize(ns3::Buffer::Iterator start) [member function]

  2512     cls.add_method('Deserialize',

  2513                    'uint32_t',

  2514                    [param('ns3::Buffer::Iterator', 'start')],

  2515                    is_virtual=True)

  2516     return

  2518 def register_Ns3EthernetTrailer_methods(root_module, cls):

  2519     ## ethernet-trailer.h: ns3::EthernetTrailer::EthernetTrailer(ns3::EthernetTrailer const & arg0) [copy constructor]

  2520     cls.add_constructor([param('ns3::EthernetTrailer const &', 'arg0')])

  2521     ## ethernet-trailer.h: ns3::EthernetTrailer::EthernetTrailer() [constructor]

  2522     cls.add_constructor([])

  2523     ## ethernet-trailer.h: static void ns3::EthernetTrailer::EnableFcs(bool enable) [member function]

  2524     cls.add_method('EnableFcs',

  2525                    'void',

  2526                    [param('bool', 'enable')],

  2527                    is_static=True)

  2528     ## ethernet-trailer.h: void ns3::EthernetTrailer::CalcFcs(ns3::Ptr<ns3::Packet> p) [member function]

  2529     cls.add_method('CalcFcs',

  2530                    'void',

  2531                    [param('ns3::Ptr< ns3::Packet >', 'p')])

  2532     ## ethernet-trailer.h: void ns3::EthernetTrailer::SetFcs(uint32_t fcs) [member function]

  2533     cls.add_method('SetFcs',

  2534                    'void',

  2535                    [param('uint32_t', 'fcs')])

  2536     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::GetFcs() [member function]

  2537     cls.add_method('GetFcs',

  2538                    'uint32_t',

  2539                    [])

  2540     ## ethernet-trailer.h: bool ns3::EthernetTrailer::CheckFcs(ns3::Ptr<ns3::Packet> p) const [member function]

  2541     cls.add_method('CheckFcs',

  2542                    'bool',

  2543                    [param('ns3::Ptr< ns3::Packet >', 'p')],

  2544                    is_const=True)

  2545     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::GetTrailerSize() const [member function]

  2546     cls.add_method('GetTrailerSize',

  2547                    'uint32_t',

  2548                    [],

  2549                    is_const=True)

  2550     ## ethernet-trailer.h: static ns3::TypeId ns3::EthernetTrailer::GetTypeId() [member function]

  2551     cls.add_method('GetTypeId',

  2552                    'ns3::TypeId',

  2553                    [],

  2554                    is_static=True)

  2555     ## ethernet-trailer.h: ns3::TypeId ns3::EthernetTrailer::GetInstanceTypeId() const [member function]

  2556     cls.add_method('GetInstanceTypeId',

  2557                    'ns3::TypeId',

  2558                    [],

  2559                    is_const=True, is_virtual=True)

  2560     ## ethernet-trailer.h: void ns3::EthernetTrailer::Print(std::ostream & os) const [member function]

  2561     cls.add_method('Print',

  2562                    'void',

  2563                    [param('std::ostream &', 'os')],

  2564                    is_const=True, is_virtual=True)

  2565     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::GetSerializedSize() const [member function]

  2566     cls.add_method('GetSerializedSize',

  2567                    'uint32_t',

  2568                    [],

  2569                    is_const=True, is_virtual=True)

  2570     ## ethernet-trailer.h: void ns3::EthernetTrailer::Serialize(ns3::Buffer::Iterator end) const [member function]

  2571     cls.add_method('Serialize',

  2572                    'void',

  2573                    [param('ns3::Buffer::Iterator', 'end')],

  2574                    is_const=True, is_virtual=True)

  2575     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::Deserialize(ns3::Buffer::Iterator end) [member function]

  2576     cls.add_method('Deserialize',

  2577                    'uint32_t',

  2578                    [param('ns3::Buffer::Iterator', 'end')],

  2579                    is_virtual=True)

  2580     return

  2582 def register_Ns3Ipv4_methods(root_module, cls):

  2583     ## ipv4.h: ns3::Ipv4::IF_ANY [variable]

  2584     cls.add_static_attribute('IF_ANY', 'uint32_t const', is_const=True)

  2585     ## ipv4.h: ns3::Ipv4::Ipv4(ns3::Ipv4 const & arg0) [copy constructor]

  2586     cls.add_constructor([param('ns3::Ipv4 const &', 'arg0')])

  2587     ## ipv4.h: static ns3::TypeId ns3::Ipv4::GetTypeId() [member function]

  2588     cls.add_method('GetTypeId',

  2589                    'ns3::TypeId',

  2590                    [],

  2591                    is_static=True)

  2592     ## ipv4.h: ns3::Ipv4::Ipv4() [constructor]

  2593     cls.add_constructor([])

  2594     ## ipv4.h: void ns3::Ipv4::SetRoutingProtocol(ns3::Ptr<ns3::Ipv4RoutingProtocol> routingProtocol) [member function]

  2595     cls.add_method('SetRoutingProtocol',

  2596                    'void',

  2597                    [param('ns3::Ptr< ns3::Ipv4RoutingProtocol >', 'routingProtocol')],

  2598                    is_pure_virtual=True, is_virtual=True)

  2599     ## ipv4.h: ns3::Ptr<ns3::Ipv4RoutingProtocol> ns3::Ipv4::GetRoutingProtocol() const [member function]

  2600     cls.add_method('GetRoutingProtocol',

  2601                    'ns3::Ptr< ns3::Ipv4RoutingProtocol >',

  2602                    [],

  2603                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2604     ## ipv4.h: uint32_t ns3::Ipv4::AddInterface(ns3::Ptr<ns3::NetDevice> device) [member function]

  2605     cls.add_method('AddInterface',

  2606                    'uint32_t',

  2607                    [param('ns3::Ptr< ns3::NetDevice >', 'device')],

  2608                    is_pure_virtual=True, is_virtual=True)

  2609     ## ipv4.h: uint32_t ns3::Ipv4::GetNInterfaces() const [member function]

  2610     cls.add_method('GetNInterfaces',

  2611                    'uint32_t',

  2612                    [],

  2613                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2614     ## ipv4.h: int32_t ns3::Ipv4::GetInterfaceForAddress(ns3::Ipv4Address address) const [member function]

  2615     cls.add_method('GetInterfaceForAddress',

  2616                    'int32_t',

  2617                    [param('ns3::Ipv4Address', 'address')],

  2618                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2619     ## ipv4.h: int32_t ns3::Ipv4::GetInterfaceForPrefix(ns3::Ipv4Address address, ns3::Ipv4Mask mask) const [member function]

  2620     cls.add_method('GetInterfaceForPrefix',

  2621                    'int32_t',

  2622                    [param('ns3::Ipv4Address', 'address'), param('ns3::Ipv4Mask', 'mask')],

  2623                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2624     ## ipv4.h: ns3::Ptr<ns3::NetDevice> ns3::Ipv4::GetNetDevice(uint32_t interface) [member function]

  2625     cls.add_method('GetNetDevice',

  2626                    'ns3::Ptr< ns3::NetDevice >',

  2627                    [param('uint32_t', 'interface')],

  2628                    is_pure_virtual=True, is_virtual=True)

  2629     ## ipv4.h: int32_t ns3::Ipv4::GetInterfaceForDevice(ns3::Ptr<const ns3::NetDevice> device) const [member function]

  2630     cls.add_method('GetInterfaceForDevice',

  2631                    'int32_t',

  2632                    [param('ns3::Ptr< ns3::NetDevice const >', 'device')],

  2633                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2634     ## ipv4.h: bool ns3::Ipv4::AddAddress(uint32_t interface, ns3::Ipv4InterfaceAddress address) [member function]

  2635     cls.add_method('AddAddress',

  2636                    'bool',

  2637                    [param('uint32_t', 'interface'), param('ns3::Ipv4InterfaceAddress', 'address')],

  2638                    is_pure_virtual=True, is_virtual=True)

  2639     ## ipv4.h: uint32_t ns3::Ipv4::GetNAddresses(uint32_t interface) const [member function]

  2640     cls.add_method('GetNAddresses',

  2641                    'uint32_t',

  2642                    [param('uint32_t', 'interface')],

  2643                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2644     ## ipv4.h: ns3::Ipv4InterfaceAddress ns3::Ipv4::GetAddress(uint32_t interface, uint32_t addressIndex) const [member function]

  2645     cls.add_method('GetAddress',

  2646                    'ns3::Ipv4InterfaceAddress',

  2647                    [param('uint32_t', 'interface'), param('uint32_t', 'addressIndex')],

  2648                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2649     ## ipv4.h: bool ns3::Ipv4::RemoveAddress(uint32_t interface, uint32_t addressIndex) [member function]

  2650     cls.add_method('RemoveAddress',

  2651                    'bool',

  2652                    [param('uint32_t', 'interface'), param('uint32_t', 'addressIndex')],

  2653                    is_pure_virtual=True, is_virtual=True)

  2654     ## ipv4.h: void ns3::Ipv4::SetMetric(uint32_t interface, uint16_t metric) [member function]

  2655     cls.add_method('SetMetric',

  2656                    'void',

  2657                    [param('uint32_t', 'interface'), param('uint16_t', 'metric')],

  2658                    is_pure_virtual=True, is_virtual=True)

  2659     ## ipv4.h: uint16_t ns3::Ipv4::GetMetric(uint32_t interface) const [member function]

  2660     cls.add_method('GetMetric',

  2661                    'uint16_t',

  2662                    [param('uint32_t', 'interface')],

  2663                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2664     ## ipv4.h: uint16_t ns3::Ipv4::GetMtu(uint32_t interface) const [member function]

  2665     cls.add_method('GetMtu',

  2666                    'uint16_t',

  2667                    [param('uint32_t', 'interface')],

  2668                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2669     ## ipv4.h: bool ns3::Ipv4::IsUp(uint32_t interface) const [member function]

  2670     cls.add_method('IsUp',

  2671                    'bool',

  2672                    [param('uint32_t', 'interface')],

  2673                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2674     ## ipv4.h: void ns3::Ipv4::SetUp(uint32_t interface) [member function]

  2675     cls.add_method('SetUp',

  2676                    'void',

  2677                    [param('uint32_t', 'interface')],

  2678                    is_pure_virtual=True, is_virtual=True)

  2679     ## ipv4.h: void ns3::Ipv4::SetDown(uint32_t interface) [member function]

  2680     cls.add_method('SetDown',

  2681                    'void',

  2682                    [param('uint32_t', 'interface')],

  2683                    is_pure_virtual=True, is_virtual=True)

  2684     ## ipv4.h: bool ns3::Ipv4::IsForwarding(uint32_t interface) const [member function]

  2685     cls.add_method('IsForwarding',

  2686                    'bool',

  2687                    [param('uint32_t', 'interface')],

  2688                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2689     ## ipv4.h: void ns3::Ipv4::SetForwarding(uint32_t interface, bool val) [member function]

  2690     cls.add_method('SetForwarding',

  2691                    'void',

  2692                    [param('uint32_t', 'interface'), param('bool', 'val')],

  2693                    is_pure_virtual=True, is_virtual=True)

  2694     ## ipv4.h: void ns3::Ipv4::SetIpForward(bool forward) [member function]

  2695     cls.add_method('SetIpForward',

  2696                    'void',

  2697                    [param('bool', 'forward')],

  2698                    is_pure_virtual=True, visibility='private', is_virtual=True)

  2699     ## ipv4.h: bool ns3::Ipv4::GetIpForward() const [member function]

  2700     cls.add_method('GetIpForward',

  2701                    'bool',

  2702                    [],

  2703                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)

  2704     return

  2706 def register_Ns3Ipv4RawSocketFactory_methods(root_module, cls):

  2707     ## ipv4-raw-socket-factory.h: ns3::Ipv4RawSocketFactory::Ipv4RawSocketFactory(ns3::Ipv4RawSocketFactory const & arg0) [copy constructor]

  2708     cls.add_constructor([param('ns3::Ipv4RawSocketFactory const &', 'arg0')])

  2709     ## ipv4-raw-socket-factory.h: ns3::Ipv4RawSocketFactory::Ipv4RawSocketFactory() [constructor]

  2710     cls.add_constructor([])

  2711     ## ipv4-raw-socket-factory.h: static ns3::TypeId ns3::Ipv4RawSocketFactory::GetTypeId() [member function]

  2712     cls.add_method('GetTypeId',

  2713                    'ns3::TypeId',

  2714                    [],

  2715                    is_static=True)

  2716     return

  2718 def register_Ns3Ipv4RoutingProtocol_methods(root_module, cls):

  2719     ## ipv4-routing-protocol.h: ns3::Ipv4RoutingProtocol::Ipv4RoutingProtocol(ns3::Ipv4RoutingProtocol const & arg0) [copy constructor]

  2720     cls.add_constructor([param('ns3::Ipv4RoutingProtocol const &', 'arg0')])

  2721     ## ipv4-routing-protocol.h: ns3::Ipv4RoutingProtocol::Ipv4RoutingProtocol() [constructor]

  2722     cls.add_constructor([])

  2723     ## ipv4-routing-protocol.h: static ns3::TypeId ns3::Ipv4RoutingProtocol::GetTypeId() [member function]

  2724     cls.add_method('GetTypeId',

  2725                    'ns3::TypeId',

  2726                    [],

  2727                    is_static=True)

  2728     ## ipv4-routing-protocol.h: ns3::Ptr<ns3::Ipv4Route> ns3::Ipv4RoutingProtocol::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Header const & header, uint32_t oif, ns3::Socket::SocketErrno & sockerr) [member function]

  2729     cls.add_method('RouteOutput',

  2730                    'ns3::Ptr< ns3::Ipv4Route >',

  2731                    [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('uint32_t', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')],

  2732                    is_pure_virtual=True, is_virtual=True)

  2733     ## ipv4-routing-protocol.h: bool ns3::Ipv4RoutingProtocol::RouteInput(ns3::Ptr<ns3::Packet const> p, ns3::Ipv4Header const & header, ns3::Ptr<const ns3::NetDevice> idev, ns3::Callback<void,ns3::Ptr<ns3::Ipv4Route>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ucb, ns3::Callback<void,ns3::Ptr<ns3::Ipv4MulticastRoute>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> mcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,unsigned int,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> lcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::Socket::SocketErrno,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ecb) [member function]

  2734     cls.add_method('RouteInput',

  2735                    'bool',

  2736                    [param('ns3::Ptr< ns3::Packet const >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice const >', 'idev'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv4Route >, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ucb'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv4MulticastRoute >, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'mcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'lcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::Socket::SocketErrno, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ecb')],

  2737                    is_pure_virtual=True, is_virtual=True)

  2738     ## ipv4-routing-protocol.h: void ns3::Ipv4RoutingProtocol::NotifyInterfaceUp(uint32_t interface) [member function]

  2739     cls.add_method('NotifyInterfaceUp',

  2740                    'void',

  2741                    [param('uint32_t', 'interface')],

  2742                    is_pure_virtual=True, is_virtual=True)

  2743     ## ipv4-routing-protocol.h: void ns3::Ipv4RoutingProtocol::NotifyInterfaceDown(uint32_t interface) [member function]

  2744     cls.add_method('NotifyInterfaceDown',

  2745                    'void',

  2746                    [param('uint32_t', 'interface')],

  2747                    is_pure_virtual=True, is_virtual=True)

  2748     ## ipv4-routing-protocol.h: void ns3::Ipv4RoutingProtocol::NotifyAddAddress(uint32_t interface, ns3::Ipv4InterfaceAddress address) [member function]

  2749     cls.add_method('NotifyAddAddress',

  2750                    'void',

  2751                    [param('uint32_t', 'interface'), param('ns3::Ipv4InterfaceAddress', 'address')],

  2752                    is_pure_virtual=True, is_virtual=True)

  2753     ## ipv4-routing-protocol.h: void ns3::Ipv4RoutingProtocol::NotifyRemoveAddress(uint32_t interface, ns3::Ipv4InterfaceAddress address) [member function]

  2754     cls.add_method('NotifyRemoveAddress',

  2755                    'void',

  2756                    [param('uint32_t', 'interface'), param('ns3::Ipv4InterfaceAddress', 'address')],

  2757                    is_pure_virtual=True, is_virtual=True)

  2758     ## ipv4-routing-protocol.h: void ns3::Ipv4RoutingProtocol::SetIpv4(ns3::Ptr<ns3::Ipv4> ipv4) [member function]

  2759     cls.add_method('SetIpv4',

  2760                    'void',

  2761                    [param('ns3::Ptr< ns3::Ipv4 >', 'ipv4')],

  2762                    is_pure_virtual=True, is_virtual=True)

  2763     return

  2765 def register_Ns3NetDevice_methods(root_module, cls):

  2766     ## net-device.h: ns3::NetDevice::NetDevice(ns3::NetDevice const & arg0) [copy constructor]

  2767     cls.add_constructor([param('ns3::NetDevice const &', 'arg0')])

  2768     ## net-device.h: ns3::NetDevice::NetDevice() [constructor]

  2769     cls.add_constructor([])

  2770     ## net-device.h: static ns3::TypeId ns3::NetDevice::GetTypeId() [member function]

  2771     cls.add_method('GetTypeId',

  2772                    'ns3::TypeId',

  2773                    [],

  2774                    is_static=True)

  2775     ## net-device.h: void ns3::NetDevice::SetIfIndex(uint32_t const index) [member function]

  2776     cls.add_method('SetIfIndex',

  2777                    'void',

  2778                    [param('uint32_t const', 'index')],

  2779                    is_pure_virtual=True, is_virtual=True)

  2780     ## net-device.h: uint32_t ns3::NetDevice::GetIfIndex() const [member function]

  2781     cls.add_method('GetIfIndex',

  2782                    'uint32_t',

  2783                    [],

  2784                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2785     ## net-device.h: ns3::Ptr<ns3::Channel> ns3::NetDevice::GetChannel() const [member function]

  2786     cls.add_method('GetChannel',

  2787                    'ns3::Ptr< ns3::Channel >',

  2788                    [],

  2789                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2790     ## net-device.h: void ns3::NetDevice::SetAddress(ns3::Address address) [member function]

  2791     cls.add_method('SetAddress',

  2792                    'void',

  2793                    [param('ns3::Address', 'address')],

  2794                    is_pure_virtual=True, is_virtual=True)

  2795     ## net-device.h: ns3::Address ns3::NetDevice::GetAddress() const [member function]

  2796     cls.add_method('GetAddress',

  2797                    'ns3::Address',

  2798                    [],

  2799                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2800     ## net-device.h: bool ns3::NetDevice::SetMtu(uint16_t const mtu) [member function]

  2801     cls.add_method('SetMtu',

  2802                    'bool',

  2803                    [param('uint16_t const', 'mtu')],

  2804                    is_pure_virtual=True, is_virtual=True)

  2805     ## net-device.h: uint16_t ns3::NetDevice::GetMtu() const [member function]

  2806     cls.add_method('GetMtu',

  2807                    'uint16_t',

  2808                    [],

  2809                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2810     ## net-device.h: bool ns3::NetDevice::IsLinkUp() const [member function]

  2811     cls.add_method('IsLinkUp',

  2812                    'bool',

  2813                    [],

  2814                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2815     ## net-device.h: void ns3::NetDevice::SetLinkChangeCallback(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function]

  2816     cls.add_method('SetLinkChangeCallback',

  2817                    'void',

  2818                    [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')],

  2819                    is_pure_virtual=True, is_virtual=True)

  2820     ## net-device.h: bool ns3::NetDevice::IsBroadcast() const [member function]

  2821     cls.add_method('IsBroadcast',

  2822                    'bool',

  2823                    [],

  2824                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2825     ## net-device.h: ns3::Address ns3::NetDevice::GetBroadcast() const [member function]

  2826     cls.add_method('GetBroadcast',

  2827                    'ns3::Address',

  2828                    [],

  2829                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2830     ## net-device.h: bool ns3::NetDevice::IsMulticast() const [member function]

  2831     cls.add_method('IsMulticast',

  2832                    'bool',

  2833                    [],

  2834                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2835     ## net-device.h: ns3::Address ns3::NetDevice::GetMulticast(ns3::Ipv4Address multicastGroup) const [member function]

  2836     cls.add_method('GetMulticast',

  2837                    'ns3::Address',

  2838                    [param('ns3::Ipv4Address', 'multicastGroup')],

  2839                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2840     ## net-device.h: ns3::Address ns3::NetDevice::GetMulticast(ns3::Ipv6Address addr) const [member function]

  2841     cls.add_method('GetMulticast',

  2842                    'ns3::Address',

  2843                    [param('ns3::Ipv6Address', 'addr')],

  2844                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2845     ## net-device.h: bool ns3::NetDevice::IsBridge() const [member function]

  2846     cls.add_method('IsBridge',

  2847                    'bool',

  2848                    [],

  2849                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2850     ## net-device.h: bool ns3::NetDevice::IsPointToPoint() const [member function]

  2851     cls.add_method('IsPointToPoint',

  2852                    'bool',

  2853                    [],

  2854                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2855     ## net-device.h: bool ns3::NetDevice::Send(ns3::Ptr<ns3::Packet> packet, ns3::Address const & dest, uint16_t protocolNumber) [member function]

  2856     cls.add_method('Send',

  2857                    'bool',

  2858                    [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')],

  2859                    is_pure_virtual=True, is_virtual=True)

  2860     ## net-device.h: bool ns3::NetDevice::SendFrom(ns3::Ptr<ns3::Packet> packet, ns3::Address const & source, ns3::Address const & dest, uint16_t protocolNumber) [member function]

  2861     cls.add_method('SendFrom',

  2862                    'bool',

  2863                    [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'source'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')],

  2864                    is_pure_virtual=True, is_virtual=True)

  2865     ## net-device.h: ns3::Ptr<ns3::Node> ns3::NetDevice::GetNode() const [member function]

  2866     cls.add_method('GetNode',

  2867                    'ns3::Ptr< ns3::Node >',

  2868                    [],

  2869                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2870     ## net-device.h: void ns3::NetDevice::SetNode(ns3::Ptr<ns3::Node> node) [member function]

  2871     cls.add_method('SetNode',

  2872                    'void',

  2873                    [param('ns3::Ptr< ns3::Node >', 'node')],

  2874                    is_pure_virtual=True, is_virtual=True)

  2875     ## net-device.h: bool ns3::NetDevice::NeedsArp() const [member function]

  2876     cls.add_method('NeedsArp',

  2877                    'bool',

  2878                    [],

  2879                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2880     ## net-device.h: void ns3::NetDevice::SetReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function]

  2881     cls.add_method('SetReceiveCallback',

  2882                    'void',

  2883                    [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')],

  2884                    is_pure_virtual=True, is_virtual=True)

  2885     ## net-device.h: void ns3::NetDevice::SetPromiscReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> cb) [member function]

  2886     cls.add_method('SetPromiscReceiveCallback',

  2887                    'void',

  2888                    [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'cb')],

  2889                    is_pure_virtual=True, is_virtual=True)

  2890     ## net-device.h: bool ns3::NetDevice::SupportsSendFrom() const [member function]

  2891     cls.add_method('SupportsSendFrom',

  2892                    'bool',

  2893                    [],

  2894                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2895     return

  2897 def register_Ns3Node_methods(root_module, cls):

  2898     ## node.h: ns3::Node::Node(ns3::Node const & arg0) [copy constructor]

  2899     cls.add_constructor([param('ns3::Node const &', 'arg0')])

  2900     ## node.h: static ns3::TypeId ns3::Node::GetTypeId() [member function]

  2901     cls.add_method('GetTypeId',

  2902                    'ns3::TypeId',

  2903                    [],

  2904                    is_static=True)

  2905     ## node.h: ns3::Node::Node() [constructor]

  2906     cls.add_constructor([])

  2907     ## node.h: ns3::Node::Node(uint32_t systemId) [constructor]

  2908     cls.add_constructor([param('uint32_t', 'systemId')])

  2909     ## node.h: uint32_t ns3::Node::GetId() const [member function]

  2910     cls.add_method('GetId',

  2911                    'uint32_t',

  2912                    [],

  2913                    is_const=True)

  2914     ## node.h: uint32_t ns3::Node::GetSystemId() const [member function]

  2915     cls.add_method('GetSystemId',

  2916                    'uint32_t',

  2917                    [],

  2918                    is_const=True)

  2919     ## node.h: uint32_t ns3::Node::AddDevice(ns3::Ptr<ns3::NetDevice> device) [member function]

  2920     cls.add_method('AddDevice',

  2921                    'uint32_t',

  2922                    [param('ns3::Ptr< ns3::NetDevice >', 'device')])

  2923     ## node.h: ns3::Ptr<ns3::NetDevice> ns3::Node::GetDevice(uint32_t index) const [member function]

  2924     cls.add_method('GetDevice',

  2925                    'ns3::Ptr< ns3::NetDevice >',

  2926                    [param('uint32_t', 'index')],

  2927                    is_const=True)

  2928     ## node.h: uint32_t ns3::Node::GetNDevices() const [member function]

  2929     cls.add_method('GetNDevices',

  2930                    'uint32_t',

  2931                    [],

  2932                    is_const=True)

  2933     ## node.h: uint32_t ns3::Node::AddApplication(ns3::Ptr<ns3::Application> application) [member function]

  2934     cls.add_method('AddApplication',

  2935                    'uint32_t',

  2936                    [param('ns3::Ptr< ns3::Application >', 'application')])

  2937     ## node.h: ns3::Ptr<ns3::Application> ns3::Node::GetApplication(uint32_t index) const [member function]

  2938     cls.add_method('GetApplication',

  2939                    'ns3::Ptr< ns3::Application >',

  2940                    [param('uint32_t', 'index')],

  2941                    is_const=True)

  2942     ## node.h: uint32_t ns3::Node::GetNApplications() const [member function]

  2943     cls.add_method('GetNApplications',

  2944                    'uint32_t',

  2945                    [],

  2946                    is_const=True)

  2947     ## node.h: void ns3::Node::RegisterProtocolHandler(ns3::Callback<void, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> handler, uint16_t protocolType, ns3::Ptr<ns3::NetDevice> device, bool promiscuous=false) [member function]

  2948     cls.add_method('RegisterProtocolHandler',

  2949                    'void',

  2950                    [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'handler'), param('uint16_t', 'protocolType'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'promiscuous', default_value='false')])

  2951     ## node.h: void ns3::Node::UnregisterProtocolHandler(ns3::Callback<void, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> handler) [member function]

  2952     cls.add_method('UnregisterProtocolHandler',

  2953                    'void',

  2954                    [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'handler')])

  2955     ## node.h: static bool ns3::Node::ChecksumEnabled() [member function]

  2956     cls.add_method('ChecksumEnabled',

  2957                    'bool',

  2958                    [],

  2959                    is_static=True)

  2960     ## node.h: void ns3::Node::DoDispose() [member function]

  2961     cls.add_method('DoDispose',

  2962                    'void',

  2963                    [],

  2964                    visibility='protected', is_virtual=True)

  2965     ## node.h: void ns3::Node::NotifyDeviceAdded(ns3::Ptr<ns3::NetDevice> device) [member function]

  2966     cls.add_method('NotifyDeviceAdded',

  2967                    'void',

  2968                    [param('ns3::Ptr< ns3::NetDevice >', 'device')],

  2969                    visibility='private', is_virtual=True)

  2970     return

  2972 def register_Ns3PacketSocketFactory_methods(root_module, cls):

  2973     ## packet-socket-factory.h: ns3::PacketSocketFactory::PacketSocketFactory(ns3::PacketSocketFactory const & arg0) [copy constructor]

  2974     cls.add_constructor([param('ns3::PacketSocketFactory const &', 'arg0')])

  2975     ## packet-socket-factory.h: static ns3::TypeId ns3::PacketSocketFactory::GetTypeId() [member function]

  2976     cls.add_method('GetTypeId',

  2977                    'ns3::TypeId',

  2978                    [],

  2979                    is_static=True)

  2980     ## packet-socket-factory.h: ns3::PacketSocketFactory::PacketSocketFactory() [constructor]

  2981     cls.add_constructor([])

  2982     ## packet-socket-factory.h: ns3::Ptr<ns3::Socket> ns3::PacketSocketFactory::CreateSocket() [member function]

  2983     cls.add_method('CreateSocket',

  2984                    'ns3::Ptr< ns3::Socket >',

  2985                    [],

  2986                    is_virtual=True)

  2987     return

  2989 def register_Ns3SimpleChannel_methods(root_module, cls):

  2990     ## simple-channel.h: ns3::SimpleChannel::SimpleChannel(ns3::SimpleChannel const & arg0) [copy constructor]

  2991     cls.add_constructor([param('ns3::SimpleChannel const &', 'arg0')])

  2992     ## simple-channel.h: static ns3::TypeId ns3::SimpleChannel::GetTypeId() [member function]

  2993     cls.add_method('GetTypeId',

  2994                    'ns3::TypeId',

  2995                    [],

  2996                    is_static=True)

  2997     ## simple-channel.h: ns3::SimpleChannel::SimpleChannel() [constructor]

  2998     cls.add_constructor([])

  2999     ## simple-channel.h: void ns3::SimpleChannel::Send(ns3::Ptr<ns3::Packet> p, uint16_t protocol, ns3::Mac48Address to, ns3::Mac48Address from, ns3::Ptr<ns3::SimpleNetDevice> sender) [member function]

  3000     cls.add_method('Send',

  3001                    'void',

  3002                    [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint16_t', 'protocol'), param('ns3::Mac48Address', 'to'), param('ns3::Mac48Address', 'from'), param('ns3::Ptr< ns3::SimpleNetDevice >', 'sender')])

  3003     ## simple-channel.h: void ns3::SimpleChannel::Add(ns3::Ptr<ns3::SimpleNetDevice> device) [member function]

  3004     cls.add_method('Add',

  3005                    'void',

  3006                    [param('ns3::Ptr< ns3::SimpleNetDevice >', 'device')])

  3007     ## simple-channel.h: uint32_t ns3::SimpleChannel::GetNDevices() const [member function]

  3008     cls.add_method('GetNDevices',

  3009                    'uint32_t',

  3010                    [],

  3011                    is_const=True, is_virtual=True)

  3012     ## simple-channel.h: ns3::Ptr<ns3::NetDevice> ns3::SimpleChannel::GetDevice(uint32_t i) const [member function]

  3013     cls.add_method('GetDevice',

  3014                    'ns3::Ptr< ns3::NetDevice >',

  3015                    [param('uint32_t', 'i')],

  3016                    is_const=True, is_virtual=True)

  3017     return

  3019 def register_Ns3SimpleNetDevice_methods(root_module, cls):

  3020     ## simple-net-device.h: ns3::SimpleNetDevice::SimpleNetDevice(ns3::SimpleNetDevice const & arg0) [copy constructor]

  3021     cls.add_constructor([param('ns3::SimpleNetDevice const &', 'arg0')])

  3022     ## simple-net-device.h: static ns3::TypeId ns3::SimpleNetDevice::GetTypeId() [member function]

  3023     cls.add_method('GetTypeId',

  3024                    'ns3::TypeId',

  3025                    [],

  3026                    is_static=True)

  3027     ## simple-net-device.h: ns3::SimpleNetDevice::SimpleNetDevice() [constructor]

  3028     cls.add_constructor([])

  3029     ## simple-net-device.h: void ns3::SimpleNetDevice::Receive(ns3::Ptr<ns3::Packet> packet, uint16_t protocol, ns3::Mac48Address to, ns3::Mac48Address from) [member function]

  3030     cls.add_method('Receive',

  3031                    'void',

  3032                    [param('ns3::Ptr< ns3::Packet >', 'packet'), param('uint16_t', 'protocol'), param('ns3::Mac48Address', 'to'), param('ns3::Mac48Address', 'from')])

  3033     ## simple-net-device.h: void ns3::SimpleNetDevice::SetChannel(ns3::Ptr<ns3::SimpleChannel> channel) [member function]

  3034     cls.add_method('SetChannel',

  3035                    'void',

  3036                    [param('ns3::Ptr< ns3::SimpleChannel >', 'channel')])

  3037     ## simple-net-device.h: void ns3::SimpleNetDevice::SetIfIndex(uint32_t const index) [member function]

  3038     cls.add_method('SetIfIndex',

  3039                    'void',

  3040                    [param('uint32_t const', 'index')],

  3041                    is_virtual=True)

  3042     ## simple-net-device.h: uint32_t ns3::SimpleNetDevice::GetIfIndex() const [member function]

  3043     cls.add_method('GetIfIndex',

  3044                    'uint32_t',

  3045                    [],

  3046                    is_const=True, is_virtual=True)

  3047     ## simple-net-device.h: ns3::Ptr<ns3::Channel> ns3::SimpleNetDevice::GetChannel() const [member function]

  3048     cls.add_method('GetChannel',

  3049                    'ns3::Ptr< ns3::Channel >',

  3050                    [],

  3051                    is_const=True, is_virtual=True)

  3052     ## simple-net-device.h: void ns3::SimpleNetDevice::SetAddress(ns3::Address address) [member function]

  3053     cls.add_method('SetAddress',

  3054                    'void',

  3055                    [param('ns3::Address', 'address')],

  3056                    is_virtual=True)

  3057     ## simple-net-device.h: ns3::Address ns3::SimpleNetDevice::GetAddress() const [member function]

  3058     cls.add_method('GetAddress',

  3059                    'ns3::Address',

  3060                    [],

  3061                    is_const=True, is_virtual=True)

  3062     ## simple-net-device.h: bool ns3::SimpleNetDevice::SetMtu(uint16_t const mtu) [member function]

  3063     cls.add_method('SetMtu',

  3064                    'bool',

  3065                    [param('uint16_t const', 'mtu')],

  3066                    is_virtual=True)

  3067     ## simple-net-device.h: uint16_t ns3::SimpleNetDevice::GetMtu() const [member function]

  3068     cls.add_method('GetMtu',

  3069                    'uint16_t',

  3070                    [],

  3071                    is_const=True, is_virtual=True)

  3072     ## simple-net-device.h: bool ns3::SimpleNetDevice::IsLinkUp() const [member function]

  3073     cls.add_method('IsLinkUp',

  3074                    'bool',

  3075                    [],

  3076                    is_const=True, is_virtual=True)

  3077     ## simple-net-device.h: void ns3::SimpleNetDevice::SetLinkChangeCallback(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function]

  3078     cls.add_method('SetLinkChangeCallback',

  3079                    'void',

  3080                    [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')],

  3081                    is_virtual=True)

  3082     ## simple-net-device.h: bool ns3::SimpleNetDevice::IsBroadcast() const [member function]

  3083     cls.add_method('IsBroadcast',

  3084                    'bool',

  3085                    [],

  3086                    is_const=True, is_virtual=True)

  3087     ## simple-net-device.h: ns3::Address ns3::SimpleNetDevice::GetBroadcast() const [member function]

  3088     cls.add_method('GetBroadcast',

  3089                    'ns3::Address',

  3090                    [],

  3091                    is_const=True, is_virtual=True)

  3092     ## simple-net-device.h: bool ns3::SimpleNetDevice::IsMulticast() const [member function]

  3093     cls.add_method('IsMulticast',

  3094                    'bool',

  3095                    [],

  3096                    is_const=True, is_virtual=True)

  3097     ## simple-net-device.h: ns3::Address ns3::SimpleNetDevice::GetMulticast(ns3::Ipv4Address multicastGroup) const [member function]

  3098     cls.add_method('GetMulticast',

  3099                    'ns3::Address',

  3100                    [param('ns3::Ipv4Address', 'multicastGroup')],

  3101                    is_const=True, is_virtual=True)

  3102     ## simple-net-device.h: bool ns3::SimpleNetDevice::IsPointToPoint() const [member function]

  3103     cls.add_method('IsPointToPoint',

  3104                    'bool',

  3105                    [],

  3106                    is_const=True, is_virtual=True)

  3107     ## simple-net-device.h: bool ns3::SimpleNetDevice::IsBridge() const [member function]

  3108     cls.add_method('IsBridge',

  3109                    'bool',

  3110                    [],

  3111                    is_const=True, is_virtual=True)

  3112     ## simple-net-device.h: bool ns3::SimpleNetDevice::Send(ns3::Ptr<ns3::Packet> packet, ns3::Address const & dest, uint16_t protocolNumber) [member function]

  3113     cls.add_method('Send',

  3114                    'bool',

  3115                    [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')],

  3116                    is_virtual=True)

  3117     ## simple-net-device.h: bool ns3::SimpleNetDevice::SendFrom(ns3::Ptr<ns3::Packet> packet, ns3::Address const & source, ns3::Address const & dest, uint16_t protocolNumber) [member function]

  3118     cls.add_method('SendFrom',

  3119                    'bool',

  3120                    [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'source'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')],

  3121                    is_virtual=True)

  3122     ## simple-net-device.h: ns3::Ptr<ns3::Node> ns3::SimpleNetDevice::GetNode() const [member function]

  3123     cls.add_method('GetNode',

  3124                    'ns3::Ptr< ns3::Node >',

  3125                    [],

  3126                    is_const=True, is_virtual=True)

  3127     ## simple-net-device.h: void ns3::SimpleNetDevice::SetNode(ns3::Ptr<ns3::Node> node) [member function]

  3128     cls.add_method('SetNode',

  3129                    'void',

  3130                    [param('ns3::Ptr< ns3::Node >', 'node')],

  3131                    is_virtual=True)

  3132     ## simple-net-device.h: bool ns3::SimpleNetDevice::NeedsArp() const [member function]

  3133     cls.add_method('NeedsArp',

  3134                    'bool',

  3135                    [],

  3136                    is_const=True, is_virtual=True)

  3137     ## simple-net-device.h: void ns3::SimpleNetDevice::SetReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function]

  3138     cls.add_method('SetReceiveCallback',

  3139                    'void',

  3140                    [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')],

  3141                    is_virtual=True)

  3142     ## simple-net-device.h: ns3::Address ns3::SimpleNetDevice::GetMulticast(ns3::Ipv6Address addr) const [member function]

  3143     cls.add_method('GetMulticast',

  3144                    'ns3::Address',

  3145                    [param('ns3::Ipv6Address', 'addr')],

  3146                    is_const=True, is_virtual=True)

  3147     ## simple-net-device.h: void ns3::SimpleNetDevice::SetPromiscReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet const>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> cb) [member function]

  3148     cls.add_method('SetPromiscReceiveCallback',

  3149                    'void',

  3150                    [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'cb')],

  3151                    is_virtual=True)

  3152     ## simple-net-device.h: bool ns3::SimpleNetDevice::SupportsSendFrom() const [member function]

  3153     cls.add_method('SupportsSendFrom',

  3154                    'bool',

  3155                    [],

  3156                    is_const=True, is_virtual=True)

  3157     ## simple-net-device.h: void ns3::SimpleNetDevice::DoDispose() [member function]

  3158     cls.add_method('DoDispose',

  3159                    'void',

  3160                    [],

  3161                    visibility='protected', is_virtual=True)

  3162     return

  3164 def register_functions(root_module):

  3165     module = root_module

  3166     ## address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeAddressChecker() [free function]

  3167     module.add_function('MakeAddressChecker',

  3168                         'ns3::Ptr< ns3::AttributeChecker const >',

  3169                         [])

  3170     ## ipv4-address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeIpv4AddressChecker() [free function]

  3171     module.add_function('MakeIpv4AddressChecker',

  3172                         'ns3::Ptr< ns3::AttributeChecker const >',

  3173                         [])

  3174     ## ipv4-address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeIpv4MaskChecker() [free function]

  3175     module.add_function('MakeIpv4MaskChecker',

  3176                         'ns3::Ptr< ns3::AttributeChecker const >',

  3177                         [])

  3178     ## ipv6-address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeIpv6AddressChecker() [free function]

  3179     module.add_function('MakeIpv6AddressChecker',

  3180                         'ns3::Ptr< ns3::AttributeChecker const >',

  3181                         [])

  3182     ## ipv6-address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeIpv6PrefixChecker() [free function]

  3183     module.add_function('MakeIpv6PrefixChecker',

  3184                         'ns3::Ptr< ns3::AttributeChecker const >',

  3185                         [])

  3186     ## mac48-address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeMac48AddressChecker() [free function]

  3187     module.add_function('MakeMac48AddressChecker',

  3188                         'ns3::Ptr< ns3::AttributeChecker const >',

  3189                         [])

  3190     ## address-utils.h: extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Address & ad, uint32_t len) [free function]

  3191     module.add_function('ReadFrom',

  3192                         'void',

  3193                         [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Address &', 'ad'), param('uint32_t', 'len')])

  3194     ## address-utils.h: extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Ipv4Address & ad) [free function]

  3195     module.add_function('ReadFrom',

  3196                         'void',

  3197                         [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Ipv4Address &', 'ad')])

  3198     ## address-utils.h: extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Ipv6Address & ad) [free function]

  3199     module.add_function('ReadFrom',

  3200                         'void',

  3201                         [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Ipv6Address &', 'ad')])

  3202     ## address-utils.h: extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Mac48Address & ad) [free function]

  3203     module.add_function('ReadFrom',

  3204                         'void',

  3205                         [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Mac48Address &', 'ad')])

  3206     ## address-utils.h: extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Address const & ad) [free function]

  3207     module.add_function('WriteTo',

  3208                         'void',

  3209                         [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Address const &', 'ad')])

  3210     ## address-utils.h: extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Ipv4Address ad) [free function]

  3211     module.add_function('WriteTo',

  3212                         'void',

  3213                         [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Ipv4Address', 'ad')])

  3214     ## address-utils.h: extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Ipv6Address ad) [free function]

  3215     module.add_function('WriteTo',

  3216                         'void',

  3217                         [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Ipv6Address', 'ad')])

  3218     ## address-utils.h: extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Mac48Address ad) [free function]

  3219     module.add_function('WriteTo',

  3220                         'void',

  3221                         [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Mac48Address', 'ad')])

  3222     register_functions_ns3_Config(module.get_submodule('Config'), root_module)

  3223     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)

  3224     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)

  3225     register_functions_ns3_internal(module.get_submodule('internal'), root_module)

  3226     register_functions_ns3_olsr(module.get_submodule('olsr'), root_module)

  3227     return

  3229 def register_functions_ns3_Config(module, root_module):

  3230     return

  3232 def register_functions_ns3_TimeStepPrecision(module, root_module):

  3233     return

  3235 def register_functions_ns3_addressUtils(module, root_module):

  3236     ## address-utils.h: extern bool ns3::addressUtils::IsMulticast(ns3::Address const & ad) [free function]

  3237     module.add_function('IsMulticast',

  3238                         'bool',

  3239                         [param('ns3::Address const &', 'ad')])

  3240     return

  3242 def register_functions_ns3_internal(module, root_module):

  3243     return

  3245 def register_functions_ns3_olsr(module, root_module):

  3246     return

author	Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
	Sat, 04 Jul 2009 08:15:48 +0200
changeset 4654	2eaebe77d66b
parent 4604	98cb594222af
permissions	-rw-r--r--