ns-3.5: bindings/python/ns3_module

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

     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     ## inet-socket-address.h: ns3::InetSocketAddress [class]

    13     module.add_class('InetSocketAddress')

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

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

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

    17     module.add_class('Ipv4Address')

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

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

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

    21     module.add_class('Ipv4AddressGenerator')

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

    23     module.add_class('Ipv4Mask')

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

    25     module.add_class('Ipv4MulticastRoute')

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

    27     module.add_class('Ipv4Route')

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

    29     module.add_class('Mac48Address')

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

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

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

    33     module.add_class('Mac64Address')

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

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

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

    37     module.add_class('NodeList')

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

    39     module.add_class('PacketSocketAddress')

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    63     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'])

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    98     ## ipv4.h: ns3::Ipv4RoutingProtocol [class]

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

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

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

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

   103     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'])

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

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

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

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

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

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

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

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

   113     ## Register a nested module for the namespace internal

   115     nested_module = module.add_cpp_namespace('internal')

   116     register_types_ns3_internal(nested_module)

   119     ## Register a nested module for the namespace TimeStepPrecision

   121     nested_module = module.add_cpp_namespace('TimeStepPrecision')

   122     register_types_ns3_TimeStepPrecision(nested_module)

   125     ## Register a nested module for the namespace Config

   127     nested_module = module.add_cpp_namespace('Config')

   128     register_types_ns3_Config(nested_module)

   131     ## Register a nested module for the namespace olsr

   133     nested_module = module.add_cpp_namespace('olsr')

   134     register_types_ns3_olsr(nested_module)

   137 def register_types_ns3_internal(module):

   138     root_module = module.get_root()

   141 def register_types_ns3_TimeStepPrecision(module):

   142     root_module = module.get_root()

   145 def register_types_ns3_Config(module):

   146     root_module = module.get_root()

   149 def register_types_ns3_olsr(module):

   150     root_module = module.get_root()

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

   154 def register_methods(root_module):

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   199     return

   201 def register_Ns3Address_methods(root_module, cls):

   202     cls.add_binary_comparison_operator('!=')

   203     cls.add_binary_comparison_operator('<')

   204     cls.add_output_stream_operator()

   205     cls.add_binary_comparison_operator('==')

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

   207     cls.add_constructor([])

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

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

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

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

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

   213     cls.add_method('CheckCompatible',

   214                    'bool',

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

   216                    is_const=True)

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

   218     cls.add_method('CopyAllFrom',

   219                    'uint32_t',

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

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

   222     cls.add_method('CopyAllTo',

   223                    'uint32_t',

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

   225                    is_const=True)

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

   227     cls.add_method('CopyFrom',

   228                    'uint32_t',

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

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

   231     cls.add_method('CopyTo',

   232                    'uint32_t',

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

   234                    is_const=True)

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

   236     cls.add_method('Deserialize',

   237                    'void',

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

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

   240     cls.add_method('GetLength',

   241                    'uint8_t',

   242                    [],

   243                    is_const=True)

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

   245     cls.add_method('GetSerializedSize',

   246                    'uint32_t',

   247                    [],

   248                    is_const=True)

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

   250     cls.add_method('IsInvalid',

   251                    'bool',

   252                    [],

   253                    is_const=True)

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

   255     cls.add_method('IsMatchingType',

   256                    'bool',

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

   258                    is_const=True)

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

   260     cls.add_method('Register',

   261                    'uint8_t',

   262                    [],

   263                    is_static=True)

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

   265     cls.add_method('Serialize',

   266                    'void',

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

   268                    is_const=True)

   269     return

   271 def register_Ns3InetSocketAddress_methods(root_module, cls):

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

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

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

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

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

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

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

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

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

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

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

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

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

   285     cls.add_method('GetPort',

   286                    'uint16_t',

   287                    [],

   288                    is_const=True)

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

   290     cls.add_method('GetIpv4',

   291                    'ns3::Ipv4Address',

   292                    [],

   293                    is_const=True)

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

   295     cls.add_method('SetPort',

   296                    'void',

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

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

   299     cls.add_method('SetIpv4',

   300                    'void',

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

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

   303     cls.add_method('IsMatchingType',

   304                    'bool',

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

   306                    is_static=True)

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

   308     cls.add_method('ConvertFrom',

   309                    'ns3::InetSocketAddress',

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

   311                    is_static=True)

   312     return

   314 def register_Ns3Ipv4Address_methods(root_module, cls):

   315     cls.add_binary_comparison_operator('!=')

   316     cls.add_binary_comparison_operator('<')

   317     cls.add_output_stream_operator()

   318     cls.add_binary_comparison_operator('==')

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

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

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

   322     cls.add_constructor([])

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

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

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

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

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

   328     cls.add_method('CombineMask',

   329                    'ns3::Ipv4Address',

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

   331                    is_const=True)

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

   333     cls.add_method('ConvertFrom',

   334                    'ns3::Ipv4Address',

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

   336                    is_static=True)

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

   338     cls.add_method('Deserialize',

   339                    'ns3::Ipv4Address',

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

   341                    is_static=True)

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

   343     cls.add_method('Get',

   344                    'uint32_t',

   345                    [],

   346                    is_const=True)

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

   348     cls.add_method('GetAny',

   349                    'ns3::Ipv4Address',

   350                    [],

   351                    is_static=True)

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

   353     cls.add_method('GetBroadcast',

   354                    'ns3::Ipv4Address',

   355                    [],

   356                    is_static=True)

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

   358     cls.add_method('GetLoopback',

   359                    'ns3::Ipv4Address',

   360                    [],

   361                    is_static=True)

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

   363     cls.add_method('GetSubnetDirectedBroadcast',

   364                    'ns3::Ipv4Address',

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

   366                    is_const=True)

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

   368     cls.add_method('GetZero',

   369                    'ns3::Ipv4Address',

   370                    [],

   371                    is_static=True)

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

   373     cls.add_method('IsBroadcast',

   374                    'bool',

   375                    [],

   376                    is_const=True)

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

   378     cls.add_method('IsEqual',

   379                    'bool',

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

   381                    is_const=True)

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

   383     cls.add_method('IsMatchingType',

   384                    'bool',

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

   386                    is_static=True)

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

   388     cls.add_method('IsMulticast',

   389                    'bool',

   390                    [],

   391                    is_const=True)

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

   393     cls.add_method('IsSubnetDirectedBroadcast',

   394                    'bool',

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

   396                    is_const=True)

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

   398     cls.add_method('Print',

   399                    'void',

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

   401                    is_const=True)

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

   403     cls.add_method('Serialize',

   404                    'void',

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

   406                    is_const=True)

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

   408     cls.add_method('Set',

   409                    'void',

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

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

   412     cls.add_method('Set',

   413                    'void',

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

   415     return

   417 def register_Ns3Ipv4AddressGenerator_methods(root_module, cls):

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

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

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

   421     cls.add_constructor([])

   422     ## 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]

   423     cls.add_method('Init',

   424                    'void',

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

   426                    is_static=True)

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

   428     cls.add_method('NextNetwork',

   429                    'ns3::Ipv4Address',

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

   431                    is_static=True)

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

   433     cls.add_method('GetNetwork',

   434                    'ns3::Ipv4Address',

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

   436                    is_static=True)

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

   438     cls.add_method('InitAddress',

   439                    'void',

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

   441                    is_static=True)

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

   443     cls.add_method('NextAddress',

   444                    'ns3::Ipv4Address',

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

   446                    is_static=True)

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

   448     cls.add_method('GetAddress',

   449                    'ns3::Ipv4Address',

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

   451                    is_static=True)

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

   453     cls.add_method('Reset',

   454                    'void',

   455                    [],

   456                    is_static=True)

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

   458     cls.add_method('AddAllocated',

   459                    'bool',

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

   461                    is_static=True)

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

   463     cls.add_method('TestMode',

   464                    'void',

   465                    [],

   466                    is_static=True)

   467     return

   469 def register_Ns3Ipv4Mask_methods(root_module, cls):

   470     cls.add_binary_comparison_operator('!=')

   471     cls.add_output_stream_operator()

   472     cls.add_binary_comparison_operator('==')

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

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

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

   476     cls.add_constructor([])

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

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

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

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

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

   482     cls.add_method('Get',

   483                    'uint32_t',

   484                    [],

   485                    is_const=True)

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

   487     cls.add_method('GetInverse',

   488                    'uint32_t',

   489                    [],

   490                    is_const=True)

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

   492     cls.add_method('GetLoopback',

   493                    'ns3::Ipv4Mask',

   494                    [],

   495                    is_static=True)

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

   497     cls.add_method('GetZero',

   498                    'ns3::Ipv4Mask',

   499                    [],

   500                    is_static=True)

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

   502     cls.add_method('IsEqual',

   503                    'bool',

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

   505                    is_const=True)

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

   507     cls.add_method('IsMatch',

   508                    'bool',

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

   510                    is_const=True)

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

   512     cls.add_method('Print',

   513                    'void',

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

   515                    is_const=True)

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

   517     cls.add_method('Set',

   518                    'void',

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

   520     return

   522 def register_Ns3Ipv4MulticastRoute_methods(root_module, cls):

   523     cls.add_output_stream_operator()

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

   525     cls.add_constructor([])

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

   527     cls.add_constructor([param('ns3::Ipv4MulticastRoute const &', 'route')])

   528     ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute(ns3::Ipv4MulticastRoute const * route) [constructor]

   529     cls.add_constructor([param('ns3::Ipv4MulticastRoute const *', 'route')])

   530     ## ipv4-route.h: static ns3::Ipv4MulticastRoute ns3::Ipv4MulticastRoute::CreateMulticastRoute(ns3::Ipv4Address origin, ns3::Ipv4Address group, uint32_t inputInterface, std::vector<unsigned int, std::allocator<unsigned int> > outputInterfaces) [member function]

   531     cls.add_method('CreateMulticastRoute',

   532                    'ns3::Ipv4MulticastRoute',

   533                    [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int >', 'outputInterfaces')],

   534                    is_static=True)

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

   536     cls.add_method('GetGroup',

   537                    'ns3::Ipv4Address',

   538                    [],

   539                    is_const=True)

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

   541     cls.add_method('GetInputInterface',

   542                    'uint32_t',

   543                    [],

   544                    is_const=True)

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

   546     cls.add_method('GetNOutputInterfaces',

   547                    'uint32_t',

   548                    [],

   549                    is_const=True)

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

   551     cls.add_method('GetOrigin',

   552                    'ns3::Ipv4Address',

   553                    [],

   554                    is_const=True)

   555     ## ipv4-route.h: uint32_t ns3::Ipv4MulticastRoute::GetOutputInterface(uint32_t n) const [member function]

   556     cls.add_method('GetOutputInterface',

   557                    'uint32_t',

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

   559                    is_const=True)

   560     ## ipv4-route.h: std::vector<unsigned int, std::allocator<unsigned int> > ns3::Ipv4MulticastRoute::GetOutputInterfaces() const [member function]

   561     cls.add_method('GetOutputInterfaces',

   562                    'std::vector< unsigned int >',

   563                    [],

   564                    is_const=True)

   565     return

   567 def register_Ns3Ipv4Route_methods(root_module, cls):

   568     cls.add_output_stream_operator()

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

   570     cls.add_constructor([])

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

   572     cls.add_constructor([param('ns3::Ipv4Route const &', 'route')])

   573     ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route(ns3::Ipv4Route const * route) [constructor]

   574     cls.add_constructor([param('ns3::Ipv4Route const *', 'route')])

   575     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateDefaultRoute(ns3::Ipv4Address nextHop, uint32_t interface) [member function]

   576     cls.add_method('CreateDefaultRoute',

   577                    'ns3::Ipv4Route',

   578                    [param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')],

   579                    is_static=True)

   580     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateHostRouteTo(ns3::Ipv4Address dest, ns3::Ipv4Address nextHop, uint32_t interface) [member function]

   581     cls.add_method('CreateHostRouteTo',

   582                    'ns3::Ipv4Route',

   583                    [param('ns3::Ipv4Address', 'dest'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')],

   584                    is_static=True)

   585     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateHostRouteTo(ns3::Ipv4Address dest, uint32_t interface) [member function]

   586     cls.add_method('CreateHostRouteTo',

   587                    'ns3::Ipv4Route',

   588                    [param('ns3::Ipv4Address', 'dest'), param('uint32_t', 'interface')],

   589                    is_static=True)

   590     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, ns3::Ipv4Address nextHop, uint32_t interface) [member function]

   591     cls.add_method('CreateNetworkRouteTo',

   592                    'ns3::Ipv4Route',

   593                    [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')],

   594                    is_static=True)

   595     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, uint32_t interface) [member function]

   596     cls.add_method('CreateNetworkRouteTo',

   597                    'ns3::Ipv4Route',

   598                    [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('uint32_t', 'interface')],

   599                    is_static=True)

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

   601     cls.add_method('GetDest',

   602                    'ns3::Ipv4Address',

   603                    [],

   604                    is_const=True)

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

   606     cls.add_method('GetDestNetwork',

   607                    'ns3::Ipv4Address',

   608                    [],

   609                    is_const=True)

   610     ## ipv4-route.h: ns3::Ipv4Mask ns3::Ipv4Route::GetDestNetworkMask() const [member function]

   611     cls.add_method('GetDestNetworkMask',

   612                    'ns3::Ipv4Mask',

   613                    [],

   614                    is_const=True)

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

   616     cls.add_method('GetGateway',

   617                    'ns3::Ipv4Address',

   618                    [],

   619                    is_const=True)

   620     ## ipv4-route.h: uint32_t ns3::Ipv4Route::GetInterface() const [member function]

   621     cls.add_method('GetInterface',

   622                    'uint32_t',

   623                    [],

   624                    is_const=True)

   625     ## ipv4-route.h: bool ns3::Ipv4Route::IsDefault() const [member function]

   626     cls.add_method('IsDefault',

   627                    'bool',

   628                    [],

   629                    is_const=True)

   630     ## ipv4-route.h: bool ns3::Ipv4Route::IsGateway() const [member function]

   631     cls.add_method('IsGateway',

   632                    'bool',

   633                    [],

   634                    is_const=True)

   635     ## ipv4-route.h: bool ns3::Ipv4Route::IsHost() const [member function]

   636     cls.add_method('IsHost',

   637                    'bool',

   638                    [],

   639                    is_const=True)

   640     ## ipv4-route.h: bool ns3::Ipv4Route::IsNetwork() const [member function]

   641     cls.add_method('IsNetwork',

   642                    'bool',

   643                    [],

   644                    is_const=True)

   645     return

   647 def register_Ns3Mac48Address_methods(root_module, cls):

   648     cls.add_binary_comparison_operator('!=')

   649     cls.add_binary_comparison_operator('<')

   650     cls.add_output_stream_operator()

   651     cls.add_binary_comparison_operator('==')

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

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

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

   655     cls.add_constructor([])

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

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

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

   659     cls.add_method('Allocate',

   660                    'ns3::Mac48Address',

   661                    [],

   662                    is_static=True)

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

   664     cls.add_method('ConvertFrom',

   665                    'ns3::Mac48Address',

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

   667                    is_static=True)

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

   669     cls.add_method('CopyFrom',

   670                    'void',

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

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

   673     cls.add_method('CopyTo',

   674                    'void',

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

   676                    is_const=True)

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

   678     cls.add_method('GetBroadcast',

   679                    'ns3::Mac48Address',

   680                    [],

   681                    is_static=True)

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

   683     cls.add_method('GetMulticast',

   684                    'ns3::Mac48Address',

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

   686                    is_static=True)

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

   688     cls.add_method('GetMulticastPrefix',

   689                    'ns3::Mac48Address',

   690                    [],

   691                    is_static=True)

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

   693     cls.add_method('IsBroadcast',

   694                    'bool',

   695                    [],

   696                    is_const=True)

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

   698     cls.add_method('IsGroup',

   699                    'bool',

   700                    [],

   701                    is_const=True)

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

   703     cls.add_method('IsMatchingType',

   704                    'bool',

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

   706                    is_static=True)

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

   708     cls.add_method('IsMulticast',

   709                    'bool',

   710                    [],

   711                    is_const=True)

   712     return

   714 def register_Ns3Mac64Address_methods(root_module, cls):

   715     cls.add_binary_comparison_operator('!=')

   716     cls.add_output_stream_operator()

   717     cls.add_binary_comparison_operator('==')

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

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

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

   721     cls.add_constructor([])

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

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

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

   725     cls.add_method('Allocate',

   726                    'ns3::Mac64Address',

   727                    [],

   728                    is_static=True)

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

   730     cls.add_method('ConvertFrom',

   731                    'ns3::Mac64Address',

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

   733                    is_static=True)

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

   735     cls.add_method('CopyFrom',

   736                    'void',

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

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

   739     cls.add_method('CopyTo',

   740                    'void',

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

   742                    is_const=True)

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

   744     cls.add_method('IsMatchingType',

   745                    'bool',

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

   747                    is_static=True)

   748     return

   750 def register_Ns3NodeList_methods(root_module, cls):

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

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

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

   754     cls.add_constructor([])

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

   756     cls.add_method('Add',

   757                    'uint32_t',

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

   759                    is_static=True)

   760     ## 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]

   761     cls.add_method('Begin',

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

   763                    [],

   764                    is_static=True)

   765     ## 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]

   766     cls.add_method('End',

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

   768                    [],

   769                    is_static=True)

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

   771     cls.add_method('GetNode',

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

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

   774                    is_static=True)

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

   776     cls.add_method('GetNNodes',

   777                    'uint32_t',

   778                    [],

   779                    is_static=True)

   780     return

   782 def register_Ns3PacketSocketAddress_methods(root_module, cls):

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

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

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

   786     cls.add_constructor([])

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

   788     cls.add_method('SetProtocol',

   789                    'void',

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

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

   792     cls.add_method('SetAllDevices',

   793                    'void',

   794                    [])

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

   796     cls.add_method('SetSingleDevice',

   797                    'void',

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

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

   800     cls.add_method('SetPhysicalAddress',

   801                    'void',

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

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

   804     cls.add_method('GetProtocol',

   805                    'uint16_t',

   806                    [],

   807                    is_const=True)

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

   809     cls.add_method('GetSingleDevice',

   810                    'uint32_t',

   811                    [],

   812                    is_const=True)

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

   814     cls.add_method('IsSingleDevice',

   815                    'bool',

   816                    [],

   817                    is_const=True)

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

   819     cls.add_method('GetPhysicalAddress',

   820                    'ns3::Address',

   821                    [],

   822                    is_const=True)

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

   824     cls.add_method('ConvertFrom',

   825                    'ns3::PacketSocketAddress',

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

   827                    is_static=True)

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

   829     cls.add_method('IsMatchingType',

   830                    'bool',

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

   832                    is_static=True)

   833     return

   835 def register_Ns3Ipv4AddressChecker_methods(root_module, cls):

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

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

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

   839     cls.add_constructor([])

   840     return

   842 def register_Ns3Ipv4AddressValue_methods(root_module, cls):

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

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

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

   846     cls.add_constructor([])

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

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

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

   850     cls.add_method('Set',

   851                    'void',

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

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

   854     cls.add_method('Get',

   855                    'ns3::Ipv4Address',

   856                    [],

   857                    is_const=True)

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

   859     cls.add_method('Copy',

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

   861                    [],

   862                    is_const=True, is_virtual=True)

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

   864     cls.add_method('SerializeToString',

   865                    'std::string',

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

   867                    is_const=True, is_virtual=True)

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

   869     cls.add_method('DeserializeFromString',

   870                    'bool',

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

   872                    is_virtual=True)

   873     return

   875 def register_Ns3Ipv4Header_methods(root_module, cls):

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

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

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

   879     cls.add_constructor([])

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

   881     cls.add_method('EnableChecksum',

   882                    'void',

   883                    [])

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

   885     cls.add_method('SetPayloadSize',

   886                    'void',

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

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

   889     cls.add_method('SetIdentification',

   890                    'void',

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

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

   893     cls.add_method('SetTos',

   894                    'void',

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

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

   897     cls.add_method('SetMoreFragments',

   898                    'void',

   899                    [])

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

   901     cls.add_method('SetLastFragment',

   902                    'void',

   903                    [])

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

   905     cls.add_method('SetDontFragment',

   906                    'void',

   907                    [])

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

   909     cls.add_method('SetMayFragment',

   910                    'void',

   911                    [])

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

   913     cls.add_method('SetFragmentOffset',

   914                    'void',

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

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

   917     cls.add_method('SetTtl',

   918                    'void',

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

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

   921     cls.add_method('SetProtocol',

   922                    'void',

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

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

   925     cls.add_method('SetSource',

   926                    'void',

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

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

   929     cls.add_method('SetDestination',

   930                    'void',

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

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

   933     cls.add_method('GetPayloadSize',

   934                    'uint16_t',

   935                    [],

   936                    is_const=True)

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

   938     cls.add_method('GetIdentification',

   939                    'uint16_t',

   940                    [],

   941                    is_const=True)

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

   943     cls.add_method('GetTos',

   944                    'uint8_t',

   945                    [],

   946                    is_const=True)

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

   948     cls.add_method('IsLastFragment',

   949                    'bool',

   950                    [],

   951                    is_const=True)

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

   953     cls.add_method('IsDontFragment',

   954                    'bool',

   955                    [],

   956                    is_const=True)

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

   958     cls.add_method('GetFragmentOffset',

   959                    'uint16_t',

   960                    [],

   961                    is_const=True)

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

   963     cls.add_method('GetTtl',

   964                    'uint8_t',

   965                    [],

   966                    is_const=True)

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

   968     cls.add_method('GetProtocol',

   969                    'uint8_t',

   970                    [],

   971                    is_const=True)

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

   973     cls.add_method('GetSource',

   974                    'ns3::Ipv4Address',

   975                    [],

   976                    is_const=True)

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

   978     cls.add_method('GetDestination',

   979                    'ns3::Ipv4Address',

   980                    [],

   981                    is_const=True)

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

   983     cls.add_method('IsChecksumOk',

   984                    'bool',

   985                    [],

   986                    is_const=True)

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

   988     cls.add_method('GetTypeId',

   989                    'ns3::TypeId',

   990                    [],

   991                    is_static=True)

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

   993     cls.add_method('GetInstanceTypeId',

   994                    'ns3::TypeId',

   995                    [],

   996                    is_const=True, is_virtual=True)

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

   998     cls.add_method('Print',

   999                    'void',

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

  1001                    is_const=True, is_virtual=True)

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

  1003     cls.add_method('GetSerializedSize',

  1004                    'uint32_t',

  1005                    [],

  1006                    is_const=True, is_virtual=True)

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

  1008     cls.add_method('Serialize',

  1009                    'void',

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

  1011                    is_const=True, is_virtual=True)

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

  1013     cls.add_method('Deserialize',

  1014                    'uint32_t',

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

  1016                    is_virtual=True)

  1017     return

  1019 def register_Ns3Ipv4MaskChecker_methods(root_module, cls):

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

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

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

  1023     cls.add_constructor([])

  1024     return

  1026 def register_Ns3Ipv4MaskValue_methods(root_module, cls):

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

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

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

  1030     cls.add_constructor([])

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

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

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

  1034     cls.add_method('Set',

  1035                    'void',

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

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

  1038     cls.add_method('Get',

  1039                    'ns3::Ipv4Mask',

  1040                    [],

  1041                    is_const=True)

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

  1043     cls.add_method('Copy',

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

  1045                    [],

  1046                    is_const=True, is_virtual=True)

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

  1048     cls.add_method('SerializeToString',

  1049                    'std::string',

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

  1051                    is_const=True, is_virtual=True)

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

  1053     cls.add_method('DeserializeFromString',

  1054                    'bool',

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

  1056                    is_virtual=True)

  1057     return

  1059 def register_Ns3LlcSnapHeader_methods(root_module, cls):

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

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

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

  1063     cls.add_constructor([])

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

  1065     cls.add_method('SetType',

  1066                    'void',

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

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

  1069     cls.add_method('GetType',

  1070                    'uint16_t',

  1071                    [])

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

  1073     cls.add_method('GetTypeId',

  1074                    'ns3::TypeId',

  1075                    [],

  1076                    is_static=True)

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

  1078     cls.add_method('GetInstanceTypeId',

  1079                    'ns3::TypeId',

  1080                    [],

  1081                    is_const=True, is_virtual=True)

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

  1083     cls.add_method('Print',

  1084                    'void',

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

  1086                    is_const=True, is_virtual=True)

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

  1088     cls.add_method('GetSerializedSize',

  1089                    'uint32_t',

  1090                    [],

  1091                    is_const=True, is_virtual=True)

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

  1093     cls.add_method('Serialize',

  1094                    'void',

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

  1096                    is_const=True, is_virtual=True)

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

  1098     cls.add_method('Deserialize',

  1099                    'uint32_t',

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

  1101                    is_virtual=True)

  1102     return

  1104 def register_Ns3Mac48AddressChecker_methods(root_module, cls):

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

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

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

  1108     cls.add_constructor([])

  1109     return

  1111 def register_Ns3Mac48AddressValue_methods(root_module, cls):

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

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

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

  1115     cls.add_constructor([])

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

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

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

  1119     cls.add_method('Set',

  1120                    'void',

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

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

  1123     cls.add_method('Get',

  1124                    'ns3::Mac48Address',

  1125                    [],

  1126                    is_const=True)

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

  1128     cls.add_method('Copy',

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

  1130                    [],

  1131                    is_const=True, is_virtual=True)

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

  1133     cls.add_method('SerializeToString',

  1134                    'std::string',

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

  1136                    is_const=True, is_virtual=True)

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

  1138     cls.add_method('DeserializeFromString',

  1139                    'bool',

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

  1141                    is_virtual=True)

  1142     return

  1144 def register_Ns3Queue_methods(root_module, cls):

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

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

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

  1148     cls.add_method('GetTypeId',

  1149                    'ns3::TypeId',

  1150                    [],

  1151                    is_static=True)

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

  1153     cls.add_constructor([])

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

  1155     cls.add_method('IsEmpty',

  1156                    'bool',

  1157                    [],

  1158                    is_const=True)

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

  1160     cls.add_method('Enqueue',

  1161                    'bool',

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

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

  1164     cls.add_method('Dequeue',

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

  1166                    [])

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

  1168     cls.add_method('Peek',

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

  1170                    [],

  1171                    is_const=True)

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

  1173     cls.add_method('DequeueAll',

  1174                    'void',

  1175                    [])

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

  1177     cls.add_method('GetNPackets',

  1178                    'uint32_t',

  1179                    [],

  1180                    is_const=True)

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

  1182     cls.add_method('GetNBytes',

  1183                    'uint32_t',

  1184                    [],

  1185                    is_const=True)

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

  1187     cls.add_method('GetTotalReceivedBytes',

  1188                    'uint32_t',

  1189                    [],

  1190                    is_const=True)

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

  1192     cls.add_method('GetTotalReceivedPackets',

  1193                    'uint32_t',

  1194                    [],

  1195                    is_const=True)

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

  1197     cls.add_method('GetTotalDroppedBytes',

  1198                    'uint32_t',

  1199                    [],

  1200                    is_const=True)

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

  1202     cls.add_method('GetTotalDroppedPackets',

  1203                    'uint32_t',

  1204                    [],

  1205                    is_const=True)

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

  1207     cls.add_method('ResetStatistics',

  1208                    'void',

  1209                    [])

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

  1211     cls.add_method('Drop',

  1212                    'void',

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

  1214                    visibility='protected')

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

  1216     cls.add_method('DoEnqueue',

  1217                    'bool',

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

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

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

  1221     cls.add_method('DoDequeue',

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

  1223                    [],

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

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

  1226     cls.add_method('DoPeek',

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

  1228                    [],

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

  1230     return

  1232 def register_Ns3Socket_methods(root_module, cls):

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

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

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

  1236     cls.add_constructor([])

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

  1238     cls.add_method('CreateSocket',

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

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

  1241                    is_static=True)

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

  1243     cls.add_method('GetErrno',

  1244                    'ns3::Socket::SocketErrno',

  1245                    [],

  1246                    is_pure_virtual=True, is_const=True, is_virtual=True)

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

  1248     cls.add_method('GetNode',

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

  1250                    [],

  1251                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1252     ## socket.h: void ns3::Socket::SetConnectCallback(ns3::Callback<void, ns3::Ptr<ns3::Socket>, 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> connectionFailed) [member function]

  1253     cls.add_method('SetConnectCallback',

  1254                    'void',

  1255                    [param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, 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 >', 'connectionFailed')])

  1256     ## socket.h: void ns3::Socket::SetAcceptCallback(ns3::Callback<bool, ns3::Ptr<ns3::Socket>, ns3::Address const&, 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> newConnectionCreated) [member function]

  1257     cls.add_method('SetAcceptCallback',

  1258                    'void',

  1259                    [param('ns3::Callback< bool, ns3::Ptr< ns3::Socket >, ns3::Address const &, 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 >', 'newConnectionCreated')])

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

  1261     cls.add_method('SetDataSentCallback',

  1262                    'void',

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

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

  1265     cls.add_method('SetSendCallback',

  1266                    'void',

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

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

  1269     cls.add_method('SetRecvCallback',

  1270                    'void',

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

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

  1273     cls.add_method('Bind',

  1274                    'int',

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

  1276                    is_pure_virtual=True, is_virtual=True)

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

  1278     cls.add_method('Bind',

  1279                    'int',

  1280                    [],

  1281                    is_pure_virtual=True, is_virtual=True)

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

  1283     cls.add_method('Close',

  1284                    'int',

  1285                    [],

  1286                    is_pure_virtual=True, is_virtual=True)

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

  1288     cls.add_method('ShutdownSend',

  1289                    'int',

  1290                    [],

  1291                    is_pure_virtual=True, is_virtual=True)

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

  1293     cls.add_method('ShutdownRecv',

  1294                    'int',

  1295                    [],

  1296                    is_pure_virtual=True, is_virtual=True)

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

  1298     cls.add_method('Connect',

  1299                    'int',

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

  1301                    is_pure_virtual=True, is_virtual=True)

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

  1303     cls.add_method('Listen',

  1304                    'int',

  1305                    [],

  1306                    is_pure_virtual=True, is_virtual=True)

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

  1308     cls.add_method('GetTxAvailable',

  1309                    'uint32_t',

  1310                    [],

  1311                    is_pure_virtual=True, is_const=True, is_virtual=True)

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

  1313     cls.add_method('Send',

  1314                    'int',

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

  1316                    is_pure_virtual=True, is_virtual=True)

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

  1318     cls.add_method('SendTo',

  1319                    'int',

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

  1321                    is_pure_virtual=True, is_virtual=True)

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

  1323     cls.add_method('GetRxAvailable',

  1324                    'uint32_t',

  1325                    [],

  1326                    is_pure_virtual=True, is_const=True, is_virtual=True)

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

  1328     cls.add_method('Recv',

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

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

  1331                    is_pure_virtual=True, is_virtual=True)

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

  1333     cls.add_method('RecvFrom',

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

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

  1336                    is_pure_virtual=True, is_virtual=True)

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

  1338     cls.add_method('Send',

  1339                    'int',

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

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

  1342     cls.add_method('Send',

  1343                    'int',

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

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

  1346     cls.add_method('SendTo',

  1347                    'int',

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

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

  1350     cls.add_method('Recv',

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

  1352                    [])

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

  1354     cls.add_method('Recv',

  1355                    'int',

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

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

  1358     cls.add_method('RecvFrom',

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

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

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

  1362     cls.add_method('RecvFrom',

  1363                    'int',

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

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

  1366     cls.add_method('GetSockName',

  1367                    'int',

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

  1369                    is_pure_virtual=True, is_const=True, is_virtual=True)

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

  1371     cls.add_method('NotifyConnectionSucceeded',

  1372                    'void',

  1373                    [],

  1374                    visibility='protected')

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

  1376     cls.add_method('NotifyConnectionFailed',

  1377                    'void',

  1378                    [],

  1379                    visibility='protected')

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

  1381     cls.add_method('NotifyConnectionRequest',

  1382                    'bool',

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

  1384                    visibility='protected')

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

  1386     cls.add_method('NotifyNewConnectionCreated',

  1387                    'void',

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

  1389                    visibility='protected')

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

  1391     cls.add_method('NotifyDataSent',

  1392                    'void',

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

  1394                    visibility='protected')

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

  1396     cls.add_method('NotifySend',

  1397                    'void',

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

  1399                    visibility='protected')

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

  1401     cls.add_method('NotifyDataRecv',

  1402                    'void',

  1403                    [],

  1404                    visibility='protected')

  1405     return

  1407 def register_Ns3SocketAddressTag_methods(root_module, cls):

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

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

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

  1411     cls.add_constructor([])

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

  1413     cls.add_method('SetAddress',

  1414                    'void',

  1415                    [param('ns3::Address', 'addr')])

  1416     ## socket.h: ns3::Address ns3::SocketAddressTag::GetAddress() const [member function]

  1417     cls.add_method('GetAddress',

  1418                    'ns3::Address',

  1419                    [],

  1420                    is_const=True)

  1421     ## socket.h: static ns3::TypeId ns3::SocketAddressTag::GetTypeId() [member function]

  1422     cls.add_method('GetTypeId',

  1423                    'ns3::TypeId',

  1424                    [],

  1425                    is_static=True)

  1426     ## socket.h: ns3::TypeId ns3::SocketAddressTag::GetInstanceTypeId() const [member function]

  1427     cls.add_method('GetInstanceTypeId',

  1428                    'ns3::TypeId',

  1429                    [],

  1430                    is_const=True, is_virtual=True)

  1431     ## socket.h: uint32_t ns3::SocketAddressTag::GetSerializedSize() const [member function]

  1432     cls.add_method('GetSerializedSize',

  1433                    'uint32_t',

  1434                    [],

  1435                    is_const=True, is_virtual=True)

  1436     ## socket.h: void ns3::SocketAddressTag::Serialize(ns3::TagBuffer i) const [member function]

  1437     cls.add_method('Serialize',

  1438                    'void',

  1439                    [param('ns3::TagBuffer', 'i')],

  1440                    is_const=True, is_virtual=True)

  1441     ## socket.h: void ns3::SocketAddressTag::Deserialize(ns3::TagBuffer i) [member function]

  1442     cls.add_method('Deserialize',

  1443                    'void',

  1444                    [param('ns3::TagBuffer', 'i')],

  1445                    is_virtual=True)

  1446     ## socket.h: void ns3::SocketAddressTag::Print(std::ostream & os) const [member function]

  1447     cls.add_method('Print',

  1448                    'void',

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

  1450                    is_const=True, is_virtual=True)

  1451     return

  1453 def register_Ns3SocketFactory_methods(root_module, cls):

  1454     ## socket-factory.h: ns3::SocketFactory::SocketFactory(ns3::SocketFactory const & arg0) [copy constructor]

  1455     cls.add_constructor([param('ns3::SocketFactory const &', 'arg0')])

  1456     ## socket-factory.h: static ns3::TypeId ns3::SocketFactory::GetTypeId() [member function]

  1457     cls.add_method('GetTypeId',

  1458                    'ns3::TypeId',

  1459                    [],

  1460                    is_static=True)

  1461     ## socket-factory.h: ns3::SocketFactory::SocketFactory() [constructor]

  1462     cls.add_constructor([])

  1463     ## socket-factory.h: ns3::Ptr<ns3::Socket> ns3::SocketFactory::CreateSocket() [member function]

  1464     cls.add_method('CreateSocket',

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

  1466                    [],

  1467                    is_pure_virtual=True, is_virtual=True)

  1468     return

  1470 def register_Ns3SocketIpTtlTag_methods(root_module, cls):

  1471     ## socket.h: ns3::SocketIpTtlTag::SocketIpTtlTag(ns3::SocketIpTtlTag const & arg0) [copy constructor]

  1472     cls.add_constructor([param('ns3::SocketIpTtlTag const &', 'arg0')])

  1473     ## socket.h: ns3::SocketIpTtlTag::SocketIpTtlTag() [constructor]

  1474     cls.add_constructor([])

  1475     ## socket.h: void ns3::SocketIpTtlTag::SetTtl(uint8_t ttl) [member function]

  1476     cls.add_method('SetTtl',

  1477                    'void',

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

  1479     ## socket.h: uint8_t ns3::SocketIpTtlTag::GetTtl() const [member function]

  1480     cls.add_method('GetTtl',

  1481                    'uint8_t',

  1482                    [],

  1483                    is_const=True)

  1484     ## socket.h: static ns3::TypeId ns3::SocketIpTtlTag::GetTypeId() [member function]

  1485     cls.add_method('GetTypeId',

  1486                    'ns3::TypeId',

  1487                    [],

  1488                    is_static=True)

  1489     ## socket.h: ns3::TypeId ns3::SocketIpTtlTag::GetInstanceTypeId() const [member function]

  1490     cls.add_method('GetInstanceTypeId',

  1491                    'ns3::TypeId',

  1492                    [],

  1493                    is_const=True, is_virtual=True)

  1494     ## socket.h: uint32_t ns3::SocketIpTtlTag::GetSerializedSize() const [member function]

  1495     cls.add_method('GetSerializedSize',

  1496                    'uint32_t',

  1497                    [],

  1498                    is_const=True, is_virtual=True)

  1499     ## socket.h: void ns3::SocketIpTtlTag::Serialize(ns3::TagBuffer i) const [member function]

  1500     cls.add_method('Serialize',

  1501                    'void',

  1502                    [param('ns3::TagBuffer', 'i')],

  1503                    is_const=True, is_virtual=True)

  1504     ## socket.h: void ns3::SocketIpTtlTag::Deserialize(ns3::TagBuffer i) [member function]

  1505     cls.add_method('Deserialize',

  1506                    'void',

  1507                    [param('ns3::TagBuffer', 'i')],

  1508                    is_virtual=True)

  1509     ## socket.h: void ns3::SocketIpTtlTag::Print(std::ostream & os) const [member function]

  1510     cls.add_method('Print',

  1511                    'void',

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

  1513                    is_const=True, is_virtual=True)

  1514     return

  1516 def register_Ns3SocketSetDontFragmentTag_methods(root_module, cls):

  1517     ## socket.h: ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag(ns3::SocketSetDontFragmentTag const & arg0) [copy constructor]

  1518     cls.add_constructor([param('ns3::SocketSetDontFragmentTag const &', 'arg0')])

  1519     ## socket.h: ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag() [constructor]

  1520     cls.add_constructor([])

  1521     ## socket.h: void ns3::SocketSetDontFragmentTag::Enable() [member function]

  1522     cls.add_method('Enable',

  1523                    'void',

  1524                    [])

  1525     ## socket.h: void ns3::SocketSetDontFragmentTag::Disable() [member function]

  1526     cls.add_method('Disable',

  1527                    'void',

  1528                    [])

  1529     ## socket.h: bool ns3::SocketSetDontFragmentTag::IsEnabled() const [member function]

  1530     cls.add_method('IsEnabled',

  1531                    'bool',

  1532                    [],

  1533                    is_const=True)

  1534     ## socket.h: static ns3::TypeId ns3::SocketSetDontFragmentTag::GetTypeId() [member function]

  1535     cls.add_method('GetTypeId',

  1536                    'ns3::TypeId',

  1537                    [],

  1538                    is_static=True)

  1539     ## socket.h: ns3::TypeId ns3::SocketSetDontFragmentTag::GetInstanceTypeId() const [member function]

  1540     cls.add_method('GetInstanceTypeId',

  1541                    'ns3::TypeId',

  1542                    [],

  1543                    is_const=True, is_virtual=True)

  1544     ## socket.h: uint32_t ns3::SocketSetDontFragmentTag::GetSerializedSize() const [member function]

  1545     cls.add_method('GetSerializedSize',

  1546                    'uint32_t',

  1547                    [],

  1548                    is_const=True, is_virtual=True)

  1549     ## socket.h: void ns3::SocketSetDontFragmentTag::Serialize(ns3::TagBuffer i) const [member function]

  1550     cls.add_method('Serialize',

  1551                    'void',

  1552                    [param('ns3::TagBuffer', 'i')],

  1553                    is_const=True, is_virtual=True)

  1554     ## socket.h: void ns3::SocketSetDontFragmentTag::Deserialize(ns3::TagBuffer i) [member function]

  1555     cls.add_method('Deserialize',

  1556                    'void',

  1557                    [param('ns3::TagBuffer', 'i')],

  1558                    is_virtual=True)

  1559     ## socket.h: void ns3::SocketSetDontFragmentTag::Print(std::ostream & os) const [member function]

  1560     cls.add_method('Print',

  1561                    'void',

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

  1563                    is_const=True, is_virtual=True)

  1564     return

  1566 def register_Ns3TcpSocket_methods(root_module, cls):

  1567     ## tcp-socket.h: ns3::TcpSocket::TcpSocket(ns3::TcpSocket const & arg0) [copy constructor]

  1568     cls.add_constructor([param('ns3::TcpSocket const &', 'arg0')])

  1569     ## tcp-socket.h: static ns3::TypeId ns3::TcpSocket::GetTypeId() [member function]

  1570     cls.add_method('GetTypeId',

  1571                    'ns3::TypeId',

  1572                    [],

  1573                    is_static=True)

  1574     ## tcp-socket.h: ns3::TcpSocket::TcpSocket() [constructor]

  1575     cls.add_constructor([])

  1576     ## tcp-socket.h: void ns3::TcpSocket::SetSndBufSize(uint32_t size) [member function]

  1577     cls.add_method('SetSndBufSize',

  1578                    'void',

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

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

  1581     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetSndBufSize() const [member function]

  1582     cls.add_method('GetSndBufSize',

  1583                    'uint32_t',

  1584                    [],

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

  1586     ## tcp-socket.h: void ns3::TcpSocket::SetRcvBufSize(uint32_t size) [member function]

  1587     cls.add_method('SetRcvBufSize',

  1588                    'void',

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

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

  1591     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetRcvBufSize() const [member function]

  1592     cls.add_method('GetRcvBufSize',

  1593                    'uint32_t',

  1594                    [],

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

  1596     ## tcp-socket.h: void ns3::TcpSocket::SetSegSize(uint32_t size) [member function]

  1597     cls.add_method('SetSegSize',

  1598                    'void',

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

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

  1601     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetSegSize() const [member function]

  1602     cls.add_method('GetSegSize',

  1603                    'uint32_t',

  1604                    [],

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

  1606     ## tcp-socket.h: void ns3::TcpSocket::SetSSThresh(uint32_t threshold) [member function]

  1607     cls.add_method('SetSSThresh',

  1608                    'void',

  1609                    [param('uint32_t', 'threshold')],

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

  1611     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetSSThresh() const [member function]

  1612     cls.add_method('GetSSThresh',

  1613                    'uint32_t',

  1614                    [],

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

  1616     ## tcp-socket.h: void ns3::TcpSocket::SetInitialCwnd(uint32_t count) [member function]

  1617     cls.add_method('SetInitialCwnd',

  1618                    'void',

  1619                    [param('uint32_t', 'count')],

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

  1621     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetInitialCwnd() const [member function]

  1622     cls.add_method('GetInitialCwnd',

  1623                    'uint32_t',

  1624                    [],

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

  1626     ## tcp-socket.h: void ns3::TcpSocket::SetConnTimeout(ns3::Time timeout) [member function]

  1627     cls.add_method('SetConnTimeout',

  1628                    'void',

  1629                    [param('ns3::Time', 'timeout')],

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

  1631     ## tcp-socket.h: ns3::Time ns3::TcpSocket::GetConnTimeout() const [member function]

  1632     cls.add_method('GetConnTimeout',

  1633                    'ns3::Time',

  1634                    [],

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

  1636     ## tcp-socket.h: void ns3::TcpSocket::SetConnCount(uint32_t count) [member function]

  1637     cls.add_method('SetConnCount',

  1638                    'void',

  1639                    [param('uint32_t', 'count')],

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

  1641     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetConnCount() const [member function]

  1642     cls.add_method('GetConnCount',

  1643                    'uint32_t',

  1644                    [],

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

  1646     ## tcp-socket.h: void ns3::TcpSocket::SetDelAckTimeout(ns3::Time timeout) [member function]

  1647     cls.add_method('SetDelAckTimeout',

  1648                    'void',

  1649                    [param('ns3::Time', 'timeout')],

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

  1651     ## tcp-socket.h: ns3::Time ns3::TcpSocket::GetDelAckTimeout() const [member function]

  1652     cls.add_method('GetDelAckTimeout',

  1653                    'ns3::Time',

  1654                    [],

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

  1656     ## tcp-socket.h: void ns3::TcpSocket::SetDelAckMaxCount(uint32_t count) [member function]

  1657     cls.add_method('SetDelAckMaxCount',

  1658                    'void',

  1659                    [param('uint32_t', 'count')],

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

  1661     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetDelAckMaxCount() const [member function]

  1662     cls.add_method('GetDelAckMaxCount',

  1663                    'uint32_t',

  1664                    [],

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

  1666     return

  1668 def register_Ns3TcpSocketFactory_methods(root_module, cls):

  1669     ## tcp-socket-factory.h: ns3::TcpSocketFactory::TcpSocketFactory(ns3::TcpSocketFactory const & arg0) [copy constructor]

  1670     cls.add_constructor([param('ns3::TcpSocketFactory const &', 'arg0')])

  1671     ## tcp-socket-factory.h: ns3::TcpSocketFactory::TcpSocketFactory() [constructor]

  1672     cls.add_constructor([])

  1673     ## tcp-socket-factory.h: static ns3::TypeId ns3::TcpSocketFactory::GetTypeId() [member function]

  1674     cls.add_method('GetTypeId',

  1675                    'ns3::TypeId',

  1676                    [],

  1677                    is_static=True)

  1678     return

  1680 def register_Ns3UdpSocket_methods(root_module, cls):

  1681     ## udp-socket.h: ns3::UdpSocket::UdpSocket(ns3::UdpSocket const & arg0) [copy constructor]

  1682     cls.add_constructor([param('ns3::UdpSocket const &', 'arg0')])

  1683     ## udp-socket.h: static ns3::TypeId ns3::UdpSocket::GetTypeId() [member function]

  1684     cls.add_method('GetTypeId',

  1685                    'ns3::TypeId',

  1686                    [],

  1687                    is_static=True)

  1688     ## udp-socket.h: ns3::UdpSocket::UdpSocket() [constructor]

  1689     cls.add_constructor([])

  1690     ## udp-socket.h: void ns3::UdpSocket::SetRcvBufSize(uint32_t size) [member function]

  1691     cls.add_method('SetRcvBufSize',

  1692                    'void',

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

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

  1695     ## udp-socket.h: uint32_t ns3::UdpSocket::GetRcvBufSize() const [member function]

  1696     cls.add_method('GetRcvBufSize',

  1697                    'uint32_t',

  1698                    [],

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

  1700     ## udp-socket.h: void ns3::UdpSocket::SetIpTtl(uint32_t ipTtl) [member function]

  1701     cls.add_method('SetIpTtl',

  1702                    'void',

  1703                    [param('uint32_t', 'ipTtl')],

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

  1705     ## udp-socket.h: uint32_t ns3::UdpSocket::GetIpTtl() const [member function]

  1706     cls.add_method('GetIpTtl',

  1707                    'uint32_t',

  1708                    [],

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

  1710     ## udp-socket.h: void ns3::UdpSocket::SetIpMulticastTtl(uint32_t ipTtl) [member function]

  1711     cls.add_method('SetIpMulticastTtl',

  1712                    'void',

  1713                    [param('uint32_t', 'ipTtl')],

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

  1715     ## udp-socket.h: uint32_t ns3::UdpSocket::GetIpMulticastTtl() const [member function]

  1716     cls.add_method('GetIpMulticastTtl',

  1717                    'uint32_t',

  1718                    [],

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

  1720     ## udp-socket.h: void ns3::UdpSocket::SetMtuDiscover(bool discover) [member function]

  1721     cls.add_method('SetMtuDiscover',

  1722                    'void',

  1723                    [param('bool', 'discover')],

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

  1725     ## udp-socket.h: bool ns3::UdpSocket::GetMtuDiscover() const [member function]

  1726     cls.add_method('GetMtuDiscover',

  1727                    'bool',

  1728                    [],

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

  1730     return

  1732 def register_Ns3UdpSocketFactory_methods(root_module, cls):

  1733     ## udp-socket-factory.h: ns3::UdpSocketFactory::UdpSocketFactory(ns3::UdpSocketFactory const & arg0) [copy constructor]

  1734     cls.add_constructor([param('ns3::UdpSocketFactory const &', 'arg0')])

  1735     ## udp-socket-factory.h: ns3::UdpSocketFactory::UdpSocketFactory() [constructor]

  1736     cls.add_constructor([])

  1737     ## udp-socket-factory.h: static ns3::TypeId ns3::UdpSocketFactory::GetTypeId() [member function]

  1738     cls.add_method('GetTypeId',

  1739                    'ns3::TypeId',

  1740                    [],

  1741                    is_static=True)

  1742     return

  1744 def register_Ns3AddressChecker_methods(root_module, cls):

  1745     ## address.h: ns3::AddressChecker::AddressChecker(ns3::AddressChecker const & arg0) [copy constructor]

  1746     cls.add_constructor([param('ns3::AddressChecker const &', 'arg0')])

  1747     ## address.h: ns3::AddressChecker::AddressChecker() [constructor]

  1748     cls.add_constructor([])

  1749     return

  1751 def register_Ns3AddressValue_methods(root_module, cls):

  1752     ## address.h: ns3::AddressValue::AddressValue(ns3::AddressValue const & arg0) [copy constructor]

  1753     cls.add_constructor([param('ns3::AddressValue const &', 'arg0')])

  1754     ## address.h: ns3::AddressValue::AddressValue() [constructor]

  1755     cls.add_constructor([])

  1756     ## address.h: ns3::AddressValue::AddressValue(ns3::Address const & value) [constructor]

  1757     cls.add_constructor([param('ns3::Address const &', 'value')])

  1758     ## address.h: void ns3::AddressValue::Set(ns3::Address const & value) [member function]

  1759     cls.add_method('Set',

  1760                    'void',

  1761                    [param('ns3::Address const &', 'value')])

  1762     ## address.h: ns3::Address ns3::AddressValue::Get() const [member function]

  1763     cls.add_method('Get',

  1764                    'ns3::Address',

  1765                    [],

  1766                    is_const=True)

  1767     ## address.h: ns3::Ptr<ns3::AttributeValue> ns3::AddressValue::Copy() const [member function]

  1768     cls.add_method('Copy',

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

  1770                    [],

  1771                    is_const=True, is_virtual=True)

  1772     ## address.h: std::string ns3::AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

  1773     cls.add_method('SerializeToString',

  1774                    'std::string',

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

  1776                    is_const=True, is_virtual=True)

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

  1778     cls.add_method('DeserializeFromString',

  1779                    'bool',

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

  1781                    is_virtual=True)

  1782     return

  1784 def register_Ns3Application_methods(root_module, cls):

  1785     ## application.h: ns3::Application::Application(ns3::Application const & arg0) [copy constructor]

  1786     cls.add_constructor([param('ns3::Application const &', 'arg0')])

  1787     ## application.h: static ns3::TypeId ns3::Application::GetTypeId() [member function]

  1788     cls.add_method('GetTypeId',

  1789                    'ns3::TypeId',

  1790                    [],

  1791                    is_static=True)

  1792     ## application.h: ns3::Application::Application() [constructor]

  1793     cls.add_constructor([])

  1794     ## application.h: void ns3::Application::Start(ns3::Time const & startTime) [member function]

  1795     cls.add_method('Start',

  1796                    'void',

  1797                    [param('ns3::Time const &', 'startTime')])

  1798     ## application.h: void ns3::Application::Start(ns3::RandomVariable const & startVariable) [member function]

  1799     cls.add_method('Start',

  1800                    'void',

  1801                    [param('ns3::RandomVariable const &', 'startVariable')])

  1802     ## application.h: void ns3::Application::Stop(ns3::Time const & stopTime) [member function]

  1803     cls.add_method('Stop',

  1804                    'void',

  1805                    [param('ns3::Time const &', 'stopTime')])

  1806     ## application.h: void ns3::Application::Stop(ns3::RandomVariable const & stopVariable) [member function]

  1807     cls.add_method('Stop',

  1808                    'void',

  1809                    [param('ns3::RandomVariable const &', 'stopVariable')])

  1810     ## application.h: ns3::Ptr<ns3::Node> ns3::Application::GetNode() const [member function]

  1811     cls.add_method('GetNode',

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

  1813                    [],

  1814                    is_const=True)

  1815     ## application.h: void ns3::Application::SetNode(ns3::Ptr<ns3::Node> node) [member function]

  1816     cls.add_method('SetNode',

  1817                    'void',

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

  1819     ## application.h: void ns3::Application::DoDispose() [member function]

  1820     cls.add_method('DoDispose',

  1821                    'void',

  1822                    [],

  1823                    visibility='protected', is_virtual=True)

  1824     ## application.h: void ns3::Application::StartApplication() [member function]

  1825     cls.add_method('StartApplication',

  1826                    'void',

  1827                    [],

  1828                    visibility='private', is_virtual=True)

  1829     ## application.h: void ns3::Application::StopApplication() [member function]

  1830     cls.add_method('StopApplication',

  1831                    'void',

  1832                    [],

  1833                    visibility='private', is_virtual=True)

  1834     return

  1836 def register_Ns3Channel_methods(root_module, cls):

  1837     ## channel.h: ns3::Channel::Channel(ns3::Channel const & arg0) [copy constructor]

  1838     cls.add_constructor([param('ns3::Channel const &', 'arg0')])

  1839     ## channel.h: static ns3::TypeId ns3::Channel::GetTypeId() [member function]

  1840     cls.add_method('GetTypeId',

  1841                    'ns3::TypeId',

  1842                    [],

  1843                    is_static=True)

  1844     ## channel.h: ns3::Channel::Channel() [constructor]

  1845     cls.add_constructor([])

  1846     ## channel.h: ns3::Channel::Channel(std::string name) [constructor]

  1847     cls.add_constructor([param('std::string', 'name')])

  1848     ## channel.h: void ns3::Channel::SetName(std::string arg0) [member function]

  1849     cls.add_method('SetName',

  1850                    'void',

  1851                    [param('std::string', 'arg0')])

  1852     ## channel.h: std::string ns3::Channel::GetName() [member function]

  1853     cls.add_method('GetName',

  1854                    'std::string',

  1855                    [])

  1856     ## channel.h: uint32_t ns3::Channel::GetNDevices() const [member function]

  1857     cls.add_method('GetNDevices',

  1858                    'uint32_t',

  1859                    [],

  1860                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1861     ## channel.h: ns3::Ptr<ns3::NetDevice> ns3::Channel::GetDevice(uint32_t i) const [member function]

  1862     cls.add_method('GetDevice',

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

  1864                    [param('uint32_t', 'i')],

  1865                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1866     return

  1868 def register_Ns3DropTailQueue_methods(root_module, cls):

  1869     ## drop-tail-queue.h: ns3::DropTailQueue::DropTailQueue(ns3::DropTailQueue const & arg0) [copy constructor]

  1870     cls.add_constructor([param('ns3::DropTailQueue const &', 'arg0')])

  1871     ## drop-tail-queue.h: static ns3::TypeId ns3::DropTailQueue::GetTypeId() [member function]

  1872     cls.add_method('GetTypeId',

  1873                    'ns3::TypeId',

  1874                    [],

  1875                    is_static=True)

  1876     ## drop-tail-queue.h: ns3::DropTailQueue::DropTailQueue() [constructor]

  1877     cls.add_constructor([])

  1878     ## drop-tail-queue.h: bool ns3::DropTailQueue::DoEnqueue(ns3::Ptr<ns3::Packet> p) [member function]

  1879     cls.add_method('DoEnqueue',

  1880                    'bool',

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

  1882                    visibility='private', is_virtual=True)

  1883     ## drop-tail-queue.h: ns3::Ptr<ns3::Packet> ns3::DropTailQueue::DoDequeue() [member function]

  1884     cls.add_method('DoDequeue',

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

  1886                    [],

  1887                    visibility='private', is_virtual=True)

  1888     ## drop-tail-queue.h: ns3::Ptr<const ns3::Packet> ns3::DropTailQueue::DoPeek() const [member function]

  1889     cls.add_method('DoPeek',

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

  1891                    [],

  1892                    is_const=True, visibility='private', is_virtual=True)

  1893     return

  1895 def register_Ns3EthernetHeader_methods(root_module, cls):

  1896     ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader(ns3::EthernetHeader const & arg0) [copy constructor]

  1897     cls.add_constructor([param('ns3::EthernetHeader const &', 'arg0')])

  1898     ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader(bool hasPreamble) [constructor]

  1899     cls.add_constructor([param('bool', 'hasPreamble')])

  1900     ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader() [constructor]

  1901     cls.add_constructor([])

  1902     ## ethernet-header.h: void ns3::EthernetHeader::SetLengthType(uint16_t size) [member function]

  1903     cls.add_method('SetLengthType',

  1904                    'void',

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

  1906     ## ethernet-header.h: void ns3::EthernetHeader::SetSource(ns3::Mac48Address source) [member function]

  1907     cls.add_method('SetSource',

  1908                    'void',

  1909                    [param('ns3::Mac48Address', 'source')])

  1910     ## ethernet-header.h: void ns3::EthernetHeader::SetDestination(ns3::Mac48Address destination) [member function]

  1911     cls.add_method('SetDestination',

  1912                    'void',

  1913                    [param('ns3::Mac48Address', 'destination')])

  1914     ## ethernet-header.h: void ns3::EthernetHeader::SetPreambleSfd(uint64_t preambleSfd) [member function]

  1915     cls.add_method('SetPreambleSfd',

  1916                    'void',

  1917                    [param('uint64_t', 'preambleSfd')])

  1918     ## ethernet-header.h: uint16_t ns3::EthernetHeader::GetLengthType() const [member function]

  1919     cls.add_method('GetLengthType',

  1920                    'uint16_t',

  1921                    [],

  1922                    is_const=True)

  1923     ## ethernet-header.h: ns3::ethernet_header_t ns3::EthernetHeader::GetPacketType() const [member function]

  1924     cls.add_method('GetPacketType',

  1925                    'ns3::ethernet_header_t',

  1926                    [],

  1927                    is_const=True)

  1928     ## ethernet-header.h: ns3::Mac48Address ns3::EthernetHeader::GetSource() const [member function]

  1929     cls.add_method('GetSource',

  1930                    'ns3::Mac48Address',

  1931                    [],

  1932                    is_const=True)

  1933     ## ethernet-header.h: ns3::Mac48Address ns3::EthernetHeader::GetDestination() const [member function]

  1934     cls.add_method('GetDestination',

  1935                    'ns3::Mac48Address',

  1936                    [],

  1937                    is_const=True)

  1938     ## ethernet-header.h: uint64_t ns3::EthernetHeader::GetPreambleSfd() const [member function]

  1939     cls.add_method('GetPreambleSfd',

  1940                    'uint64_t',

  1941                    [],

  1942                    is_const=True)

  1943     ## ethernet-header.h: uint32_t ns3::EthernetHeader::GetHeaderSize() const [member function]

  1944     cls.add_method('GetHeaderSize',

  1945                    'uint32_t',

  1946                    [],

  1947                    is_const=True)

  1948     ## ethernet-header.h: static ns3::TypeId ns3::EthernetHeader::GetTypeId() [member function]

  1949     cls.add_method('GetTypeId',

  1950                    'ns3::TypeId',

  1951                    [],

  1952                    is_static=True)

  1953     ## ethernet-header.h: ns3::TypeId ns3::EthernetHeader::GetInstanceTypeId() const [member function]

  1954     cls.add_method('GetInstanceTypeId',

  1955                    'ns3::TypeId',

  1956                    [],

  1957                    is_const=True, is_virtual=True)

  1958     ## ethernet-header.h: void ns3::EthernetHeader::Print(std::ostream & os) const [member function]

  1959     cls.add_method('Print',

  1960                    'void',

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

  1962                    is_const=True, is_virtual=True)

  1963     ## ethernet-header.h: uint32_t ns3::EthernetHeader::GetSerializedSize() const [member function]

  1964     cls.add_method('GetSerializedSize',

  1965                    'uint32_t',

  1966                    [],

  1967                    is_const=True, is_virtual=True)

  1968     ## ethernet-header.h: void ns3::EthernetHeader::Serialize(ns3::Buffer::Iterator start) const [member function]

  1969     cls.add_method('Serialize',

  1970                    'void',

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

  1972                    is_const=True, is_virtual=True)

  1973     ## ethernet-header.h: uint32_t ns3::EthernetHeader::Deserialize(ns3::Buffer::Iterator start) [member function]

  1974     cls.add_method('Deserialize',

  1975                    'uint32_t',

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

  1977                    is_virtual=True)

  1978     return

  1980 def register_Ns3EthernetTrailer_methods(root_module, cls):

  1981     ## ethernet-trailer.h: ns3::EthernetTrailer::EthernetTrailer(ns3::EthernetTrailer const & arg0) [copy constructor]

  1982     cls.add_constructor([param('ns3::EthernetTrailer const &', 'arg0')])

  1983     ## ethernet-trailer.h: ns3::EthernetTrailer::EthernetTrailer() [constructor]

  1984     cls.add_constructor([])

  1985     ## ethernet-trailer.h: static void ns3::EthernetTrailer::EnableFcs(bool enable) [member function]

  1986     cls.add_method('EnableFcs',

  1987                    'void',

  1988                    [param('bool', 'enable')],

  1989                    is_static=True)

  1990     ## ethernet-trailer.h: void ns3::EthernetTrailer::CalcFcs(ns3::Ptr<ns3::Packet> p) [member function]

  1991     cls.add_method('CalcFcs',

  1992                    'void',

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

  1994     ## ethernet-trailer.h: void ns3::EthernetTrailer::SetFcs(uint32_t fcs) [member function]

  1995     cls.add_method('SetFcs',

  1996                    'void',

  1997                    [param('uint32_t', 'fcs')])

  1998     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::GetFcs() [member function]

  1999     cls.add_method('GetFcs',

  2000                    'uint32_t',

  2001                    [])

  2002     ## ethernet-trailer.h: bool ns3::EthernetTrailer::CheckFcs(ns3::Ptr<ns3::Packet> p) const [member function]

  2003     cls.add_method('CheckFcs',

  2004                    'bool',

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

  2006                    is_const=True)

  2007     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::GetTrailerSize() const [member function]

  2008     cls.add_method('GetTrailerSize',

  2009                    'uint32_t',

  2010                    [],

  2011                    is_const=True)

  2012     ## ethernet-trailer.h: static ns3::TypeId ns3::EthernetTrailer::GetTypeId() [member function]

  2013     cls.add_method('GetTypeId',

  2014                    'ns3::TypeId',

  2015                    [],

  2016                    is_static=True)

  2017     ## ethernet-trailer.h: ns3::TypeId ns3::EthernetTrailer::GetInstanceTypeId() const [member function]

  2018     cls.add_method('GetInstanceTypeId',

  2019                    'ns3::TypeId',

  2020                    [],

  2021                    is_const=True, is_virtual=True)

  2022     ## ethernet-trailer.h: void ns3::EthernetTrailer::Print(std::ostream & os) const [member function]

  2023     cls.add_method('Print',

  2024                    'void',

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

  2026                    is_const=True, is_virtual=True)

  2027     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::GetSerializedSize() const [member function]

  2028     cls.add_method('GetSerializedSize',

  2029                    'uint32_t',

  2030                    [],

  2031                    is_const=True, is_virtual=True)

  2032     ## ethernet-trailer.h: void ns3::EthernetTrailer::Serialize(ns3::Buffer::Iterator end) const [member function]

  2033     cls.add_method('Serialize',

  2034                    'void',

  2035                    [param('ns3::Buffer::Iterator', 'end')],

  2036                    is_const=True, is_virtual=True)

  2037     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::Deserialize(ns3::Buffer::Iterator end) [member function]

  2038     cls.add_method('Deserialize',

  2039                    'uint32_t',

  2040                    [param('ns3::Buffer::Iterator', 'end')],

  2041                    is_virtual=True)

  2042     return

  2044 def register_Ns3Ipv4_methods(root_module, cls):

  2045     ## ipv4.h: ns3::Ipv4::Ipv4(ns3::Ipv4 const & arg0) [copy constructor]

  2046     cls.add_constructor([param('ns3::Ipv4 const &', 'arg0')])

  2047     ## ipv4.h: static ns3::TypeId ns3::Ipv4::GetTypeId() [member function]

  2048     cls.add_method('GetTypeId',

  2049                    'ns3::TypeId',

  2050                    [],

  2051                    is_static=True)

  2052     ## ipv4.h: ns3::Ipv4::Ipv4() [constructor]

  2053     cls.add_constructor([])

  2054     ## ipv4.h: void ns3::Ipv4::AddRoutingProtocol(ns3::Ptr<ns3::Ipv4RoutingProtocol> routingProtocol, int16_t priority) [member function]

  2055     cls.add_method('AddRoutingProtocol',

  2056                    'void',

  2057                    [param('ns3::Ptr< ns3::Ipv4RoutingProtocol >', 'routingProtocol'), param('int16_t', 'priority')],

  2058                    is_pure_virtual=True, is_virtual=True)

  2059     ## ipv4.h: void ns3::Ipv4::AddHostRouteTo(ns3::Ipv4Address dest, ns3::Ipv4Address nextHop, uint32_t interface) [member function]

  2060     cls.add_method('AddHostRouteTo',

  2061                    'void',

  2062                    [param('ns3::Ipv4Address', 'dest'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')],

  2063                    is_pure_virtual=True, is_virtual=True)

  2064     ## ipv4.h: void ns3::Ipv4::AddHostRouteTo(ns3::Ipv4Address dest, uint32_t interface) [member function]

  2065     cls.add_method('AddHostRouteTo',

  2066                    'void',

  2067                    [param('ns3::Ipv4Address', 'dest'), param('uint32_t', 'interface')],

  2068                    is_pure_virtual=True, is_virtual=True)

  2069     ## ipv4.h: void ns3::Ipv4::AddNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, ns3::Ipv4Address nextHop, uint32_t interface) [member function]

  2070     cls.add_method('AddNetworkRouteTo',

  2071                    'void',

  2072                    [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')],

  2073                    is_pure_virtual=True, is_virtual=True)

  2074     ## ipv4.h: void ns3::Ipv4::AddNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, uint32_t interface) [member function]

  2075     cls.add_method('AddNetworkRouteTo',

  2076                    'void',

  2077                    [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('uint32_t', 'interface')],

  2078                    is_pure_virtual=True, is_virtual=True)

  2079     ## ipv4.h: void ns3::Ipv4::SetDefaultRoute(ns3::Ipv4Address nextHop, uint32_t interface) [member function]

  2080     cls.add_method('SetDefaultRoute',

  2081                    'void',

  2082                    [param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')],

  2083                    is_pure_virtual=True, is_virtual=True)

  2084     ## ipv4.h: uint32_t ns3::Ipv4::GetNRoutes() [member function]

  2085     cls.add_method('GetNRoutes',

  2086                    'uint32_t',

  2087                    [],

  2088                    is_pure_virtual=True, is_virtual=True)

  2089     ## ipv4.h: ns3::Ipv4Route ns3::Ipv4::GetRoute(uint32_t i) [member function]

  2090     cls.add_method('GetRoute',

  2091                    'ns3::Ipv4Route',

  2092                    [param('uint32_t', 'i')],

  2093                    is_pure_virtual=True, is_virtual=True)

  2094     ## ipv4.h: void ns3::Ipv4::RemoveRoute(uint32_t i) [member function]

  2095     cls.add_method('RemoveRoute',

  2096                    'void',

  2097                    [param('uint32_t', 'i')],

  2098                    is_pure_virtual=True, is_virtual=True)

  2099     ## ipv4.h: void ns3::Ipv4::AddMulticastRoute(ns3::Ipv4Address origin, ns3::Ipv4Address group, uint32_t inputInterface, std::vector<unsigned int, std::allocator<unsigned int> > outputInterfaces) [member function]

  2100     cls.add_method('AddMulticastRoute',

  2101                    'void',

  2102                    [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int >', 'outputInterfaces')],

  2103                    is_pure_virtual=True, is_virtual=True)

  2104     ## ipv4.h: void ns3::Ipv4::RemoveMulticastRoute(ns3::Ipv4Address origin, ns3::Ipv4Address group, uint32_t inputInterface) [member function]

  2105     cls.add_method('RemoveMulticastRoute',

  2106                    'void',

  2107                    [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface')],

  2108                    is_pure_virtual=True, is_virtual=True)

  2109     ## ipv4.h: void ns3::Ipv4::SetDefaultMulticastRoute(uint32_t outputInterface) [member function]

  2110     cls.add_method('SetDefaultMulticastRoute',

  2111                    'void',

  2112                    [param('uint32_t', 'outputInterface')],

  2113                    is_pure_virtual=True, is_virtual=True)

  2114     ## ipv4.h: uint32_t ns3::Ipv4::GetNMulticastRoutes() const [member function]

  2115     cls.add_method('GetNMulticastRoutes',

  2116                    'uint32_t',

  2117                    [],

  2118                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2119     ## ipv4.h: ns3::Ipv4MulticastRoute ns3::Ipv4::GetMulticastRoute(uint32_t i) const [member function]

  2120     cls.add_method('GetMulticastRoute',

  2121                    'ns3::Ipv4MulticastRoute',

  2122                    [param('uint32_t', 'i')],

  2123                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2124     ## ipv4.h: void ns3::Ipv4::RemoveMulticastRoute(uint32_t i) [member function]

  2125     cls.add_method('RemoveMulticastRoute',

  2126                    'void',

  2127                    [param('uint32_t', 'i')],

  2128                    is_pure_virtual=True, is_virtual=True)

  2129     ## ipv4.h: uint32_t ns3::Ipv4::AddInterface(ns3::Ptr<ns3::NetDevice> device) [member function]

  2130     cls.add_method('AddInterface',

  2131                    'uint32_t',

  2132                    [param('ns3::Ptr< ns3::NetDevice >', 'device')],

  2133                    is_pure_virtual=True, is_virtual=True)

  2134     ## ipv4.h: uint32_t ns3::Ipv4::GetNInterfaces() [member function]

  2135     cls.add_method('GetNInterfaces',

  2136                    'uint32_t',

  2137                    [],

  2138                    is_pure_virtual=True, is_virtual=True)

  2139     ## ipv4.h: uint32_t ns3::Ipv4::FindInterfaceForAddr(ns3::Ipv4Address addr) const [member function]

  2140     cls.add_method('FindInterfaceForAddr',

  2141                    'uint32_t',

  2142                    [param('ns3::Ipv4Address', 'addr')],

  2143                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2144     ## ipv4.h: uint32_t ns3::Ipv4::FindInterfaceForAddr(ns3::Ipv4Address addr, ns3::Ipv4Mask mask) const [member function]

  2145     cls.add_method('FindInterfaceForAddr',

  2146                    'uint32_t',

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

  2148                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2149     ## ipv4.h: int32_t ns3::Ipv4::FindInterfaceForDevice(ns3::Ptr<ns3::NetDevice> nd) const [member function]

  2150     cls.add_method('FindInterfaceForDevice',

  2151                    'int32_t',

  2152                    [param('ns3::Ptr< ns3::NetDevice >', 'nd')],

  2153                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2154     ## ipv4.h: ns3::Ptr<ns3::NetDevice> ns3::Ipv4::GetNetDevice(uint32_t i) [member function]

  2155     cls.add_method('GetNetDevice',

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

  2157                    [param('uint32_t', 'i')],

  2158                    is_pure_virtual=True, is_virtual=True)

  2159     ## ipv4.h: void ns3::Ipv4::JoinMulticastGroup(ns3::Ipv4Address origin, ns3::Ipv4Address group) [member function]

  2160     cls.add_method('JoinMulticastGroup',

  2161                    'void',

  2162                    [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group')],

  2163                    is_pure_virtual=True, is_virtual=True)

  2164     ## ipv4.h: void ns3::Ipv4::LeaveMulticastGroup(ns3::Ipv4Address origin, ns3::Ipv4Address group) [member function]

  2165     cls.add_method('LeaveMulticastGroup',

  2166                    'void',

  2167                    [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group')],

  2168                    is_pure_virtual=True, is_virtual=True)

  2169     ## ipv4.h: void ns3::Ipv4::SetAddress(uint32_t i, ns3::Ipv4Address address) [member function]

  2170     cls.add_method('SetAddress',

  2171                    'void',

  2172                    [param('uint32_t', 'i'), param('ns3::Ipv4Address', 'address')],

  2173                    is_pure_virtual=True, is_virtual=True)

  2174     ## ipv4.h: void ns3::Ipv4::SetNetworkMask(uint32_t i, ns3::Ipv4Mask mask) [member function]

  2175     cls.add_method('SetNetworkMask',

  2176                    'void',

  2177                    [param('uint32_t', 'i'), param('ns3::Ipv4Mask', 'mask')],

  2178                    is_pure_virtual=True, is_virtual=True)

  2179     ## ipv4.h: ns3::Ipv4Mask ns3::Ipv4::GetNetworkMask(uint32_t i) const [member function]

  2180     cls.add_method('GetNetworkMask',

  2181                    'ns3::Ipv4Mask',

  2182                    [param('uint32_t', 'i')],

  2183                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2184     ## ipv4.h: void ns3::Ipv4::SetMetric(uint32_t i, uint16_t metric) [member function]

  2185     cls.add_method('SetMetric',

  2186                    'void',

  2187                    [param('uint32_t', 'i'), param('uint16_t', 'metric')],

  2188                    is_pure_virtual=True, is_virtual=True)

  2189     ## ipv4.h: uint16_t ns3::Ipv4::GetMetric(uint32_t i) const [member function]

  2190     cls.add_method('GetMetric',

  2191                    'uint16_t',

  2192                    [param('uint32_t', 'i')],

  2193                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2194     ## ipv4.h: ns3::Ipv4Address ns3::Ipv4::GetAddress(uint32_t i) const [member function]

  2195     cls.add_method('GetAddress',

  2196                    'ns3::Ipv4Address',

  2197                    [param('uint32_t', 'i')],

  2198                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2199     ## ipv4.h: ns3::Ipv4Address ns3::Ipv4::GetSourceAddress(ns3::Ipv4Address destination) const [member function]

  2200     cls.add_method('GetSourceAddress',

  2201                    'ns3::Ipv4Address',

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

  2203                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2204     ## ipv4.h: bool ns3::Ipv4::GetIfIndexForDestination(ns3::Ipv4Address dest, uint32_t & ifIndex) const [member function]

  2205     cls.add_method('GetIfIndexForDestination',

  2206                    'bool',

  2207                    [param('ns3::Ipv4Address', 'dest'), param('uint32_t &', 'ifIndex')],

  2208                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2209     ## ipv4.h: uint16_t ns3::Ipv4::GetMtu(uint32_t i) const [member function]

  2210     cls.add_method('GetMtu',

  2211                    'uint16_t',

  2212                    [param('uint32_t', 'i')],

  2213                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2214     ## ipv4.h: bool ns3::Ipv4::IsUp(uint32_t i) const [member function]

  2215     cls.add_method('IsUp',

  2216                    'bool',

  2217                    [param('uint32_t', 'i')],

  2218                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2219     ## ipv4.h: void ns3::Ipv4::SetUp(uint32_t i) [member function]

  2220     cls.add_method('SetUp',

  2221                    'void',

  2222                    [param('uint32_t', 'i')],

  2223                    is_pure_virtual=True, is_virtual=True)

  2224     ## ipv4.h: void ns3::Ipv4::SetDown(uint32_t i) [member function]

  2225     cls.add_method('SetDown',

  2226                    'void',

  2227                    [param('uint32_t', 'i')],

  2228                    is_pure_virtual=True, is_virtual=True)

  2229     ## ipv4.h: uint32_t ns3::Ipv4::GetIfIndexByAddress(ns3::Ipv4Address addr, ns3::Ipv4Mask mask=ns3::Ipv4Mask(((const char*)"255.255.255.255"))) [member function]

  2230     cls.add_method('GetIfIndexByAddress',

  2231                    'uint32_t',

  2232                    [param('ns3::Ipv4Address', 'addr'), param('ns3::Ipv4Mask', 'mask', default_value='ns3::Ipv4Mask(((const char*)"255.255.255.255"))')],

  2233                    is_virtual=True)

  2234     return

  2236 def register_Ns3Ipv4RawSocketFactory_methods(root_module, cls):

  2237     ## ipv4-raw-socket-factory.h: ns3::Ipv4RawSocketFactory::Ipv4RawSocketFactory(ns3::Ipv4RawSocketFactory const & arg0) [copy constructor]

  2238     cls.add_constructor([param('ns3::Ipv4RawSocketFactory const &', 'arg0')])

  2239     ## ipv4-raw-socket-factory.h: ns3::Ipv4RawSocketFactory::Ipv4RawSocketFactory() [constructor]

  2240     cls.add_constructor([])

  2241     ## ipv4-raw-socket-factory.h: static ns3::TypeId ns3::Ipv4RawSocketFactory::GetTypeId() [member function]

  2242     cls.add_method('GetTypeId',

  2243                    'ns3::TypeId',

  2244                    [],

  2245                    is_static=True)

  2246     return

  2248 def register_Ns3Ipv4RoutingProtocol_methods(root_module, cls):

  2249     ## ipv4.h: ns3::Ipv4RoutingProtocol::IF_INDEX_ANY [variable]

  2250     cls.add_static_attribute('IF_INDEX_ANY', 'uint32_t const', is_const=True)

  2251     ## ipv4.h: ns3::Ipv4RoutingProtocol::Ipv4RoutingProtocol(ns3::Ipv4RoutingProtocol const & arg0) [copy constructor]

  2252     cls.add_constructor([param('ns3::Ipv4RoutingProtocol const &', 'arg0')])

  2253     ## ipv4.h: ns3::Ipv4RoutingProtocol::Ipv4RoutingProtocol() [constructor]

  2254     cls.add_constructor([])

  2255     ## ipv4.h: bool ns3::Ipv4RoutingProtocol::RequestRoute(uint32_t ifIndex, ns3::Ipv4Header const & ipHeader, ns3::Ptr<ns3::Packet> packet, ns3::Callback<void,bool,const ns3::Ipv4Route&,ns3::Ptr<ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty> routeReply) [member function]

  2256     cls.add_method('RequestRoute',

  2257                    'bool',

  2258                    [param('uint32_t', 'ifIndex'), param('ns3::Ipv4Header const &', 'ipHeader'), param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Callback< void, bool, ns3::Ipv4Route const &, ns3::Ptr< ns3::Packet >, ns3::Ipv4Header const &, ns3::empty, ns3::empty >', 'routeReply')],

  2259                    is_pure_virtual=True, is_virtual=True)

  2260     ## ipv4.h: bool ns3::Ipv4RoutingProtocol::RequestIfIndex(ns3::Ipv4Address destination, uint32_t & ifIndex) [member function]

  2261     cls.add_method('RequestIfIndex',

  2262                    'bool',

  2263                    [param('ns3::Ipv4Address', 'destination'), param('uint32_t &', 'ifIndex')],

  2264                    is_pure_virtual=True, is_virtual=True)

  2265     return

  2267 def register_Ns3NetDevice_methods(root_module, cls):

  2268     ## net-device.h: ns3::NetDevice::NetDevice(ns3::NetDevice const & arg0) [copy constructor]

  2269     cls.add_constructor([param('ns3::NetDevice const &', 'arg0')])

  2270     ## net-device.h: ns3::NetDevice::NetDevice() [constructor]

  2271     cls.add_constructor([])

  2272     ## net-device.h: static ns3::TypeId ns3::NetDevice::GetTypeId() [member function]

  2273     cls.add_method('GetTypeId',

  2274                    'ns3::TypeId',

  2275                    [],

  2276                    is_static=True)

  2277     ## net-device.h: void ns3::NetDevice::SetName(std::string const name) [member function]

  2278     cls.add_method('SetName',

  2279                    'void',

  2280                    [param('std::string const', 'name')],

  2281                    is_pure_virtual=True, is_virtual=True)

  2282     ## net-device.h: std::string ns3::NetDevice::GetName() const [member function]

  2283     cls.add_method('GetName',

  2284                    'std::string',

  2285                    [],

  2286                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2287     ## net-device.h: void ns3::NetDevice::SetIfIndex(uint32_t const index) [member function]

  2288     cls.add_method('SetIfIndex',

  2289                    'void',

  2290                    [param('uint32_t const', 'index')],

  2291                    is_pure_virtual=True, is_virtual=True)

  2292     ## net-device.h: uint32_t ns3::NetDevice::GetIfIndex() const [member function]

  2293     cls.add_method('GetIfIndex',

  2294                    'uint32_t',

  2295                    [],

  2296                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2297     ## net-device.h: ns3::Ptr<ns3::Channel> ns3::NetDevice::GetChannel() const [member function]

  2298     cls.add_method('GetChannel',

  2299                    'ns3::Ptr< ns3::Channel >',

  2300                    [],

  2301                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2302     ## net-device.h: ns3::Address ns3::NetDevice::GetAddress() const [member function]

  2303     cls.add_method('GetAddress',

  2304                    'ns3::Address',

  2305                    [],

  2306                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2307     ## net-device.h: bool ns3::NetDevice::SetMtu(uint16_t const mtu) [member function]

  2308     cls.add_method('SetMtu',

  2309                    'bool',

  2310                    [param('uint16_t const', 'mtu')],

  2311                    is_pure_virtual=True, is_virtual=True)

  2312     ## net-device.h: uint16_t ns3::NetDevice::GetMtu() const [member function]

  2313     cls.add_method('GetMtu',

  2314                    'uint16_t',

  2315                    [],

  2316                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2317     ## net-device.h: bool ns3::NetDevice::IsLinkUp() const [member function]

  2318     cls.add_method('IsLinkUp',

  2319                    'bool',

  2320                    [],

  2321                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2322     ## net-device.h: void ns3::NetDevice::SetLinkChangeCallback(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function]

  2323     cls.add_method('SetLinkChangeCallback',

  2324                    'void',

  2325                    [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')],

  2326                    is_pure_virtual=True, is_virtual=True)

  2327     ## net-device.h: bool ns3::NetDevice::IsBroadcast() const [member function]

  2328     cls.add_method('IsBroadcast',

  2329                    'bool',

  2330                    [],

  2331                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2332     ## net-device.h: ns3::Address ns3::NetDevice::GetBroadcast() const [member function]

  2333     cls.add_method('GetBroadcast',

  2334                    'ns3::Address',

  2335                    [],

  2336                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2337     ## net-device.h: bool ns3::NetDevice::IsMulticast() const [member function]

  2338     cls.add_method('IsMulticast',

  2339                    'bool',

  2340                    [],

  2341                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2342     ## net-device.h: ns3::Address ns3::NetDevice::GetMulticast(ns3::Ipv4Address multicastGroup) const [member function]

  2343     cls.add_method('GetMulticast',

  2344                    'ns3::Address',

  2345                    [param('ns3::Ipv4Address', 'multicastGroup')],

  2346                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2347     ## net-device.h: bool ns3::NetDevice::IsPointToPoint() const [member function]

  2348     cls.add_method('IsPointToPoint',

  2349                    'bool',

  2350                    [],

  2351                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2352     ## net-device.h: bool ns3::NetDevice::Send(ns3::Ptr<ns3::Packet> packet, ns3::Address const & dest, uint16_t protocolNumber) [member function]

  2353     cls.add_method('Send',

  2354                    'bool',

  2355                    [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')],

  2356                    is_pure_virtual=True, is_virtual=True)

  2357     ## 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]

  2358     cls.add_method('SendFrom',

  2359                    'bool',

  2360                    [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'source'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')],

  2361                    is_pure_virtual=True, is_virtual=True)

  2362     ## net-device.h: ns3::Ptr<ns3::Node> ns3::NetDevice::GetNode() const [member function]

  2363     cls.add_method('GetNode',

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

  2365                    [],

  2366                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2367     ## net-device.h: void ns3::NetDevice::SetNode(ns3::Ptr<ns3::Node> node) [member function]

  2368     cls.add_method('SetNode',

  2369                    'void',

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

  2371                    is_pure_virtual=True, is_virtual=True)

  2372     ## net-device.h: bool ns3::NetDevice::NeedsArp() const [member function]

  2373     cls.add_method('NeedsArp',

  2374                    'bool',

  2375                    [],

  2376                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2377     ## 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> cb) [member function]

  2378     cls.add_method('SetReceiveCallback',

  2379                    'void',

  2380                    [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty >', 'cb')],

  2381                    is_pure_virtual=True, is_virtual=True)

  2382     ## 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> cb) [member function]

  2383     cls.add_method('SetPromiscReceiveCallback',

  2384                    'void',

  2385                    [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType >', 'cb')],

  2386                    is_pure_virtual=True, is_virtual=True)

  2387     ## net-device.h: bool ns3::NetDevice::SupportsSendFrom() const [member function]

  2388     cls.add_method('SupportsSendFrom',

  2389                    'bool',

  2390                    [],

  2391                    is_pure_virtual=True, is_const=True, is_virtual=True)

  2392     return

  2394 def register_Ns3Node_methods(root_module, cls):

  2395     ## node.h: ns3::Node::Node(ns3::Node const & arg0) [copy constructor]

  2396     cls.add_constructor([param('ns3::Node const &', 'arg0')])

  2397     ## node.h: static ns3::TypeId ns3::Node::GetTypeId() [member function]

  2398     cls.add_method('GetTypeId',

  2399                    'ns3::TypeId',

  2400                    [],

  2401                    is_static=True)

  2402     ## node.h: ns3::Node::Node() [constructor]

  2403     cls.add_constructor([])

  2404     ## node.h: ns3::Node::Node(uint32_t systemId) [constructor]

  2405     cls.add_constructor([param('uint32_t', 'systemId')])

  2406     ## node.h: uint32_t ns3::Node::GetId() const [member function]

  2407     cls.add_method('GetId',

  2408                    'uint32_t',

  2409                    [],

  2410                    is_const=True)

  2411     ## node.h: uint32_t ns3::Node::GetSystemId() const [member function]

  2412     cls.add_method('GetSystemId',

  2413                    'uint32_t',

  2414                    [],

  2415                    is_const=True)

  2416     ## node.h: uint32_t ns3::Node::AddDevice(ns3::Ptr<ns3::NetDevice> device) [member function]

  2417     cls.add_method('AddDevice',

  2418                    'uint32_t',

  2419                    [param('ns3::Ptr< ns3::NetDevice >', 'device')])

  2420     ## node.h: ns3::Ptr<ns3::NetDevice> ns3::Node::GetDevice(uint32_t index) const [member function]

  2421     cls.add_method('GetDevice',

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

  2423                    [param('uint32_t', 'index')],

  2424                    is_const=True)

  2425     ## node.h: uint32_t ns3::Node::GetNDevices() const [member function]

  2426     cls.add_method('GetNDevices',

  2427                    'uint32_t',

  2428                    [],

  2429                    is_const=True)

  2430     ## node.h: uint32_t ns3::Node::AddApplication(ns3::Ptr<ns3::Application> application) [member function]

  2431     cls.add_method('AddApplication',

  2432                    'uint32_t',

  2433                    [param('ns3::Ptr< ns3::Application >', 'application')])

  2434     ## node.h: ns3::Ptr<ns3::Application> ns3::Node::GetApplication(uint32_t index) const [member function]

  2435     cls.add_method('GetApplication',

  2436                    'ns3::Ptr< ns3::Application >',

  2437                    [param('uint32_t', 'index')],

  2438                    is_const=True)

  2439     ## node.h: uint32_t ns3::Node::GetNApplications() const [member function]

  2440     cls.add_method('GetNApplications',

  2441                    'uint32_t',

  2442                    [],

  2443                    is_const=True)

  2444     ## 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> handler, uint16_t protocolType, ns3::Ptr<ns3::NetDevice> device, bool promiscuous=false) [member function]

  2445     cls.add_method('RegisterProtocolHandler',

  2446                    'void',

  2447                    [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType >', 'handler'), param('uint16_t', 'protocolType'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'promiscuous', default_value='false')])

  2448     ## 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> handler) [member function]

  2449     cls.add_method('UnregisterProtocolHandler',

  2450                    'void',

  2451                    [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType >', 'handler')])

  2452     ## node.h: void ns3::Node::DoDispose() [member function]

  2453     cls.add_method('DoDispose',

  2454                    'void',

  2455                    [],

  2456                    visibility='protected', is_virtual=True)

  2457     ## node.h: void ns3::Node::NotifyDeviceAdded(ns3::Ptr<ns3::NetDevice> device) [member function]

  2458     cls.add_method('NotifyDeviceAdded',

  2459                    'void',

  2460                    [param('ns3::Ptr< ns3::NetDevice >', 'device')],

  2461                    visibility='private', is_virtual=True)

  2462     return

  2464 def register_Ns3PacketSocketFactory_methods(root_module, cls):

  2465     ## packet-socket-factory.h: ns3::PacketSocketFactory::PacketSocketFactory(ns3::PacketSocketFactory const & arg0) [copy constructor]

  2466     cls.add_constructor([param('ns3::PacketSocketFactory const &', 'arg0')])

  2467     ## packet-socket-factory.h: static ns3::TypeId ns3::PacketSocketFactory::GetTypeId() [member function]

  2468     cls.add_method('GetTypeId',

  2469                    'ns3::TypeId',

  2470                    [],

  2471                    is_static=True)

  2472     ## packet-socket-factory.h: ns3::PacketSocketFactory::PacketSocketFactory() [constructor]

  2473     cls.add_constructor([])

  2474     ## packet-socket-factory.h: ns3::Ptr<ns3::Socket> ns3::PacketSocketFactory::CreateSocket() [member function]

  2475     cls.add_method('CreateSocket',

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

  2477                    [],

  2478                    is_virtual=True)

  2479     return

  2481 def register_Ns3SimpleChannel_methods(root_module, cls):

  2482     ## simple-channel.h: ns3::SimpleChannel::SimpleChannel(ns3::SimpleChannel const & arg0) [copy constructor]

  2483     cls.add_constructor([param('ns3::SimpleChannel const &', 'arg0')])

  2484     ## simple-channel.h: static ns3::TypeId ns3::SimpleChannel::GetTypeId() [member function]

  2485     cls.add_method('GetTypeId',

  2486                    'ns3::TypeId',

  2487                    [],

  2488                    is_static=True)

  2489     ## simple-channel.h: ns3::SimpleChannel::SimpleChannel() [constructor]

  2490     cls.add_constructor([])

  2491     ## 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]

  2492     cls.add_method('Send',

  2493                    'void',

  2494                    [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint16_t', 'protocol'), param('ns3::Mac48Address', 'to'), param('ns3::Mac48Address', 'from'), param('ns3::Ptr< ns3::SimpleNetDevice >', 'sender')])

  2495     ## simple-channel.h: void ns3::SimpleChannel::Add(ns3::Ptr<ns3::SimpleNetDevice> device) [member function]

  2496     cls.add_method('Add',

  2497                    'void',

  2498                    [param('ns3::Ptr< ns3::SimpleNetDevice >', 'device')])

  2499     ## simple-channel.h: uint32_t ns3::SimpleChannel::GetNDevices() const [member function]

  2500     cls.add_method('GetNDevices',

  2501                    'uint32_t',

  2502                    [],

  2503                    is_const=True, is_virtual=True)

  2504     ## simple-channel.h: ns3::Ptr<ns3::NetDevice> ns3::SimpleChannel::GetDevice(uint32_t i) const [member function]

  2505     cls.add_method('GetDevice',

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

  2507                    [param('uint32_t', 'i')],

  2508                    is_const=True, is_virtual=True)

  2509     return

  2511 def register_Ns3SimpleNetDevice_methods(root_module, cls):

  2512     ## simple-net-device.h: ns3::SimpleNetDevice::SimpleNetDevice(ns3::SimpleNetDevice const & arg0) [copy constructor]

  2513     cls.add_constructor([param('ns3::SimpleNetDevice const &', 'arg0')])

  2514     ## simple-net-device.h: static ns3::TypeId ns3::SimpleNetDevice::GetTypeId() [member function]

  2515     cls.add_method('GetTypeId',

  2516                    'ns3::TypeId',

  2517                    [],

  2518                    is_static=True)

  2519     ## simple-net-device.h: ns3::SimpleNetDevice::SimpleNetDevice() [constructor]

  2520     cls.add_constructor([])

  2521     ## simple-net-device.h: void ns3::SimpleNetDevice::Receive(ns3::Ptr<ns3::Packet> packet, uint16_t protocol, ns3::Mac48Address to, ns3::Mac48Address from) [member function]

  2522     cls.add_method('Receive',

  2523                    'void',

  2524                    [param('ns3::Ptr< ns3::Packet >', 'packet'), param('uint16_t', 'protocol'), param('ns3::Mac48Address', 'to'), param('ns3::Mac48Address', 'from')])

  2525     ## simple-net-device.h: void ns3::SimpleNetDevice::SetChannel(ns3::Ptr<ns3::SimpleChannel> channel) [member function]

  2526     cls.add_method('SetChannel',

  2527                    'void',

  2528                    [param('ns3::Ptr< ns3::SimpleChannel >', 'channel')])

  2529     ## simple-net-device.h: void ns3::SimpleNetDevice::SetAddress(ns3::Mac48Address address) [member function]

  2530     cls.add_method('SetAddress',

  2531                    'void',

  2532                    [param('ns3::Mac48Address', 'address')])

  2533     ## simple-net-device.h: void ns3::SimpleNetDevice::SetName(std::string const name) [member function]

  2534     cls.add_method('SetName',

  2535                    'void',

  2536                    [param('std::string const', 'name')],

  2537                    is_virtual=True)

  2538     ## simple-net-device.h: std::string ns3::SimpleNetDevice::GetName() const [member function]

  2539     cls.add_method('GetName',

  2540                    'std::string',

  2541                    [],

  2542                    is_const=True, is_virtual=True)

  2543     ## simple-net-device.h: void ns3::SimpleNetDevice::SetIfIndex(uint32_t const index) [member function]

  2544     cls.add_method('SetIfIndex',

  2545                    'void',

  2546                    [param('uint32_t const', 'index')],

  2547                    is_virtual=True)

  2548     ## simple-net-device.h: uint32_t ns3::SimpleNetDevice::GetIfIndex() const [member function]

  2549     cls.add_method('GetIfIndex',

  2550                    'uint32_t',

  2551                    [],

  2552                    is_const=True, is_virtual=True)

  2553     ## simple-net-device.h: ns3::Ptr<ns3::Channel> ns3::SimpleNetDevice::GetChannel() const [member function]

  2554     cls.add_method('GetChannel',

  2555                    'ns3::Ptr< ns3::Channel >',

  2556                    [],

  2557                    is_const=True, is_virtual=True)

  2558     ## simple-net-device.h: ns3::Address ns3::SimpleNetDevice::GetAddress() const [member function]

  2559     cls.add_method('GetAddress',

  2560                    'ns3::Address',

  2561                    [],

  2562                    is_const=True, is_virtual=True)

  2563     ## simple-net-device.h: bool ns3::SimpleNetDevice::SetMtu(uint16_t const mtu) [member function]

  2564     cls.add_method('SetMtu',

  2565                    'bool',

  2566                    [param('uint16_t const', 'mtu')],

  2567                    is_virtual=True)

  2568     ## simple-net-device.h: uint16_t ns3::SimpleNetDevice::GetMtu() const [member function]

  2569     cls.add_method('GetMtu',

  2570                    'uint16_t',

  2571                    [],

  2572                    is_const=True, is_virtual=True)

  2573     ## simple-net-device.h: bool ns3::SimpleNetDevice::IsLinkUp() const [member function]

  2574     cls.add_method('IsLinkUp',

  2575                    'bool',

  2576                    [],

  2577                    is_const=True, is_virtual=True)

  2578     ## simple-net-device.h: void ns3::SimpleNetDevice::SetLinkChangeCallback(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function]

  2579     cls.add_method('SetLinkChangeCallback',

  2580                    'void',

  2581                    [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')],

  2582                    is_virtual=True)

  2583     ## simple-net-device.h: bool ns3::SimpleNetDevice::IsBroadcast() const [member function]

  2584     cls.add_method('IsBroadcast',

  2585                    'bool',

  2586                    [],

  2587                    is_const=True, is_virtual=True)

  2588     ## simple-net-device.h: ns3::Address ns3::SimpleNetDevice::GetBroadcast() const [member function]

  2589     cls.add_method('GetBroadcast',

  2590                    'ns3::Address',

  2591                    [],

  2592                    is_const=True, is_virtual=True)

  2593     ## simple-net-device.h: bool ns3::SimpleNetDevice::IsMulticast() const [member function]

  2594     cls.add_method('IsMulticast',

  2595                    'bool',

  2596                    [],

  2597                    is_const=True, is_virtual=True)

  2598     ## simple-net-device.h: ns3::Address ns3::SimpleNetDevice::GetMulticast(ns3::Ipv4Address multicastGroup) const [member function]

  2599     cls.add_method('GetMulticast',

  2600                    'ns3::Address',

  2601                    [param('ns3::Ipv4Address', 'multicastGroup')],

  2602                    is_const=True, is_virtual=True)

  2603     ## simple-net-device.h: bool ns3::SimpleNetDevice::IsPointToPoint() const [member function]

  2604     cls.add_method('IsPointToPoint',

  2605                    'bool',

  2606                    [],

  2607                    is_const=True, is_virtual=True)

  2608     ## simple-net-device.h: bool ns3::SimpleNetDevice::Send(ns3::Ptr<ns3::Packet> packet, ns3::Address const & dest, uint16_t protocolNumber) [member function]

  2609     cls.add_method('Send',

  2610                    'bool',

  2611                    [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')],

  2612                    is_virtual=True)

  2613     ## 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]

  2614     cls.add_method('SendFrom',

  2615                    'bool',

  2616                    [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'source'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')],

  2617                    is_virtual=True)

  2618     ## simple-net-device.h: ns3::Ptr<ns3::Node> ns3::SimpleNetDevice::GetNode() const [member function]

  2619     cls.add_method('GetNode',

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

  2621                    [],

  2622                    is_const=True, is_virtual=True)

  2623     ## simple-net-device.h: void ns3::SimpleNetDevice::SetNode(ns3::Ptr<ns3::Node> node) [member function]

  2624     cls.add_method('SetNode',

  2625                    'void',

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

  2627                    is_virtual=True)

  2628     ## simple-net-device.h: bool ns3::SimpleNetDevice::NeedsArp() const [member function]

  2629     cls.add_method('NeedsArp',

  2630                    'bool',

  2631                    [],

  2632                    is_const=True, is_virtual=True)

  2633     ## 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> cb) [member function]

  2634     cls.add_method('SetReceiveCallback',

  2635                    'void',

  2636                    [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty >', 'cb')],

  2637                    is_virtual=True)

  2638     ## 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> cb) [member function]

  2639     cls.add_method('SetPromiscReceiveCallback',

  2640                    'void',

  2641                    [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType >', 'cb')],

  2642                    is_virtual=True)

  2643     ## simple-net-device.h: bool ns3::SimpleNetDevice::SupportsSendFrom() const [member function]

  2644     cls.add_method('SupportsSendFrom',

  2645                    'bool',

  2646                    [],

  2647                    is_const=True, is_virtual=True)

  2648     ## simple-net-device.h: void ns3::SimpleNetDevice::DoDispose() [member function]

  2649     cls.add_method('DoDispose',

  2650                    'void',

  2651                    [],

  2652                    visibility='protected', is_virtual=True)

  2653     return

  2655 def register_functions(root_module):

  2656     module = root_module

  2657     ## mac48-address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeMac48AddressChecker() [free function]

  2658     module.add_function('MakeMac48AddressChecker',

  2659                         'ns3::Ptr< ns3::AttributeChecker const >',

  2660                         [])

  2661     ## ipv4-address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeIpv4AddressChecker() [free function]

  2662     module.add_function('MakeIpv4AddressChecker',

  2663                         'ns3::Ptr< ns3::AttributeChecker const >',

  2664                         [])

  2665     ## address-utils.h: extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Mac48Address ad) [free function]

  2666     module.add_function('WriteTo',

  2667                         'void',

  2668                         [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Mac48Address', 'ad')])

  2669     ## address-utils.h: extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Address const & ad) [free function]

  2670     module.add_function('WriteTo',

  2671                         'void',

  2672                         [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Address const &', 'ad')])

  2673     ## address-utils.h: extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Ipv4Address ad) [free function]

  2674     module.add_function('WriteTo',

  2675                         'void',

  2676                         [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Ipv4Address', 'ad')])

  2677     ## address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeAddressChecker() [free function]

  2678     module.add_function('MakeAddressChecker',

  2679                         'ns3::Ptr< ns3::AttributeChecker const >',

  2680                         [])

  2681     ## ipv4-address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeIpv4MaskChecker() [free function]

  2682     module.add_function('MakeIpv4MaskChecker',

  2683                         'ns3::Ptr< ns3::AttributeChecker const >',

  2684                         [])

  2685     ## address-utils.h: extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Mac48Address & ad) [free function]

  2686     module.add_function('ReadFrom',

  2687                         'void',

  2688                         [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Mac48Address &', 'ad')])

  2689     ## address-utils.h: extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Address & ad, uint32_t len) [free function]

  2690     module.add_function('ReadFrom',

  2691                         'void',

  2692                         [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Address &', 'ad'), param('uint32_t', 'len')])

  2693     ## address-utils.h: extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Ipv4Address & ad) [free function]

  2694     module.add_function('ReadFrom',

  2695                         'void',

  2696                         [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Ipv4Address &', 'ad')])

  2697     register_functions_ns3_internal(module.get_submodule('internal'), root_module)

  2698     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)

  2699     register_functions_ns3_Config(module.get_submodule('Config'), root_module)

  2700     register_functions_ns3_olsr(module.get_submodule('olsr'), root_module)

  2701     return

  2703 def register_functions_ns3_internal(module, root_module):

  2704     return

  2706 def register_functions_ns3_TimeStepPrecision(module, root_module):

  2707     return

  2709 def register_functions_ns3_Config(module, root_module):

  2710     return

  2712 def register_functions_ns3_olsr(module, root_module):

  2713     return

author	vincent@clarinet.u-strasbg.fr
	Wed, 05 Nov 2008 14:49:21 -0800
changeset 3842	545ddf9398ed
parent 3820	c04ecfdce1ef
child 3855	7fdcbeea6c4f
permissions	-rw-r--r--