bindings/python/ns3_module_node.py
changeset 3567 728eb3f583b3
parent 3552 b822851cb95d
child 3574 b6804efbe16b
equal deleted inserted replaced
3566:b96af8dc8abf 3567:728eb3f583b3
     3 def register_types(module):
     3 def register_types(module):
     4     root_module = module.get_root()
     4     root_module = module.get_root()
     5     
     5     
     6     ## ethernet-header.h: ns3::ethernet_header_t [enumeration]
     6     ## ethernet-header.h: ns3::ethernet_header_t [enumeration]
     7     module.add_enum('ethernet_header_t', ['LENGTH', 'VLAN', 'QINQ'])
     7     module.add_enum('ethernet_header_t', ['LENGTH', 'VLAN', 'QINQ'])
       
     8     ## ipv4-address.h: ns3::Ipv4Mask [class]
       
     9     module.add_class('Ipv4Mask')
     8     ## node-list.h: ns3::NodeList [class]
    10     ## node-list.h: ns3::NodeList [class]
     9     module.add_class('NodeList')
    11     module.add_class('NodeList')
    10     ## address.h: ns3::Address [class]
    12     ## address.h: ns3::Address [class]
    11     module.add_class('Address')
    13     module.add_class('Address')
    12     ## address.h: ns3::Address::MaxSize_e [enumeration]
    14     ## address.h: ns3::Address::MaxSize_e [enumeration]
    35     module.add_class('AddressChecker', parent=root_module['ns3::AttributeChecker'])
    37     module.add_class('AddressChecker', parent=root_module['ns3::AttributeChecker'])
    36     ## packet-socket-address.h: ns3::PacketSocketAddress [class]
    38     ## packet-socket-address.h: ns3::PacketSocketAddress [class]
    37     module.add_class('PacketSocketAddress')
    39     module.add_class('PacketSocketAddress')
    38     ## packet-socket-address.h: ns3::PacketSocketAddress [class]
    40     ## packet-socket-address.h: ns3::PacketSocketAddress [class]
    39     root_module['ns3::PacketSocketAddress'].implicitly_converts_to(root_module['ns3::Address'])
    41     root_module['ns3::PacketSocketAddress'].implicitly_converts_to(root_module['ns3::Address'])
    40     ## ipv4-address.h: ns3::Ipv4Mask [class]
       
    41     module.add_class('Ipv4Mask')
       
    42     ## ipv4-address.h: ns3::Ipv4AddressValue [class]
    42     ## ipv4-address.h: ns3::Ipv4AddressValue [class]
    43     module.add_class('Ipv4AddressValue', parent=root_module['ns3::AttributeValue'])
    43     module.add_class('Ipv4AddressValue', parent=root_module['ns3::AttributeValue'])
    44     ## ipv4.h: ns3::Ipv4RoutingProtocol [class]
    44     ## ipv4.h: ns3::Ipv4RoutingProtocol [class]
    45     module.add_class('Ipv4RoutingProtocol', parent=root_module['ns3::Object'])
    45     module.add_class('Ipv4RoutingProtocol', parent=root_module['ns3::Object'])
    46     ## mac48-address.h: ns3::Mac48AddressValue [class]
    46     ## mac48-address.h: ns3::Mac48AddressValue [class]
   145 def register_types_ns3_olsr(module):
   145 def register_types_ns3_olsr(module):
   146     root_module = module.get_root()
   146     root_module = module.get_root()
   147     
   147     
   148 
   148 
   149 def register_methods(root_module):
   149 def register_methods(root_module):
       
   150     register_Ns3Ipv4Mask_methods(root_module, root_module['ns3::Ipv4Mask'])
   150     register_Ns3NodeList_methods(root_module, root_module['ns3::NodeList'])
   151     register_Ns3NodeList_methods(root_module, root_module['ns3::NodeList'])
   151     register_Ns3Address_methods(root_module, root_module['ns3::Address'])
   152     register_Ns3Address_methods(root_module, root_module['ns3::Address'])
   152     register_Ns3Ipv4AddressChecker_methods(root_module, root_module['ns3::Ipv4AddressChecker'])
   153     register_Ns3Ipv4AddressChecker_methods(root_module, root_module['ns3::Ipv4AddressChecker'])
   153     register_Ns3Mac48Address_methods(root_module, root_module['ns3::Mac48Address'])
   154     register_Ns3Mac48Address_methods(root_module, root_module['ns3::Mac48Address'])
   154     register_Ns3Mac64Address_methods(root_module, root_module['ns3::Mac64Address'])
   155     register_Ns3Mac64Address_methods(root_module, root_module['ns3::Mac64Address'])
   157     register_Ns3Ipv4MaskChecker_methods(root_module, root_module['ns3::Ipv4MaskChecker'])
   158     register_Ns3Ipv4MaskChecker_methods(root_module, root_module['ns3::Ipv4MaskChecker'])
   158     register_Ns3Ipv4Route_methods(root_module, root_module['ns3::Ipv4Route'])
   159     register_Ns3Ipv4Route_methods(root_module, root_module['ns3::Ipv4Route'])
   159     register_Ns3Ipv4MulticastRoute_methods(root_module, root_module['ns3::Ipv4MulticastRoute'])
   160     register_Ns3Ipv4MulticastRoute_methods(root_module, root_module['ns3::Ipv4MulticastRoute'])
   160     register_Ns3AddressChecker_methods(root_module, root_module['ns3::AddressChecker'])
   161     register_Ns3AddressChecker_methods(root_module, root_module['ns3::AddressChecker'])
   161     register_Ns3PacketSocketAddress_methods(root_module, root_module['ns3::PacketSocketAddress'])
   162     register_Ns3PacketSocketAddress_methods(root_module, root_module['ns3::PacketSocketAddress'])
   162     register_Ns3Ipv4Mask_methods(root_module, root_module['ns3::Ipv4Mask'])
       
   163     register_Ns3Ipv4AddressValue_methods(root_module, root_module['ns3::Ipv4AddressValue'])
   163     register_Ns3Ipv4AddressValue_methods(root_module, root_module['ns3::Ipv4AddressValue'])
   164     register_Ns3Ipv4RoutingProtocol_methods(root_module, root_module['ns3::Ipv4RoutingProtocol'])
   164     register_Ns3Ipv4RoutingProtocol_methods(root_module, root_module['ns3::Ipv4RoutingProtocol'])
   165     register_Ns3Mac48AddressValue_methods(root_module, root_module['ns3::Mac48AddressValue'])
   165     register_Ns3Mac48AddressValue_methods(root_module, root_module['ns3::Mac48AddressValue'])
   166     register_Ns3Ipv4MaskValue_methods(root_module, root_module['ns3::Ipv4MaskValue'])
   166     register_Ns3Ipv4MaskValue_methods(root_module, root_module['ns3::Ipv4MaskValue'])
   167     register_Ns3SocketAddressTag_methods(root_module, root_module['ns3::SocketAddressTag'])
   167     register_Ns3SocketAddressTag_methods(root_module, root_module['ns3::SocketAddressTag'])
   189     register_Ns3SimpleNetDevice_methods(root_module, root_module['ns3::SimpleNetDevice'])
   189     register_Ns3SimpleNetDevice_methods(root_module, root_module['ns3::SimpleNetDevice'])
   190     register_Ns3TcpSocketFactory_methods(root_module, root_module['ns3::TcpSocketFactory'])
   190     register_Ns3TcpSocketFactory_methods(root_module, root_module['ns3::TcpSocketFactory'])
   191     register_Ns3PacketSocketFactory_methods(root_module, root_module['ns3::PacketSocketFactory'])
   191     register_Ns3PacketSocketFactory_methods(root_module, root_module['ns3::PacketSocketFactory'])
   192     return
   192     return
   193 
   193 
       
   194 def register_Ns3Ipv4Mask_methods(root_module, cls):
       
   195     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [copy constructor]
       
   196     cls.add_constructor([param('ns3::Ipv4Mask&', 'arg0', is_const=True)])
       
   197     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask() [constructor]
       
   198     cls.add_constructor([])
       
   199     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(uint32_t mask) [constructor]
       
   200     cls.add_constructor([param('uint32_t', 'mask')])
       
   201     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(char const * mask) [constructor]
       
   202     cls.add_constructor([param('char *', 'mask', transfer_ownership=False, is_const=True)])
       
   203     ## ipv4-address.h: uint32_t ns3::Ipv4Mask::Get() const [member function]
       
   204     cls.add_method('Get', 
       
   205                    'uint32_t', 
       
   206                    [], 
       
   207                    is_const=True)
       
   208     ## ipv4-address.h: uint32_t ns3::Ipv4Mask::GetInverse() const [member function]
       
   209     cls.add_method('GetInverse', 
       
   210                    'uint32_t', 
       
   211                    [], 
       
   212                    is_const=True)
       
   213     ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetLoopback() [member function]
       
   214     cls.add_method('GetLoopback', 
       
   215                    'ns3::Ipv4Mask', 
       
   216                    [], 
       
   217                    is_static=True)
       
   218     ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetZero() [member function]
       
   219     cls.add_method('GetZero', 
       
   220                    'ns3::Ipv4Mask', 
       
   221                    [], 
       
   222                    is_static=True)
       
   223     ## ipv4-address.h: bool ns3::Ipv4Mask::IsEqual(ns3::Ipv4Mask other) const [member function]
       
   224     cls.add_method('IsEqual', 
       
   225                    'bool', 
       
   226                    [param('ns3::Ipv4Mask', 'other')], 
       
   227                    is_const=True)
       
   228     ## ipv4-address.h: bool ns3::Ipv4Mask::IsMatch(ns3::Ipv4Address a, ns3::Ipv4Address b) const [member function]
       
   229     cls.add_method('IsMatch', 
       
   230                    'bool', 
       
   231                    [param('ns3::Ipv4Address', 'a'), param('ns3::Ipv4Address', 'b')], 
       
   232                    is_const=True)
       
   233     ## ipv4-address.h: void ns3::Ipv4Mask::Print(std::ostream & os) const [member function]
       
   234     cls.add_method('Print', 
       
   235                    'void', 
       
   236                    [param('std::ostream&', 'os')], 
       
   237                    is_const=True)
       
   238     ## ipv4-address.h: void ns3::Ipv4Mask::Set(uint32_t mask) [member function]
       
   239     cls.add_method('Set', 
       
   240                    'void', 
       
   241                    [param('uint32_t', 'mask')])
       
   242     cls.add_output_stream_operator()
       
   243     return
       
   244 
   194 def register_Ns3NodeList_methods(root_module, cls):
   245 def register_Ns3NodeList_methods(root_module, cls):
       
   246     ## node-list.h: ns3::NodeList::NodeList(ns3::NodeList const & arg0) [copy constructor]
       
   247     cls.add_constructor([param('ns3::NodeList&', 'arg0', is_const=True)])
       
   248     ## node-list.h: ns3::NodeList::NodeList() [constructor]
       
   249     cls.add_constructor([])
   195     ## node-list.h: static uint32_t ns3::NodeList::Add(ns3::Ptr<ns3::Node> node) [member function]
   250     ## node-list.h: static uint32_t ns3::NodeList::Add(ns3::Ptr<ns3::Node> node) [member function]
   196     cls.add_method('Add', 
   251     cls.add_method('Add', 
   197                    'uint32_t', 
   252                    'uint32_t', 
   198                    [param('ns3::Ptr< ns3::Node >', 'node')], 
   253                    [param('ns3::Ptr< ns3::Node >', 'node')], 
   199                    is_static=True)
   254                    is_static=True)
   200     ## 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]
   255     ## 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]
   201     cls.add_method('Begin', 
   256     cls.add_method('Begin', 
   202                    '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node >, std::allocator< ns3::Ptr< ns3::Node > > > >', 
   257                    '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node > > >', 
   203                    [], 
   258                    [], 
   204                    is_static=True)
   259                    is_static=True)
   205     ## 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]
   260     ## 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]
   206     cls.add_method('End', 
   261     cls.add_method('End', 
   207                    '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node >, std::allocator< ns3::Ptr< ns3::Node > > > >', 
   262                    '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node > > >', 
   208                    [], 
   263                    [], 
   209                    is_static=True)
   264                    is_static=True)
   210     ## node-list.h: static ns3::Ptr<ns3::Node> ns3::NodeList::GetNode(uint32_t n) [member function]
   265     ## node-list.h: static ns3::Ptr<ns3::Node> ns3::NodeList::GetNode(uint32_t n) [member function]
   211     cls.add_method('GetNode', 
   266     cls.add_method('GetNode', 
   212                    'ns3::Ptr< ns3::Node >', 
   267                    'ns3::Ptr< ns3::Node >', 
   215     ## node-list.h: static uint32_t ns3::NodeList::GetNNodes() [member function]
   270     ## node-list.h: static uint32_t ns3::NodeList::GetNNodes() [member function]
   216     cls.add_method('GetNNodes', 
   271     cls.add_method('GetNNodes', 
   217                    'uint32_t', 
   272                    'uint32_t', 
   218                    [], 
   273                    [], 
   219                    is_static=True)
   274                    is_static=True)
   220     cls.add_constructor([])
       
   221     cls.add_copy_constructor()
       
   222     return
   275     return
   223 
   276 
   224 def register_Ns3Address_methods(root_module, cls):
   277 def register_Ns3Address_methods(root_module, cls):
   225     ## address.h: ns3::Address::Address() [constructor]
   278     ## address.h: ns3::Address::Address() [constructor]
   226     cls.add_constructor([])
   279     cls.add_constructor([])
   287                    is_const=True)
   340                    is_const=True)
   288     cls.add_output_stream_operator()
   341     cls.add_output_stream_operator()
   289     return
   342     return
   290 
   343 
   291 def register_Ns3Ipv4AddressChecker_methods(root_module, cls):
   344 def register_Ns3Ipv4AddressChecker_methods(root_module, cls):
   292     cls.add_constructor([])
   345     ## ipv4-address.h: ns3::Ipv4AddressChecker::Ipv4AddressChecker(ns3::Ipv4AddressChecker const & arg0) [copy constructor]
   293     cls.add_copy_constructor()
   346     cls.add_constructor([param('ns3::Ipv4AddressChecker&', 'arg0', is_const=True)])
       
   347     ## ipv4-address.h: ns3::Ipv4AddressChecker::Ipv4AddressChecker() [constructor]
       
   348     cls.add_constructor([])
   294     return
   349     return
   295 
   350 
   296 def register_Ns3Mac48Address_methods(root_module, cls):
   351 def register_Ns3Mac48Address_methods(root_module, cls):
   297     ## mac48-address.h: ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [copy constructor]
   352     ## mac48-address.h: ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [copy constructor]
   298     cls.add_constructor([param('ns3::Mac48Address&', 'arg0', is_const=True)])
   353     cls.add_constructor([param('ns3::Mac48Address&', 'arg0', is_const=True)])
   322     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::GetBroadcast() [member function]
   377     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::GetBroadcast() [member function]
   323     cls.add_method('GetBroadcast', 
   378     cls.add_method('GetBroadcast', 
   324                    'ns3::Mac48Address', 
   379                    'ns3::Mac48Address', 
   325                    [], 
   380                    [], 
   326                    is_static=True)
   381                    is_static=True)
       
   382     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::GetMulticast(ns3::Ipv4Address address) [member function]
       
   383     cls.add_method('GetMulticast', 
       
   384                    'ns3::Mac48Address', 
       
   385                    [param('ns3::Ipv4Address', 'address')], 
       
   386                    is_static=True)
       
   387     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::GetMulticastPrefix() [member function]
       
   388     cls.add_method('GetMulticastPrefix', 
       
   389                    'ns3::Mac48Address', 
       
   390                    [], 
       
   391                    is_static=True)
   327     ## mac48-address.h: bool ns3::Mac48Address::IsBroadcast() const [member function]
   392     ## mac48-address.h: bool ns3::Mac48Address::IsBroadcast() const [member function]
   328     cls.add_method('IsBroadcast', 
   393     cls.add_method('IsBroadcast', 
       
   394                    'bool', 
       
   395                    [], 
       
   396                    is_const=True)
       
   397     ## mac48-address.h: bool ns3::Mac48Address::IsGroup() const [member function]
       
   398     cls.add_method('IsGroup', 
   329                    'bool', 
   399                    'bool', 
   330                    [], 
   400                    [], 
   331                    is_const=True)
   401                    is_const=True)
   332     ## mac48-address.h: static bool ns3::Mac48Address::IsMatchingType(ns3::Address const & address) [member function]
   402     ## mac48-address.h: static bool ns3::Mac48Address::IsMatchingType(ns3::Address const & address) [member function]
   333     cls.add_method('IsMatchingType', 
   403     cls.add_method('IsMatchingType', 
   375                    is_static=True)
   445                    is_static=True)
   376     cls.add_output_stream_operator()
   446     cls.add_output_stream_operator()
   377     return
   447     return
   378 
   448 
   379 def register_Ns3Ipv4AddressGenerator_methods(root_module, cls):
   449 def register_Ns3Ipv4AddressGenerator_methods(root_module, cls):
       
   450     ## ipv4-address-generator.h: ns3::Ipv4AddressGenerator::Ipv4AddressGenerator(ns3::Ipv4AddressGenerator const & arg0) [copy constructor]
       
   451     cls.add_constructor([param('ns3::Ipv4AddressGenerator&', 'arg0', is_const=True)])
       
   452     ## ipv4-address-generator.h: ns3::Ipv4AddressGenerator::Ipv4AddressGenerator() [constructor]
       
   453     cls.add_constructor([])
   380     ## 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]
   454     ## 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]
   381     cls.add_method('Init', 
   455     cls.add_method('Init', 
   382                    'void', 
   456                    'void', 
   383                    [param('ns3::Ipv4Address', 'net', is_const=True), param('ns3::Ipv4Mask', 'mask', is_const=True), param('ns3::Ipv4Address', 'addr', default_value='"0.0.0.1"', is_const=True)], 
   457                    [param('ns3::Ipv4Address', 'net', is_const=True), param('ns3::Ipv4Mask', 'mask', is_const=True), param('ns3::Ipv4Address', 'addr', default_value='"0.0.0.1"', is_const=True)], 
   384                    is_static=True)
   458                    is_static=True)
   420     ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::TestMode() [member function]
   494     ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::TestMode() [member function]
   421     cls.add_method('TestMode', 
   495     cls.add_method('TestMode', 
   422                    'void', 
   496                    'void', 
   423                    [], 
   497                    [], 
   424                    is_static=True)
   498                    is_static=True)
   425     cls.add_constructor([])
       
   426     cls.add_copy_constructor()
       
   427     return
   499     return
   428 
   500 
   429 def register_Ns3Mac48AddressChecker_methods(root_module, cls):
   501 def register_Ns3Mac48AddressChecker_methods(root_module, cls):
   430     cls.add_constructor([])
   502     ## mac48-address.h: ns3::Mac48AddressChecker::Mac48AddressChecker(ns3::Mac48AddressChecker const & arg0) [copy constructor]
   431     cls.add_copy_constructor()
   503     cls.add_constructor([param('ns3::Mac48AddressChecker&', 'arg0', is_const=True)])
       
   504     ## mac48-address.h: ns3::Mac48AddressChecker::Mac48AddressChecker() [constructor]
       
   505     cls.add_constructor([])
   432     return
   506     return
   433 
   507 
   434 def register_Ns3Ipv4MaskChecker_methods(root_module, cls):
   508 def register_Ns3Ipv4MaskChecker_methods(root_module, cls):
   435     cls.add_constructor([])
   509     ## ipv4-address.h: ns3::Ipv4MaskChecker::Ipv4MaskChecker(ns3::Ipv4MaskChecker const & arg0) [copy constructor]
   436     cls.add_copy_constructor()
   510     cls.add_constructor([param('ns3::Ipv4MaskChecker&', 'arg0', is_const=True)])
       
   511     ## ipv4-address.h: ns3::Ipv4MaskChecker::Ipv4MaskChecker() [constructor]
       
   512     cls.add_constructor([])
   437     return
   513     return
   438 
   514 
   439 def register_Ns3Ipv4Route_methods(root_module, cls):
   515 def register_Ns3Ipv4Route_methods(root_module, cls):
   440     ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route() [constructor]
   516     ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route() [constructor]
   441     cls.add_constructor([])
   517     cls.add_constructor([])
   524     ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute(ns3::Ipv4MulticastRoute const * route) [constructor]
   600     ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute(ns3::Ipv4MulticastRoute const * route) [constructor]
   525     cls.add_constructor([param('ns3::Ipv4MulticastRoute *', 'route', transfer_ownership=False, is_const=True)])
   601     cls.add_constructor([param('ns3::Ipv4MulticastRoute *', 'route', transfer_ownership=False, is_const=True)])
   526     ## 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]
   602     ## 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]
   527     cls.add_method('CreateMulticastRoute', 
   603     cls.add_method('CreateMulticastRoute', 
   528                    'ns3::Ipv4MulticastRoute', 
   604                    'ns3::Ipv4MulticastRoute', 
   529                    [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int, std::allocator< unsigned int > >', 'outputInterfaces')], 
   605                    [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int >', 'outputInterfaces')], 
   530                    is_static=True)
   606                    is_static=True)
   531     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4MulticastRoute::GetGroup() const [member function]
   607     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4MulticastRoute::GetGroup() const [member function]
   532     cls.add_method('GetGroup', 
   608     cls.add_method('GetGroup', 
   533                    'ns3::Ipv4Address', 
   609                    'ns3::Ipv4Address', 
   534                    [], 
   610                    [], 
   553                    'uint32_t', 
   629                    'uint32_t', 
   554                    [param('uint32_t', 'n')], 
   630                    [param('uint32_t', 'n')], 
   555                    is_const=True)
   631                    is_const=True)
   556     ## ipv4-route.h: std::vector<unsigned int, std::allocator<unsigned int> > ns3::Ipv4MulticastRoute::GetOutputInterfaces() const [member function]
   632     ## ipv4-route.h: std::vector<unsigned int, std::allocator<unsigned int> > ns3::Ipv4MulticastRoute::GetOutputInterfaces() const [member function]
   557     cls.add_method('GetOutputInterfaces', 
   633     cls.add_method('GetOutputInterfaces', 
   558                    'std::vector< unsigned int, std::allocator< unsigned int > >', 
   634                    'std::vector< unsigned int >', 
   559                    [], 
   635                    [], 
   560                    is_const=True)
   636                    is_const=True)
   561     cls.add_output_stream_operator()
   637     cls.add_output_stream_operator()
   562     return
   638     return
   563 
   639 
   564 def register_Ns3AddressChecker_methods(root_module, cls):
   640 def register_Ns3AddressChecker_methods(root_module, cls):
   565     cls.add_constructor([])
   641     ## address.h: ns3::AddressChecker::AddressChecker(ns3::AddressChecker const & arg0) [copy constructor]
   566     cls.add_copy_constructor()
   642     cls.add_constructor([param('ns3::AddressChecker&', 'arg0', is_const=True)])
       
   643     ## address.h: ns3::AddressChecker::AddressChecker() [constructor]
       
   644     cls.add_constructor([])
   567     return
   645     return
   568 
   646 
   569 def register_Ns3PacketSocketAddress_methods(root_module, cls):
   647 def register_Ns3PacketSocketAddress_methods(root_module, cls):
       
   648     ## packet-socket-address.h: ns3::PacketSocketAddress::PacketSocketAddress(ns3::PacketSocketAddress const & arg0) [copy constructor]
       
   649     cls.add_constructor([param('ns3::PacketSocketAddress&', 'arg0', is_const=True)])
   570     ## packet-socket-address.h: ns3::PacketSocketAddress::PacketSocketAddress() [constructor]
   650     ## packet-socket-address.h: ns3::PacketSocketAddress::PacketSocketAddress() [constructor]
   571     cls.add_constructor([])
   651     cls.add_constructor([])
   572     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetProtocol(uint16_t protocol) [member function]
   652     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetProtocol(uint16_t protocol) [member function]
   573     cls.add_method('SetProtocol', 
   653     cls.add_method('SetProtocol', 
   574                    'void', 
   654                    'void', 
   613     ## packet-socket-address.h: static bool ns3::PacketSocketAddress::IsMatchingType(ns3::Address const & address) [member function]
   693     ## packet-socket-address.h: static bool ns3::PacketSocketAddress::IsMatchingType(ns3::Address const & address) [member function]
   614     cls.add_method('IsMatchingType', 
   694     cls.add_method('IsMatchingType', 
   615                    'bool', 
   695                    'bool', 
   616                    [param('ns3::Address&', 'address', is_const=True)], 
   696                    [param('ns3::Address&', 'address', is_const=True)], 
   617                    is_static=True)
   697                    is_static=True)
   618     cls.add_copy_constructor()
       
   619     return
       
   620 
       
   621 def register_Ns3Ipv4Mask_methods(root_module, cls):
       
   622     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [copy constructor]
       
   623     cls.add_constructor([param('ns3::Ipv4Mask&', 'arg0', is_const=True)])
       
   624     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask() [constructor]
       
   625     cls.add_constructor([])
       
   626     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(uint32_t mask) [constructor]
       
   627     cls.add_constructor([param('uint32_t', 'mask')])
       
   628     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(char const * mask) [constructor]
       
   629     cls.add_constructor([param('char *', 'mask', transfer_ownership=False, is_const=True)])
       
   630     ## ipv4-address.h: uint32_t ns3::Ipv4Mask::Get() const [member function]
       
   631     cls.add_method('Get', 
       
   632                    'uint32_t', 
       
   633                    [], 
       
   634                    is_const=True)
       
   635     ## ipv4-address.h: uint32_t ns3::Ipv4Mask::GetInverse() const [member function]
       
   636     cls.add_method('GetInverse', 
       
   637                    'uint32_t', 
       
   638                    [], 
       
   639                    is_const=True)
       
   640     ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetLoopback() [member function]
       
   641     cls.add_method('GetLoopback', 
       
   642                    'ns3::Ipv4Mask', 
       
   643                    [], 
       
   644                    is_static=True)
       
   645     ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetZero() [member function]
       
   646     cls.add_method('GetZero', 
       
   647                    'ns3::Ipv4Mask', 
       
   648                    [], 
       
   649                    is_static=True)
       
   650     ## ipv4-address.h: bool ns3::Ipv4Mask::IsEqual(ns3::Ipv4Mask other) const [member function]
       
   651     cls.add_method('IsEqual', 
       
   652                    'bool', 
       
   653                    [param('ns3::Ipv4Mask', 'other')], 
       
   654                    is_const=True)
       
   655     ## ipv4-address.h: bool ns3::Ipv4Mask::IsMatch(ns3::Ipv4Address a, ns3::Ipv4Address b) const [member function]
       
   656     cls.add_method('IsMatch', 
       
   657                    'bool', 
       
   658                    [param('ns3::Ipv4Address', 'a'), param('ns3::Ipv4Address', 'b')], 
       
   659                    is_const=True)
       
   660     ## ipv4-address.h: void ns3::Ipv4Mask::Print(std::ostream & os) const [member function]
       
   661     cls.add_method('Print', 
       
   662                    'void', 
       
   663                    [param('std::ostream&', 'os')], 
       
   664                    is_const=True)
       
   665     ## ipv4-address.h: void ns3::Ipv4Mask::Set(uint32_t mask) [member function]
       
   666     cls.add_method('Set', 
       
   667                    'void', 
       
   668                    [param('uint32_t', 'mask')])
       
   669     cls.add_output_stream_operator()
       
   670     return
   698     return
   671 
   699 
   672 def register_Ns3Ipv4AddressValue_methods(root_module, cls):
   700 def register_Ns3Ipv4AddressValue_methods(root_module, cls):
       
   701     ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4AddressValue const & arg0) [copy constructor]
       
   702     cls.add_constructor([param('ns3::Ipv4AddressValue&', 'arg0', is_const=True)])
   673     ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue() [constructor]
   703     ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue() [constructor]
   674     cls.add_constructor([])
   704     cls.add_constructor([])
   675     ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4Address const & value) [constructor]
   705     ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4Address const & value) [constructor]
   676     cls.add_constructor([param('ns3::Ipv4Address&', 'value', is_const=True)])
   706     cls.add_constructor([param('ns3::Ipv4Address&', 'value', is_const=True)])
   677     ## ipv4-address.h: void ns3::Ipv4AddressValue::Set(ns3::Ipv4Address const & value) [member function]
   707     ## ipv4-address.h: void ns3::Ipv4AddressValue::Set(ns3::Ipv4Address const & value) [member function]
   696     ## ipv4-address.h: bool ns3::Ipv4AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   726     ## ipv4-address.h: bool ns3::Ipv4AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   697     cls.add_method('DeserializeFromString', 
   727     cls.add_method('DeserializeFromString', 
   698                    'bool', 
   728                    'bool', 
   699                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
   729                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
   700                    is_virtual=True)
   730                    is_virtual=True)
   701     cls.add_copy_constructor()
       
   702     return
   731     return
   703 
   732 
   704 def register_Ns3Ipv4RoutingProtocol_methods(root_module, cls):
   733 def register_Ns3Ipv4RoutingProtocol_methods(root_module, cls):
   705     ## ipv4.h: ns3::Ipv4RoutingProtocol::IF_INDEX_ANY [variable]
   734     ## ipv4.h: ns3::Ipv4RoutingProtocol::IF_INDEX_ANY [variable]
   706     cls.add_static_attribute('IF_INDEX_ANY', retval('uint32_t', is_const=True), is_const=True)
   735     cls.add_static_attribute('IF_INDEX_ANY', retval('uint32_t', is_const=True), is_const=True)
       
   736     ## ipv4.h: ns3::Ipv4RoutingProtocol::Ipv4RoutingProtocol(ns3::Ipv4RoutingProtocol const & arg0) [copy constructor]
       
   737     cls.add_constructor([param('ns3::Ipv4RoutingProtocol&', 'arg0', is_const=True)])
       
   738     ## ipv4.h: ns3::Ipv4RoutingProtocol::Ipv4RoutingProtocol() [constructor]
       
   739     cls.add_constructor([])
   707     ## 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]
   740     ## 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]
   708     cls.add_method('RequestRoute', 
   741     cls.add_method('RequestRoute', 
   709                    'bool', 
   742                    'bool', 
   710                    [param('uint32_t', 'ifIndex'), param('ns3::Ipv4Header&', 'ipHeader', is_const=True), param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Callback< void, bool, const ns3::Ipv4Route&, ns3::Ptr< ns3::Packet >, const ns3::Ipv4Header&, ns3::empty, ns3::empty >', 'routeReply')], 
   743                    [param('uint32_t', 'ifIndex'), param('ns3::Ipv4Header&', 'ipHeader', is_const=True), param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Callback< void, bool, const ns3::Ipv4Route&, ns3::Ptr< ns3::Packet >, const ns3::Ipv4Header&, ns3::empty, ns3::empty >', 'routeReply')], 
   711                    is_pure_virtual=True, is_virtual=True)
   744                    is_pure_virtual=True, is_virtual=True)
   712     ## ipv4.h: bool ns3::Ipv4RoutingProtocol::RequestIfIndex(ns3::Ipv4Address destination, uint32_t & ifIndex) [member function]
   745     ## ipv4.h: bool ns3::Ipv4RoutingProtocol::RequestIfIndex(ns3::Ipv4Address destination, uint32_t & ifIndex) [member function]
   713     cls.add_method('RequestIfIndex', 
   746     cls.add_method('RequestIfIndex', 
   714                    'bool', 
   747                    'bool', 
   715                    [param('ns3::Ipv4Address', 'destination'), param('uint32_t&', 'ifIndex')], 
   748                    [param('ns3::Ipv4Address', 'destination'), param('uint32_t&', 'ifIndex')], 
   716                    is_pure_virtual=True, is_virtual=True)
   749                    is_pure_virtual=True, is_virtual=True)
   717     cls.add_constructor([])
       
   718     cls.add_copy_constructor()
       
   719     return
   750     return
   720 
   751 
   721 def register_Ns3Mac48AddressValue_methods(root_module, cls):
   752 def register_Ns3Mac48AddressValue_methods(root_module, cls):
       
   753     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48AddressValue const & arg0) [copy constructor]
       
   754     cls.add_constructor([param('ns3::Mac48AddressValue&', 'arg0', is_const=True)])
   722     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue() [constructor]
   755     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue() [constructor]
   723     cls.add_constructor([])
   756     cls.add_constructor([])
   724     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48Address const & value) [constructor]
   757     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48Address const & value) [constructor]
   725     cls.add_constructor([param('ns3::Mac48Address&', 'value', is_const=True)])
   758     cls.add_constructor([param('ns3::Mac48Address&', 'value', is_const=True)])
   726     ## mac48-address.h: void ns3::Mac48AddressValue::Set(ns3::Mac48Address const & value) [member function]
   759     ## mac48-address.h: void ns3::Mac48AddressValue::Set(ns3::Mac48Address const & value) [member function]
   745     ## mac48-address.h: bool ns3::Mac48AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   778     ## mac48-address.h: bool ns3::Mac48AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   746     cls.add_method('DeserializeFromString', 
   779     cls.add_method('DeserializeFromString', 
   747                    'bool', 
   780                    'bool', 
   748                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
   781                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
   749                    is_virtual=True)
   782                    is_virtual=True)
   750     cls.add_copy_constructor()
       
   751     return
   783     return
   752 
   784 
   753 def register_Ns3Ipv4MaskValue_methods(root_module, cls):
   785 def register_Ns3Ipv4MaskValue_methods(root_module, cls):
       
   786     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4MaskValue const & arg0) [copy constructor]
       
   787     cls.add_constructor([param('ns3::Ipv4MaskValue&', 'arg0', is_const=True)])
   754     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue() [constructor]
   788     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue() [constructor]
   755     cls.add_constructor([])
   789     cls.add_constructor([])
   756     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4Mask const & value) [constructor]
   790     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4Mask const & value) [constructor]
   757     cls.add_constructor([param('ns3::Ipv4Mask&', 'value', is_const=True)])
   791     cls.add_constructor([param('ns3::Ipv4Mask&', 'value', is_const=True)])
   758     ## ipv4-address.h: void ns3::Ipv4MaskValue::Set(ns3::Ipv4Mask const & value) [member function]
   792     ## ipv4-address.h: void ns3::Ipv4MaskValue::Set(ns3::Ipv4Mask const & value) [member function]
   777     ## ipv4-address.h: bool ns3::Ipv4MaskValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   811     ## ipv4-address.h: bool ns3::Ipv4MaskValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   778     cls.add_method('DeserializeFromString', 
   812     cls.add_method('DeserializeFromString', 
   779                    'bool', 
   813                    'bool', 
   780                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
   814                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
   781                    is_virtual=True)
   815                    is_virtual=True)
   782     cls.add_copy_constructor()
       
   783     return
   816     return
   784 
   817 
   785 def register_Ns3SocketAddressTag_methods(root_module, cls):
   818 def register_Ns3SocketAddressTag_methods(root_module, cls):
       
   819     ## socket.h: ns3::SocketAddressTag::SocketAddressTag(ns3::SocketAddressTag const & arg0) [copy constructor]
       
   820     cls.add_constructor([param('ns3::SocketAddressTag&', 'arg0', is_const=True)])
   786     ## socket.h: ns3::SocketAddressTag::SocketAddressTag() [constructor]
   821     ## socket.h: ns3::SocketAddressTag::SocketAddressTag() [constructor]
   787     cls.add_constructor([])
   822     cls.add_constructor([])
   788     ## socket.h: void ns3::SocketAddressTag::SetAddress(ns3::Address addr) [member function]
   823     ## socket.h: void ns3::SocketAddressTag::SetAddress(ns3::Address addr) [member function]
   789     cls.add_method('SetAddress', 
   824     cls.add_method('SetAddress', 
   790                    'void', 
   825                    'void', 
   822     ## socket.h: void ns3::SocketAddressTag::Print(std::ostream & os) const [member function]
   857     ## socket.h: void ns3::SocketAddressTag::Print(std::ostream & os) const [member function]
   823     cls.add_method('Print', 
   858     cls.add_method('Print', 
   824                    'void', 
   859                    'void', 
   825                    [param('std::ostream&', 'os')], 
   860                    [param('std::ostream&', 'os')], 
   826                    is_const=True, is_virtual=True)
   861                    is_const=True, is_virtual=True)
   827     cls.add_copy_constructor()
       
   828     return
   862     return
   829 
   863 
   830 def register_Ns3InetSocketAddress_methods(root_module, cls):
   864 def register_Ns3InetSocketAddress_methods(root_module, cls):
       
   865     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(ns3::InetSocketAddress const & arg0) [copy constructor]
       
   866     cls.add_constructor([param('ns3::InetSocketAddress&', 'arg0', is_const=True)])
   831     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(ns3::Ipv4Address ipv4, uint16_t port) [constructor]
   867     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(ns3::Ipv4Address ipv4, uint16_t port) [constructor]
   832     cls.add_constructor([param('ns3::Ipv4Address', 'ipv4'), param('uint16_t', 'port')])
   868     cls.add_constructor([param('ns3::Ipv4Address', 'ipv4'), param('uint16_t', 'port')])
   833     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(ns3::Ipv4Address ipv4) [constructor]
   869     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(ns3::Ipv4Address ipv4) [constructor]
   834     cls.add_constructor([param('ns3::Ipv4Address', 'ipv4')])
   870     cls.add_constructor([param('ns3::Ipv4Address', 'ipv4')])
   835     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(uint16_t port) [constructor]
   871     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(uint16_t port) [constructor]
   864     ## inet-socket-address.h: static ns3::InetSocketAddress ns3::InetSocketAddress::ConvertFrom(ns3::Address const & address) [member function]
   900     ## inet-socket-address.h: static ns3::InetSocketAddress ns3::InetSocketAddress::ConvertFrom(ns3::Address const & address) [member function]
   865     cls.add_method('ConvertFrom', 
   901     cls.add_method('ConvertFrom', 
   866                    'ns3::InetSocketAddress', 
   902                    'ns3::InetSocketAddress', 
   867                    [param('ns3::Address&', 'address', is_const=True)], 
   903                    [param('ns3::Address&', 'address', is_const=True)], 
   868                    is_static=True)
   904                    is_static=True)
   869     cls.add_copy_constructor()
       
   870     return
   905     return
   871 
   906 
   872 def register_Ns3Ipv4Address_methods(root_module, cls):
   907 def register_Ns3Ipv4Address_methods(root_module, cls):
   873     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [copy constructor]
   908     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [copy constructor]
   874     cls.add_constructor([param('ns3::Ipv4Address&', 'arg0', is_const=True)])
   909     cls.add_constructor([param('ns3::Ipv4Address&', 'arg0', is_const=True)])
   968                    [param('char *', 'address', transfer_ownership=False, is_const=True)])
  1003                    [param('char *', 'address', transfer_ownership=False, is_const=True)])
   969     cls.add_output_stream_operator()
  1004     cls.add_output_stream_operator()
   970     return
  1005     return
   971 
  1006 
   972 def register_Ns3Application_methods(root_module, cls):
  1007 def register_Ns3Application_methods(root_module, cls):
       
  1008     ## application.h: ns3::Application::Application(ns3::Application const & arg0) [copy constructor]
       
  1009     cls.add_constructor([param('ns3::Application&', 'arg0', is_const=True)])
   973     ## application.h: static ns3::TypeId ns3::Application::GetTypeId() [member function]
  1010     ## application.h: static ns3::TypeId ns3::Application::GetTypeId() [member function]
   974     cls.add_method('GetTypeId', 
  1011     cls.add_method('GetTypeId', 
   975                    'ns3::TypeId', 
  1012                    'ns3::TypeId', 
   976                    [], 
  1013                    [], 
   977                    is_static=True)
  1014                    is_static=True)
  1015     ## application.h: void ns3::Application::StopApplication() [member function]
  1052     ## application.h: void ns3::Application::StopApplication() [member function]
  1016     cls.add_method('StopApplication', 
  1053     cls.add_method('StopApplication', 
  1017                    'void', 
  1054                    'void', 
  1018                    [], 
  1055                    [], 
  1019                    visibility='private', is_virtual=True)
  1056                    visibility='private', is_virtual=True)
  1020     cls.add_copy_constructor()
       
  1021     return
  1057     return
  1022 
  1058 
  1023 def register_Ns3Queue_methods(root_module, cls):
  1059 def register_Ns3Queue_methods(root_module, cls):
       
  1060     ## queue.h: ns3::Queue::Queue(ns3::Queue const & arg0) [copy constructor]
       
  1061     cls.add_constructor([param('ns3::Queue&', 'arg0', is_const=True)])
  1024     ## queue.h: static ns3::TypeId ns3::Queue::GetTypeId() [member function]
  1062     ## queue.h: static ns3::TypeId ns3::Queue::GetTypeId() [member function]
  1025     cls.add_method('GetTypeId', 
  1063     cls.add_method('GetTypeId', 
  1026                    'ns3::TypeId', 
  1064                    'ns3::TypeId', 
  1027                    [], 
  1065                    [], 
  1028                    is_static=True)
  1066                    is_static=True)
  1102     ## queue.h: ns3::Ptr<const ns3::Packet> ns3::Queue::DoPeek() const [member function]
  1140     ## queue.h: ns3::Ptr<const ns3::Packet> ns3::Queue::DoPeek() const [member function]
  1103     cls.add_method('DoPeek', 
  1141     cls.add_method('DoPeek', 
  1104                    'ns3::Ptr< const ns3::Packet >', 
  1142                    'ns3::Ptr< const ns3::Packet >', 
  1105                    [], 
  1143                    [], 
  1106                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1144                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1107     cls.add_copy_constructor()
       
  1108     return
  1145     return
  1109 
  1146 
  1110 def register_Ns3Socket_methods(root_module, cls):
  1147 def register_Ns3Socket_methods(root_module, cls):
       
  1148     ## socket.h: ns3::Socket::Socket(ns3::Socket const & arg0) [copy constructor]
       
  1149     cls.add_constructor([param('ns3::Socket&', 'arg0', is_const=True)])
  1111     ## socket.h: ns3::Socket::Socket() [constructor]
  1150     ## socket.h: ns3::Socket::Socket() [constructor]
  1112     cls.add_constructor([])
  1151     cls.add_constructor([])
  1113     ## socket.h: static ns3::Ptr<ns3::Socket> ns3::Socket::CreateSocket(ns3::Ptr<ns3::Node> node, ns3::TypeId tid) [member function]
  1152     ## socket.h: static ns3::Ptr<ns3::Socket> ns3::Socket::CreateSocket(ns3::Ptr<ns3::Node> node, ns3::TypeId tid) [member function]
  1114     cls.add_method('CreateSocket', 
  1153     cls.add_method('CreateSocket', 
  1115                    'ns3::Ptr< ns3::Socket >', 
  1154                    'ns3::Ptr< ns3::Socket >', 
  1271     ## socket.h: void ns3::Socket::NotifyDataRecv() [member function]
  1310     ## socket.h: void ns3::Socket::NotifyDataRecv() [member function]
  1272     cls.add_method('NotifyDataRecv', 
  1311     cls.add_method('NotifyDataRecv', 
  1273                    'void', 
  1312                    'void', 
  1274                    [], 
  1313                    [], 
  1275                    visibility='protected')
  1314                    visibility='protected')
  1276     cls.add_copy_constructor()
       
  1277     return
  1315     return
  1278 
  1316 
  1279 def register_Ns3Ipv4Header_methods(root_module, cls):
  1317 def register_Ns3Ipv4Header_methods(root_module, cls):
       
  1318     ## ipv4-header.h: ns3::Ipv4Header::Ipv4Header(ns3::Ipv4Header const & arg0) [copy constructor]
       
  1319     cls.add_constructor([param('ns3::Ipv4Header&', 'arg0', is_const=True)])
  1280     ## ipv4-header.h: ns3::Ipv4Header::Ipv4Header() [constructor]
  1320     ## ipv4-header.h: ns3::Ipv4Header::Ipv4Header() [constructor]
  1281     cls.add_constructor([])
  1321     cls.add_constructor([])
  1282     ## ipv4-header.h: void ns3::Ipv4Header::EnableChecksum() [member function]
  1322     ## ipv4-header.h: void ns3::Ipv4Header::EnableChecksum() [member function]
  1283     cls.add_method('EnableChecksum', 
  1323     cls.add_method('EnableChecksum', 
  1284                    'void', 
  1324                    'void', 
  1414     ## ipv4-header.h: uint32_t ns3::Ipv4Header::Deserialize(ns3::Buffer::Iterator start) [member function]
  1454     ## ipv4-header.h: uint32_t ns3::Ipv4Header::Deserialize(ns3::Buffer::Iterator start) [member function]
  1415     cls.add_method('Deserialize', 
  1455     cls.add_method('Deserialize', 
  1416                    'uint32_t', 
  1456                    'uint32_t', 
  1417                    [param('ns3::Buffer::Iterator', 'start')], 
  1457                    [param('ns3::Buffer::Iterator', 'start')], 
  1418                    is_virtual=True)
  1458                    is_virtual=True)
  1419     cls.add_copy_constructor()
       
  1420     return
  1459     return
  1421 
  1460 
  1422 def register_Ns3UdpSocket_methods(root_module, cls):
  1461 def register_Ns3UdpSocket_methods(root_module, cls):
       
  1462     ## udp-socket.h: ns3::UdpSocket::UdpSocket(ns3::UdpSocket const & arg0) [copy constructor]
       
  1463     cls.add_constructor([param('ns3::UdpSocket&', 'arg0', is_const=True)])
  1423     ## udp-socket.h: static ns3::TypeId ns3::UdpSocket::GetTypeId() [member function]
  1464     ## udp-socket.h: static ns3::TypeId ns3::UdpSocket::GetTypeId() [member function]
  1424     cls.add_method('GetTypeId', 
  1465     cls.add_method('GetTypeId', 
  1425                    'ns3::TypeId', 
  1466                    'ns3::TypeId', 
  1426                    [], 
  1467                    [], 
  1427                    is_static=True)
  1468                    is_static=True)
  1455     ## udp-socket.h: uint32_t ns3::UdpSocket::GetIpMulticastTtl() const [member function]
  1496     ## udp-socket.h: uint32_t ns3::UdpSocket::GetIpMulticastTtl() const [member function]
  1456     cls.add_method('GetIpMulticastTtl', 
  1497     cls.add_method('GetIpMulticastTtl', 
  1457                    'uint32_t', 
  1498                    'uint32_t', 
  1458                    [], 
  1499                    [], 
  1459                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1500                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1460     cls.add_copy_constructor()
       
  1461     return
  1501     return
  1462 
  1502 
  1463 def register_Ns3NetDevice_methods(root_module, cls):
  1503 def register_Ns3NetDevice_methods(root_module, cls):
       
  1504     ## net-device.h: ns3::NetDevice::NetDevice(ns3::NetDevice const & arg0) [copy constructor]
       
  1505     cls.add_constructor([param('ns3::NetDevice&', 'arg0', is_const=True)])
       
  1506     ## net-device.h: ns3::NetDevice::NetDevice() [constructor]
       
  1507     cls.add_constructor([])
  1464     ## net-device.h: static ns3::TypeId ns3::NetDevice::GetTypeId() [member function]
  1508     ## net-device.h: static ns3::TypeId ns3::NetDevice::GetTypeId() [member function]
  1465     cls.add_method('GetTypeId', 
  1509     cls.add_method('GetTypeId', 
  1466                    'ns3::TypeId', 
  1510                    'ns3::TypeId', 
  1467                    [], 
  1511                    [], 
  1468                    is_static=True)
  1512                    is_static=True)
  1569     ## net-device.h: bool ns3::NetDevice::NeedsArp() const [member function]
  1613     ## net-device.h: bool ns3::NetDevice::NeedsArp() const [member function]
  1570     cls.add_method('NeedsArp', 
  1614     cls.add_method('NeedsArp', 
  1571                    'bool', 
  1615                    'bool', 
  1572                    [], 
  1616                    [], 
  1573                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1617                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1574     ## net-device.h: void ns3::NetDevice::SetReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> cb) [member function]
  1618     ## 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]
  1575     cls.add_method('SetReceiveCallback', 
  1619     cls.add_method('SetReceiveCallback', 
  1576                    'void', 
  1620                    'void', 
  1577                    [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr<const ns3::Packet >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], 
  1621                    [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], 
  1578                    is_pure_virtual=True, is_virtual=True)
  1622                    is_pure_virtual=True, is_virtual=True)
  1579     ## net-device.h: void ns3::NetDevice::SetPromiscReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType> cb) [member function]
  1623     ## 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]
  1580     cls.add_method('SetPromiscReceiveCallback', 
  1624     cls.add_method('SetPromiscReceiveCallback', 
  1581                    'void', 
  1625                    'void', 
  1582                    [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr<const ns3::Packet >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'cb')], 
  1626                    [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')], 
  1583                    is_pure_virtual=True, is_virtual=True)
  1627                    is_pure_virtual=True, is_virtual=True)
  1584     ## net-device.h: bool ns3::NetDevice::SupportsPromiscuous() const [member function]
  1628     ## net-device.h: bool ns3::NetDevice::SupportsPromiscuous() const [member function]
  1585     cls.add_method('SupportsPromiscuous', 
  1629     cls.add_method('SupportsPromiscuous', 
  1586                    'bool', 
  1630                    'bool', 
  1587                    [], 
  1631                    [], 
  1588                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1632                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1589     cls.add_constructor([])
       
  1590     cls.add_copy_constructor()
       
  1591     return
  1633     return
  1592 
  1634 
  1593 def register_Ns3DropTailQueue_methods(root_module, cls):
  1635 def register_Ns3DropTailQueue_methods(root_module, cls):
       
  1636     ## drop-tail-queue.h: ns3::DropTailQueue::DropTailQueue(ns3::DropTailQueue const & arg0) [copy constructor]
       
  1637     cls.add_constructor([param('ns3::DropTailQueue&', 'arg0', is_const=True)])
  1594     ## drop-tail-queue.h: static ns3::TypeId ns3::DropTailQueue::GetTypeId() [member function]
  1638     ## drop-tail-queue.h: static ns3::TypeId ns3::DropTailQueue::GetTypeId() [member function]
  1595     cls.add_method('GetTypeId', 
  1639     cls.add_method('GetTypeId', 
  1596                    'ns3::TypeId', 
  1640                    'ns3::TypeId', 
  1597                    [], 
  1641                    [], 
  1598                    is_static=True)
  1642                    is_static=True)
  1611     ## drop-tail-queue.h: ns3::Ptr<const ns3::Packet> ns3::DropTailQueue::DoPeek() const [member function]
  1655     ## drop-tail-queue.h: ns3::Ptr<const ns3::Packet> ns3::DropTailQueue::DoPeek() const [member function]
  1612     cls.add_method('DoPeek', 
  1656     cls.add_method('DoPeek', 
  1613                    'ns3::Ptr< const ns3::Packet >', 
  1657                    'ns3::Ptr< const ns3::Packet >', 
  1614                    [], 
  1658                    [], 
  1615                    is_const=True, visibility='private', is_virtual=True)
  1659                    is_const=True, visibility='private', is_virtual=True)
  1616     cls.add_copy_constructor()
       
  1617     return
  1660     return
  1618 
  1661 
  1619 def register_Ns3AddressValue_methods(root_module, cls):
  1662 def register_Ns3AddressValue_methods(root_module, cls):
       
  1663     ## address.h: ns3::AddressValue::AddressValue(ns3::AddressValue const & arg0) [copy constructor]
       
  1664     cls.add_constructor([param('ns3::AddressValue&', 'arg0', is_const=True)])
  1620     ## address.h: ns3::AddressValue::AddressValue() [constructor]
  1665     ## address.h: ns3::AddressValue::AddressValue() [constructor]
  1621     cls.add_constructor([])
  1666     cls.add_constructor([])
  1622     ## address.h: ns3::AddressValue::AddressValue(ns3::Address const & value) [constructor]
  1667     ## address.h: ns3::AddressValue::AddressValue(ns3::Address const & value) [constructor]
  1623     cls.add_constructor([param('ns3::Address&', 'value', is_const=True)])
  1668     cls.add_constructor([param('ns3::Address&', 'value', is_const=True)])
  1624     ## address.h: void ns3::AddressValue::Set(ns3::Address const & value) [member function]
  1669     ## address.h: void ns3::AddressValue::Set(ns3::Address const & value) [member function]
  1643     ## address.h: bool ns3::AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1688     ## address.h: bool ns3::AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1644     cls.add_method('DeserializeFromString', 
  1689     cls.add_method('DeserializeFromString', 
  1645                    'bool', 
  1690                    'bool', 
  1646                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1691                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1647                    is_virtual=True)
  1692                    is_virtual=True)
  1648     cls.add_copy_constructor()
       
  1649     return
  1693     return
  1650 
  1694 
  1651 def register_Ns3Node_methods(root_module, cls):
  1695 def register_Ns3Node_methods(root_module, cls):
       
  1696     ## node.h: ns3::Node::Node(ns3::Node const & arg0) [copy constructor]
       
  1697     cls.add_constructor([param('ns3::Node&', 'arg0', is_const=True)])
  1652     ## node.h: static ns3::TypeId ns3::Node::GetTypeId() [member function]
  1698     ## node.h: static ns3::TypeId ns3::Node::GetTypeId() [member function]
  1653     cls.add_method('GetTypeId', 
  1699     cls.add_method('GetTypeId', 
  1654                    'ns3::TypeId', 
  1700                    'ns3::TypeId', 
  1655                    [], 
  1701                    [], 
  1656                    is_static=True)
  1702                    is_static=True)
  1694     ## node.h: uint32_t ns3::Node::GetNApplications() const [member function]
  1740     ## node.h: uint32_t ns3::Node::GetNApplications() const [member function]
  1695     cls.add_method('GetNApplications', 
  1741     cls.add_method('GetNApplications', 
  1696                    'uint32_t', 
  1742                    'uint32_t', 
  1697                    [], 
  1743                    [], 
  1698                    is_const=True)
  1744                    is_const=True)
  1699     ## node.h: void ns3::Node::RegisterProtocolHandler(ns3::Callback<void, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, 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]
  1745     ## 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]
  1700     cls.add_method('RegisterProtocolHandler', 
  1746     cls.add_method('RegisterProtocolHandler', 
  1701                    'void', 
  1747                    'void', 
  1702                    [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr<const ns3::Packet >, 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')])
  1748                    [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')])
  1703     ## node.h: void ns3::Node::UnregisterProtocolHandler(ns3::Callback<void, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType> handler) [member function]
  1749     ## 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]
  1704     cls.add_method('UnregisterProtocolHandler', 
  1750     cls.add_method('UnregisterProtocolHandler', 
  1705                    'void', 
  1751                    'void', 
  1706                    [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr<const ns3::Packet >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'handler')])
  1752                    [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')])
  1707     ## node.h: void ns3::Node::DoDispose() [member function]
  1753     ## node.h: void ns3::Node::DoDispose() [member function]
  1708     cls.add_method('DoDispose', 
  1754     cls.add_method('DoDispose', 
  1709                    'void', 
  1755                    'void', 
  1710                    [], 
  1756                    [], 
  1711                    visibility='protected', is_virtual=True)
  1757                    visibility='protected', is_virtual=True)
  1712     ## node.h: void ns3::Node::NotifyDeviceAdded(ns3::Ptr<ns3::NetDevice> device) [member function]
  1758     ## node.h: void ns3::Node::NotifyDeviceAdded(ns3::Ptr<ns3::NetDevice> device) [member function]
  1713     cls.add_method('NotifyDeviceAdded', 
  1759     cls.add_method('NotifyDeviceAdded', 
  1714                    'void', 
  1760                    'void', 
  1715                    [param('ns3::Ptr< ns3::NetDevice >', 'device')], 
  1761                    [param('ns3::Ptr< ns3::NetDevice >', 'device')], 
  1716                    visibility='private', is_virtual=True)
  1762                    visibility='private', is_virtual=True)
  1717     cls.add_copy_constructor()
       
  1718     return
  1763     return
  1719 
  1764 
  1720 def register_Ns3Channel_methods(root_module, cls):
  1765 def register_Ns3Channel_methods(root_module, cls):
       
  1766     ## channel.h: ns3::Channel::Channel(ns3::Channel const & arg0) [copy constructor]
       
  1767     cls.add_constructor([param('ns3::Channel&', 'arg0', is_const=True)])
  1721     ## channel.h: static ns3::TypeId ns3::Channel::GetTypeId() [member function]
  1768     ## channel.h: static ns3::TypeId ns3::Channel::GetTypeId() [member function]
  1722     cls.add_method('GetTypeId', 
  1769     cls.add_method('GetTypeId', 
  1723                    'ns3::TypeId', 
  1770                    'ns3::TypeId', 
  1724                    [], 
  1771                    [], 
  1725                    is_static=True)
  1772                    is_static=True)
  1743     ## channel.h: ns3::Ptr<ns3::NetDevice> ns3::Channel::GetDevice(uint32_t i) const [member function]
  1790     ## channel.h: ns3::Ptr<ns3::NetDevice> ns3::Channel::GetDevice(uint32_t i) const [member function]
  1744     cls.add_method('GetDevice', 
  1791     cls.add_method('GetDevice', 
  1745                    'ns3::Ptr< ns3::NetDevice >', 
  1792                    'ns3::Ptr< ns3::NetDevice >', 
  1746                    [param('uint32_t', 'i')], 
  1793                    [param('uint32_t', 'i')], 
  1747                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1794                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1748     cls.add_copy_constructor()
       
  1749     return
  1795     return
  1750 
  1796 
  1751 def register_Ns3TcpSocket_methods(root_module, cls):
  1797 def register_Ns3TcpSocket_methods(root_module, cls):
       
  1798     ## tcp-socket.h: ns3::TcpSocket::TcpSocket(ns3::TcpSocket const & arg0) [copy constructor]
       
  1799     cls.add_constructor([param('ns3::TcpSocket&', 'arg0', is_const=True)])
  1752     ## tcp-socket.h: static ns3::TypeId ns3::TcpSocket::GetTypeId() [member function]
  1800     ## tcp-socket.h: static ns3::TypeId ns3::TcpSocket::GetTypeId() [member function]
  1753     cls.add_method('GetTypeId', 
  1801     cls.add_method('GetTypeId', 
  1754                    'ns3::TypeId', 
  1802                    'ns3::TypeId', 
  1755                    [], 
  1803                    [], 
  1756                    is_static=True)
  1804                    is_static=True)
  1854     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetDelAckMaxCount() const [member function]
  1902     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetDelAckMaxCount() const [member function]
  1855     cls.add_method('GetDelAckMaxCount', 
  1903     cls.add_method('GetDelAckMaxCount', 
  1856                    'uint32_t', 
  1904                    'uint32_t', 
  1857                    [], 
  1905                    [], 
  1858                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1906                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1859     cls.add_copy_constructor()
       
  1860     return
  1907     return
  1861 
  1908 
  1862 def register_Ns3EthernetHeader_methods(root_module, cls):
  1909 def register_Ns3EthernetHeader_methods(root_module, cls):
       
  1910     ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader(ns3::EthernetHeader const & arg0) [copy constructor]
       
  1911     cls.add_constructor([param('ns3::EthernetHeader&', 'arg0', is_const=True)])
  1863     ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader(bool hasPreamble) [constructor]
  1912     ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader(bool hasPreamble) [constructor]
  1864     cls.add_constructor([param('bool', 'hasPreamble')])
  1913     cls.add_constructor([param('bool', 'hasPreamble')])
  1865     ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader() [constructor]
  1914     ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader() [constructor]
  1866     cls.add_constructor([])
  1915     cls.add_constructor([])
  1867     ## ethernet-header.h: void ns3::EthernetHeader::SetLengthType(uint16_t size) [member function]
  1916     ## ethernet-header.h: void ns3::EthernetHeader::SetLengthType(uint16_t size) [member function]
  1938     ## ethernet-header.h: uint32_t ns3::EthernetHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
  1987     ## ethernet-header.h: uint32_t ns3::EthernetHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
  1939     cls.add_method('Deserialize', 
  1988     cls.add_method('Deserialize', 
  1940                    'uint32_t', 
  1989                    'uint32_t', 
  1941                    [param('ns3::Buffer::Iterator', 'start')], 
  1990                    [param('ns3::Buffer::Iterator', 'start')], 
  1942                    is_virtual=True)
  1991                    is_virtual=True)
  1943     cls.add_copy_constructor()
       
  1944     return
  1992     return
  1945 
  1993 
  1946 def register_Ns3SocketIpTtlTag_methods(root_module, cls):
  1994 def register_Ns3SocketIpTtlTag_methods(root_module, cls):
       
  1995     ## socket.h: ns3::SocketIpTtlTag::SocketIpTtlTag(ns3::SocketIpTtlTag const & arg0) [copy constructor]
       
  1996     cls.add_constructor([param('ns3::SocketIpTtlTag&', 'arg0', is_const=True)])
  1947     ## socket.h: ns3::SocketIpTtlTag::SocketIpTtlTag() [constructor]
  1997     ## socket.h: ns3::SocketIpTtlTag::SocketIpTtlTag() [constructor]
  1948     cls.add_constructor([])
  1998     cls.add_constructor([])
  1949     ## socket.h: void ns3::SocketIpTtlTag::SetTtl(uint8_t ttl) [member function]
  1999     ## socket.h: void ns3::SocketIpTtlTag::SetTtl(uint8_t ttl) [member function]
  1950     cls.add_method('SetTtl', 
  2000     cls.add_method('SetTtl', 
  1951                    'void', 
  2001                    'void', 
  1983     ## socket.h: void ns3::SocketIpTtlTag::Print(std::ostream & os) const [member function]
  2033     ## socket.h: void ns3::SocketIpTtlTag::Print(std::ostream & os) const [member function]
  1984     cls.add_method('Print', 
  2034     cls.add_method('Print', 
  1985                    'void', 
  2035                    'void', 
  1986                    [param('std::ostream&', 'os')], 
  2036                    [param('std::ostream&', 'os')], 
  1987                    is_const=True, is_virtual=True)
  2037                    is_const=True, is_virtual=True)
  1988     cls.add_copy_constructor()
       
  1989     return
  2038     return
  1990 
  2039 
  1991 def register_Ns3Ipv4_methods(root_module, cls):
  2040 def register_Ns3Ipv4_methods(root_module, cls):
       
  2041     ## ipv4.h: ns3::Ipv4::Ipv4(ns3::Ipv4 const & arg0) [copy constructor]
       
  2042     cls.add_constructor([param('ns3::Ipv4&', 'arg0', is_const=True)])
  1992     ## ipv4.h: static ns3::TypeId ns3::Ipv4::GetTypeId() [member function]
  2043     ## ipv4.h: static ns3::TypeId ns3::Ipv4::GetTypeId() [member function]
  1993     cls.add_method('GetTypeId', 
  2044     cls.add_method('GetTypeId', 
  1994                    'ns3::TypeId', 
  2045                    'ns3::TypeId', 
  1995                    [], 
  2046                    [], 
  1996                    is_static=True)
  2047                    is_static=True)
  2042                    [param('uint32_t', 'i')], 
  2093                    [param('uint32_t', 'i')], 
  2043                    is_pure_virtual=True, is_virtual=True)
  2094                    is_pure_virtual=True, is_virtual=True)
  2044     ## 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]
  2095     ## 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]
  2045     cls.add_method('AddMulticastRoute', 
  2096     cls.add_method('AddMulticastRoute', 
  2046                    'void', 
  2097                    'void', 
  2047                    [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int, std::allocator< unsigned int > >', 'outputInterfaces')], 
  2098                    [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int >', 'outputInterfaces')], 
  2048                    is_pure_virtual=True, is_virtual=True)
  2099                    is_pure_virtual=True, is_virtual=True)
  2049     ## ipv4.h: void ns3::Ipv4::RemoveMulticastRoute(ns3::Ipv4Address origin, ns3::Ipv4Address group, uint32_t inputInterface) [member function]
  2100     ## ipv4.h: void ns3::Ipv4::RemoveMulticastRoute(ns3::Ipv4Address origin, ns3::Ipv4Address group, uint32_t inputInterface) [member function]
  2050     cls.add_method('RemoveMulticastRoute', 
  2101     cls.add_method('RemoveMulticastRoute', 
  2051                    'void', 
  2102                    'void', 
  2052                    [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface')], 
  2103                    [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface')], 
  2174     ## ipv4.h: uint32_t ns3::Ipv4::GetIfIndexByAddress(ns3::Ipv4Address addr, ns3::Ipv4Mask mask=ns3::Ipv4Mask(((const char*)"255.255.255.255"))) [member function]
  2225     ## ipv4.h: uint32_t ns3::Ipv4::GetIfIndexByAddress(ns3::Ipv4Address addr, ns3::Ipv4Mask mask=ns3::Ipv4Mask(((const char*)"255.255.255.255"))) [member function]
  2175     cls.add_method('GetIfIndexByAddress', 
  2226     cls.add_method('GetIfIndexByAddress', 
  2176                    'uint32_t', 
  2227                    'uint32_t', 
  2177                    [param('ns3::Ipv4Address', 'addr'), param('ns3::Ipv4Mask', 'mask', default_value='ns3::Ipv4Mask(((const char*)"255.255.255.255"))')], 
  2228                    [param('ns3::Ipv4Address', 'addr'), param('ns3::Ipv4Mask', 'mask', default_value='ns3::Ipv4Mask(((const char*)"255.255.255.255"))')], 
  2178                    is_virtual=True)
  2229                    is_virtual=True)
  2179     cls.add_copy_constructor()
       
  2180     return
  2230     return
  2181 
  2231 
  2182 def register_Ns3SocketFactory_methods(root_module, cls):
  2232 def register_Ns3SocketFactory_methods(root_module, cls):
       
  2233     ## socket-factory.h: ns3::SocketFactory::SocketFactory(ns3::SocketFactory const & arg0) [copy constructor]
       
  2234     cls.add_constructor([param('ns3::SocketFactory&', 'arg0', is_const=True)])
  2183     ## socket-factory.h: static ns3::TypeId ns3::SocketFactory::GetTypeId() [member function]
  2235     ## socket-factory.h: static ns3::TypeId ns3::SocketFactory::GetTypeId() [member function]
  2184     cls.add_method('GetTypeId', 
  2236     cls.add_method('GetTypeId', 
  2185                    'ns3::TypeId', 
  2237                    'ns3::TypeId', 
  2186                    [], 
  2238                    [], 
  2187                    is_static=True)
  2239                    is_static=True)
  2190     ## socket-factory.h: ns3::Ptr<ns3::Socket> ns3::SocketFactory::CreateSocket() [member function]
  2242     ## socket-factory.h: ns3::Ptr<ns3::Socket> ns3::SocketFactory::CreateSocket() [member function]
  2191     cls.add_method('CreateSocket', 
  2243     cls.add_method('CreateSocket', 
  2192                    'ns3::Ptr< ns3::Socket >', 
  2244                    'ns3::Ptr< ns3::Socket >', 
  2193                    [], 
  2245                    [], 
  2194                    is_pure_virtual=True, is_virtual=True)
  2246                    is_pure_virtual=True, is_virtual=True)
  2195     cls.add_copy_constructor()
       
  2196     return
  2247     return
  2197 
  2248 
  2198 def register_Ns3EthernetTrailer_methods(root_module, cls):
  2249 def register_Ns3EthernetTrailer_methods(root_module, cls):
       
  2250     ## ethernet-trailer.h: ns3::EthernetTrailer::EthernetTrailer(ns3::EthernetTrailer const & arg0) [copy constructor]
       
  2251     cls.add_constructor([param('ns3::EthernetTrailer&', 'arg0', is_const=True)])
  2199     ## ethernet-trailer.h: ns3::EthernetTrailer::EthernetTrailer() [constructor]
  2252     ## ethernet-trailer.h: ns3::EthernetTrailer::EthernetTrailer() [constructor]
  2200     cls.add_constructor([])
  2253     cls.add_constructor([])
  2201     ## ethernet-trailer.h: static void ns3::EthernetTrailer::EnableFcs(bool enable) [member function]
  2254     ## ethernet-trailer.h: static void ns3::EthernetTrailer::EnableFcs(bool enable) [member function]
  2202     cls.add_method('EnableFcs', 
  2255     cls.add_method('EnableFcs', 
  2203                    'void', 
  2256                    'void', 
  2253     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::Deserialize(ns3::Buffer::Iterator end) [member function]
  2306     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::Deserialize(ns3::Buffer::Iterator end) [member function]
  2254     cls.add_method('Deserialize', 
  2307     cls.add_method('Deserialize', 
  2255                    'uint32_t', 
  2308                    'uint32_t', 
  2256                    [param('ns3::Buffer::Iterator', 'end')], 
  2309                    [param('ns3::Buffer::Iterator', 'end')], 
  2257                    is_virtual=True)
  2310                    is_virtual=True)
  2258     cls.add_copy_constructor()
       
  2259     return
  2311     return
  2260 
  2312 
  2261 def register_Ns3SimpleChannel_methods(root_module, cls):
  2313 def register_Ns3SimpleChannel_methods(root_module, cls):
       
  2314     ## simple-channel.h: ns3::SimpleChannel::SimpleChannel(ns3::SimpleChannel const & arg0) [copy constructor]
       
  2315     cls.add_constructor([param('ns3::SimpleChannel&', 'arg0', is_const=True)])
  2262     ## simple-channel.h: static ns3::TypeId ns3::SimpleChannel::GetTypeId() [member function]
  2316     ## simple-channel.h: static ns3::TypeId ns3::SimpleChannel::GetTypeId() [member function]
  2263     cls.add_method('GetTypeId', 
  2317     cls.add_method('GetTypeId', 
  2264                    'ns3::TypeId', 
  2318                    'ns3::TypeId', 
  2265                    [], 
  2319                    [], 
  2266                    is_static=True)
  2320                    is_static=True)
  2282     ## simple-channel.h: ns3::Ptr<ns3::NetDevice> ns3::SimpleChannel::GetDevice(uint32_t i) const [member function]
  2336     ## simple-channel.h: ns3::Ptr<ns3::NetDevice> ns3::SimpleChannel::GetDevice(uint32_t i) const [member function]
  2283     cls.add_method('GetDevice', 
  2337     cls.add_method('GetDevice', 
  2284                    'ns3::Ptr< ns3::NetDevice >', 
  2338                    'ns3::Ptr< ns3::NetDevice >', 
  2285                    [param('uint32_t', 'i')], 
  2339                    [param('uint32_t', 'i')], 
  2286                    is_const=True, is_virtual=True)
  2340                    is_const=True, is_virtual=True)
  2287     cls.add_copy_constructor()
       
  2288     return
  2341     return
  2289 
  2342 
  2290 def register_Ns3LlcSnapHeader_methods(root_module, cls):
  2343 def register_Ns3LlcSnapHeader_methods(root_module, cls):
       
  2344     ## llc-snap-header.h: ns3::LlcSnapHeader::LlcSnapHeader(ns3::LlcSnapHeader const & arg0) [copy constructor]
       
  2345     cls.add_constructor([param('ns3::LlcSnapHeader&', 'arg0', is_const=True)])
  2291     ## llc-snap-header.h: ns3::LlcSnapHeader::LlcSnapHeader() [constructor]
  2346     ## llc-snap-header.h: ns3::LlcSnapHeader::LlcSnapHeader() [constructor]
  2292     cls.add_constructor([])
  2347     cls.add_constructor([])
  2293     ## llc-snap-header.h: void ns3::LlcSnapHeader::SetType(uint16_t type) [member function]
  2348     ## llc-snap-header.h: void ns3::LlcSnapHeader::SetType(uint16_t type) [member function]
  2294     cls.add_method('SetType', 
  2349     cls.add_method('SetType', 
  2295                    'void', 
  2350                    'void', 
  2326     ## llc-snap-header.h: uint32_t ns3::LlcSnapHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
  2381     ## llc-snap-header.h: uint32_t ns3::LlcSnapHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
  2327     cls.add_method('Deserialize', 
  2382     cls.add_method('Deserialize', 
  2328                    'uint32_t', 
  2383                    'uint32_t', 
  2329                    [param('ns3::Buffer::Iterator', 'start')], 
  2384                    [param('ns3::Buffer::Iterator', 'start')], 
  2330                    is_virtual=True)
  2385                    is_virtual=True)
  2331     cls.add_copy_constructor()
       
  2332     return
  2386     return
  2333 
  2387 
  2334 def register_Ns3UdpSocketFactory_methods(root_module, cls):
  2388 def register_Ns3UdpSocketFactory_methods(root_module, cls):
       
  2389     ## udp-socket-factory.h: ns3::UdpSocketFactory::UdpSocketFactory(ns3::UdpSocketFactory const & arg0) [copy constructor]
       
  2390     cls.add_constructor([param('ns3::UdpSocketFactory&', 'arg0', is_const=True)])
       
  2391     ## udp-socket-factory.h: ns3::UdpSocketFactory::UdpSocketFactory() [constructor]
       
  2392     cls.add_constructor([])
  2335     ## udp-socket-factory.h: static ns3::TypeId ns3::UdpSocketFactory::GetTypeId() [member function]
  2393     ## udp-socket-factory.h: static ns3::TypeId ns3::UdpSocketFactory::GetTypeId() [member function]
  2336     cls.add_method('GetTypeId', 
  2394     cls.add_method('GetTypeId', 
  2337                    'ns3::TypeId', 
  2395                    'ns3::TypeId', 
  2338                    [], 
  2396                    [], 
  2339                    is_static=True)
  2397                    is_static=True)
  2340     cls.add_constructor([])
       
  2341     cls.add_copy_constructor()
       
  2342     return
  2398     return
  2343 
  2399 
  2344 def register_Ns3SimpleNetDevice_methods(root_module, cls):
  2400 def register_Ns3SimpleNetDevice_methods(root_module, cls):
       
  2401     ## simple-net-device.h: ns3::SimpleNetDevice::SimpleNetDevice(ns3::SimpleNetDevice const & arg0) [copy constructor]
       
  2402     cls.add_constructor([param('ns3::SimpleNetDevice&', 'arg0', is_const=True)])
  2345     ## simple-net-device.h: static ns3::TypeId ns3::SimpleNetDevice::GetTypeId() [member function]
  2403     ## simple-net-device.h: static ns3::TypeId ns3::SimpleNetDevice::GetTypeId() [member function]
  2346     cls.add_method('GetTypeId', 
  2404     cls.add_method('GetTypeId', 
  2347                    'ns3::TypeId', 
  2405                    'ns3::TypeId', 
  2348                    [], 
  2406                    [], 
  2349                    is_static=True)
  2407                    is_static=True)
  2464     ## simple-net-device.h: bool ns3::SimpleNetDevice::NeedsArp() const [member function]
  2522     ## simple-net-device.h: bool ns3::SimpleNetDevice::NeedsArp() const [member function]
  2465     cls.add_method('NeedsArp', 
  2523     cls.add_method('NeedsArp', 
  2466                    'bool', 
  2524                    'bool', 
  2467                    [], 
  2525                    [], 
  2468                    is_const=True, is_virtual=True)
  2526                    is_const=True, is_virtual=True)
  2469     ## simple-net-device.h: void ns3::SimpleNetDevice::SetReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, unsigned short, ns3::Address const&, ns3::empty, ns3::empty> cb) [member function]
  2527     ## 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]
  2470     cls.add_method('SetReceiveCallback', 
  2528     cls.add_method('SetReceiveCallback', 
  2471                    'void', 
  2529                    'void', 
  2472                    [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr<const ns3::Packet >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], 
  2530                    [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], 
  2473                    is_virtual=True)
  2531                    is_virtual=True)
  2474     ## simple-net-device.h: void ns3::SimpleNetDevice::SetPromiscReceiveCallback(ns3::Callback<bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<ns3::Packet>, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType> cb) [member function]
  2532     ## 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]
  2475     cls.add_method('SetPromiscReceiveCallback', 
  2533     cls.add_method('SetPromiscReceiveCallback', 
  2476                    'void', 
  2534                    'void', 
  2477                    [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr<const ns3::Packet >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'cb')], 
  2535                    [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')], 
  2478                    is_virtual=True)
  2536                    is_virtual=True)
  2479     ## simple-net-device.h: bool ns3::SimpleNetDevice::SupportsPromiscuous() const [member function]
  2537     ## simple-net-device.h: bool ns3::SimpleNetDevice::SupportsPromiscuous() const [member function]
  2480     cls.add_method('SupportsPromiscuous', 
  2538     cls.add_method('SupportsPromiscuous', 
  2481                    'bool', 
  2539                    'bool', 
  2482                    [], 
  2540                    [], 
  2484     ## simple-net-device.h: void ns3::SimpleNetDevice::DoDispose() [member function]
  2542     ## simple-net-device.h: void ns3::SimpleNetDevice::DoDispose() [member function]
  2485     cls.add_method('DoDispose', 
  2543     cls.add_method('DoDispose', 
  2486                    'void', 
  2544                    'void', 
  2487                    [], 
  2545                    [], 
  2488                    visibility='protected', is_virtual=True)
  2546                    visibility='protected', is_virtual=True)
  2489     cls.add_copy_constructor()
       
  2490     return
  2547     return
  2491 
  2548 
  2492 def register_Ns3TcpSocketFactory_methods(root_module, cls):
  2549 def register_Ns3TcpSocketFactory_methods(root_module, cls):
       
  2550     ## tcp-socket-factory.h: ns3::TcpSocketFactory::TcpSocketFactory(ns3::TcpSocketFactory const & arg0) [copy constructor]
       
  2551     cls.add_constructor([param('ns3::TcpSocketFactory&', 'arg0', is_const=True)])
       
  2552     ## tcp-socket-factory.h: ns3::TcpSocketFactory::TcpSocketFactory() [constructor]
       
  2553     cls.add_constructor([])
  2493     ## tcp-socket-factory.h: static ns3::TypeId ns3::TcpSocketFactory::GetTypeId() [member function]
  2554     ## tcp-socket-factory.h: static ns3::TypeId ns3::TcpSocketFactory::GetTypeId() [member function]
  2494     cls.add_method('GetTypeId', 
  2555     cls.add_method('GetTypeId', 
  2495                    'ns3::TypeId', 
  2556                    'ns3::TypeId', 
  2496                    [], 
  2557                    [], 
  2497                    is_static=True)
  2558                    is_static=True)
  2498     cls.add_constructor([])
       
  2499     cls.add_copy_constructor()
       
  2500     return
  2559     return
  2501 
  2560 
  2502 def register_Ns3PacketSocketFactory_methods(root_module, cls):
  2561 def register_Ns3PacketSocketFactory_methods(root_module, cls):
       
  2562     ## packet-socket-factory.h: ns3::PacketSocketFactory::PacketSocketFactory(ns3::PacketSocketFactory const & arg0) [copy constructor]
       
  2563     cls.add_constructor([param('ns3::PacketSocketFactory&', 'arg0', is_const=True)])
  2503     ## packet-socket-factory.h: static ns3::TypeId ns3::PacketSocketFactory::GetTypeId() [member function]
  2564     ## packet-socket-factory.h: static ns3::TypeId ns3::PacketSocketFactory::GetTypeId() [member function]
  2504     cls.add_method('GetTypeId', 
  2565     cls.add_method('GetTypeId', 
  2505                    'ns3::TypeId', 
  2566                    'ns3::TypeId', 
  2506                    [], 
  2567                    [], 
  2507                    is_static=True)
  2568                    is_static=True)
  2510     ## packet-socket-factory.h: ns3::Ptr<ns3::Socket> ns3::PacketSocketFactory::CreateSocket() [member function]
  2571     ## packet-socket-factory.h: ns3::Ptr<ns3::Socket> ns3::PacketSocketFactory::CreateSocket() [member function]
  2511     cls.add_method('CreateSocket', 
  2572     cls.add_method('CreateSocket', 
  2512                    'ns3::Ptr< ns3::Socket >', 
  2573                    'ns3::Ptr< ns3::Socket >', 
  2513                    [], 
  2574                    [], 
  2514                    is_virtual=True)
  2575                    is_virtual=True)
  2515     cls.add_copy_constructor()
       
  2516     return
  2576     return
  2517 
  2577 
  2518 def register_functions(root_module):
  2578 def register_functions(root_module):
  2519     module = root_module
  2579     module = root_module
  2520     ## mac48-address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeMac48AddressChecker() [free function]
  2580     ## mac48-address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeMac48AddressChecker() [free function]