bindings/python/ns3_module_node.py
changeset 3468 0bb5275704fc
parent 3460 99698bc858e8
child 3474 dac9146297c8
equal deleted inserted replaced
3467:351f5847dda5 3468:0bb5275704fc
     1 from pybindgen import Module, FileCodeSink, write_preamble, param, retval
     1 from pybindgen import Module, FileCodeSink, param, retval, cppclass
     2 
     2 
     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]
   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_Ns3NodeList_methods(root_module, cls):
   194 def register_Ns3NodeList_methods(root_module, cls):
   195     ## node-list.h: static uint32_t ns3::NodeList::Add(ns3::Ptr<ns3::Node> node) [member function]
   195     ## node-list.h: static uint32_t ns3::NodeList::Add(ns3::Ptr<ns3::Node> node) [member function]
   196     cls.add_method('Add', 'uint32_t', [param('ns3::Ptr< ns3::Node >', 'node')], is_static=True)
   196     cls.add_method('Add', 
       
   197                    'uint32_t', 
       
   198                    [param('ns3::Ptr< ns3::Node >', 'node')], 
       
   199                    is_static=True)
   197     ## 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]
   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]
   198     cls.add_method('Begin', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node >, std::allocator< ns3::Ptr< ns3::Node > > > >', [], is_static=True)
   201     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 > > > >', 
       
   203                    [], 
       
   204                    is_static=True)
   199     ## 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]
   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]
   200     cls.add_method('End', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Node >, std::vector< ns3::Ptr< ns3::Node >, std::allocator< ns3::Ptr< ns3::Node > > > >', [], is_static=True)
   206     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 > > > >', 
       
   208                    [], 
       
   209                    is_static=True)
   201     ## node-list.h: static ns3::Ptr<ns3::Node> ns3::NodeList::GetNode(uint32_t n) [member function]
   210     ## node-list.h: static ns3::Ptr<ns3::Node> ns3::NodeList::GetNode(uint32_t n) [member function]
   202     cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', [param('uint32_t', 'n')], is_static=True)
   211     cls.add_method('GetNode', 
       
   212                    'ns3::Ptr< ns3::Node >', 
       
   213                    [param('uint32_t', 'n')], 
       
   214                    is_static=True)
   203     ## node-list.h: static uint32_t ns3::NodeList::GetNNodes() [member function]
   215     ## node-list.h: static uint32_t ns3::NodeList::GetNNodes() [member function]
   204     cls.add_method('GetNNodes', 'uint32_t', [], is_static=True)
   216     cls.add_method('GetNNodes', 
       
   217                    'uint32_t', 
       
   218                    [], 
       
   219                    is_static=True)
   205     cls.add_constructor([])
   220     cls.add_constructor([])
   206     return
   221     return
   207 
   222 
   208 def register_Ns3Address_methods(root_module, cls):
   223 def register_Ns3Address_methods(root_module, cls):
   209     ## address.h: ns3::Address::Address() [constructor]
   224     ## address.h: ns3::Address::Address() [constructor]
   210     cls.add_constructor([], visibility='public')
   225     cls.add_constructor([])
   211     ## address.h: ns3::Address::Address(uint8_t type, uint8_t const * buffer, uint8_t len) [constructor]
   226     ## address.h: ns3::Address::Address(uint8_t type, uint8_t const * buffer, uint8_t len) [constructor]
   212     cls.add_constructor([param('uint8_t', 'type'), param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint8_t', 'len')], visibility='public')
   227     cls.add_constructor([param('uint8_t', 'type'), param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint8_t', 'len')])
   213     ## address.h: ns3::Address::Address(ns3::Address const & address) [copy constructor]
   228     ## address.h: ns3::Address::Address(ns3::Address const & address) [copy constructor]
   214     cls.add_constructor([param('ns3::Address&', 'address', is_const=True)], visibility='public')
   229     cls.add_constructor([param('ns3::Address&', 'address', is_const=True)])
   215     ## address.h: bool ns3::Address::CheckCompatible(uint8_t type, uint8_t len) const [member function]
   230     ## address.h: bool ns3::Address::CheckCompatible(uint8_t type, uint8_t len) const [member function]
   216     cls.add_method('CheckCompatible', 'bool', [param('uint8_t', 'type'), param('uint8_t', 'len')], is_const=True)
   231     cls.add_method('CheckCompatible', 
       
   232                    'bool', 
       
   233                    [param('uint8_t', 'type'), param('uint8_t', 'len')], 
       
   234                    is_const=True)
   217     ## address.h: uint32_t ns3::Address::CopyAllFrom(uint8_t const * buffer, uint8_t len) [member function]
   235     ## address.h: uint32_t ns3::Address::CopyAllFrom(uint8_t const * buffer, uint8_t len) [member function]
   218     cls.add_method('CopyAllFrom', 'uint32_t', [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint8_t', 'len')])
   236     cls.add_method('CopyAllFrom', 
       
   237                    'uint32_t', 
       
   238                    [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint8_t', 'len')])
   219     ## address.h: uint32_t ns3::Address::CopyAllTo(uint8_t * buffer, uint8_t len) const [member function]
   239     ## address.h: uint32_t ns3::Address::CopyAllTo(uint8_t * buffer, uint8_t len) const [member function]
   220     cls.add_method('CopyAllTo', 'uint32_t', [param('uint8_t *', 'buffer'), param('uint8_t', 'len')], is_const=True)
   240     cls.add_method('CopyAllTo', 
       
   241                    'uint32_t', 
       
   242                    [param('uint8_t *', 'buffer'), param('uint8_t', 'len')], 
       
   243                    is_const=True)
   221     ## address.h: uint32_t ns3::Address::CopyFrom(uint8_t const * buffer, uint8_t len) [member function]
   244     ## address.h: uint32_t ns3::Address::CopyFrom(uint8_t const * buffer, uint8_t len) [member function]
   222     cls.add_method('CopyFrom', 'uint32_t', [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint8_t', 'len')])
   245     cls.add_method('CopyFrom', 
       
   246                    'uint32_t', 
       
   247                    [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True), param('uint8_t', 'len')])
   223     ## address.h: uint32_t ns3::Address::CopyTo(uint8_t * buffer) const [member function]
   248     ## address.h: uint32_t ns3::Address::CopyTo(uint8_t * buffer) const [member function]
   224     cls.add_method('CopyTo', 'uint32_t', [param('uint8_t *', 'buffer')], is_const=True)
   249     cls.add_method('CopyTo', 
       
   250                    'uint32_t', 
       
   251                    [param('uint8_t *', 'buffer')], 
       
   252                    is_const=True)
   225     ## address.h: void ns3::Address::Deserialize(ns3::TagBuffer buffer) [member function]
   253     ## address.h: void ns3::Address::Deserialize(ns3::TagBuffer buffer) [member function]
   226     cls.add_method('Deserialize', 'void', [param('ns3::TagBuffer', 'buffer')])
   254     cls.add_method('Deserialize', 
       
   255                    'void', 
       
   256                    [param('ns3::TagBuffer', 'buffer')])
   227     ## address.h: uint8_t ns3::Address::GetLength() const [member function]
   257     ## address.h: uint8_t ns3::Address::GetLength() const [member function]
   228     cls.add_method('GetLength', 'uint8_t', [], is_const=True)
   258     cls.add_method('GetLength', 
       
   259                    'uint8_t', 
       
   260                    [], 
       
   261                    is_const=True)
   229     ## address.h: uint32_t ns3::Address::GetSerializedSize() const [member function]
   262     ## address.h: uint32_t ns3::Address::GetSerializedSize() const [member function]
   230     cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True)
   263     cls.add_method('GetSerializedSize', 
       
   264                    'uint32_t', 
       
   265                    [], 
       
   266                    is_const=True)
   231     ## address.h: bool ns3::Address::IsInvalid() const [member function]
   267     ## address.h: bool ns3::Address::IsInvalid() const [member function]
   232     cls.add_method('IsInvalid', 'bool', [], is_const=True)
   268     cls.add_method('IsInvalid', 
       
   269                    'bool', 
       
   270                    [], 
       
   271                    is_const=True)
   233     ## address.h: bool ns3::Address::IsMatchingType(uint8_t type) const [member function]
   272     ## address.h: bool ns3::Address::IsMatchingType(uint8_t type) const [member function]
   234     cls.add_method('IsMatchingType', 'bool', [param('uint8_t', 'type')], is_const=True)
   273     cls.add_method('IsMatchingType', 
       
   274                    'bool', 
       
   275                    [param('uint8_t', 'type')], 
       
   276                    is_const=True)
   235     ## address.h: static uint8_t ns3::Address::Register() [member function]
   277     ## address.h: static uint8_t ns3::Address::Register() [member function]
   236     cls.add_method('Register', 'uint8_t', [], is_static=True)
   278     cls.add_method('Register', 
       
   279                    'uint8_t', 
       
   280                    [], 
       
   281                    is_static=True)
   237     ## address.h: void ns3::Address::Serialize(ns3::TagBuffer buffer) const [member function]
   282     ## address.h: void ns3::Address::Serialize(ns3::TagBuffer buffer) const [member function]
   238     cls.add_method('Serialize', 'void', [param('ns3::TagBuffer', 'buffer')], is_const=True)
   283     cls.add_method('Serialize', 
       
   284                    'void', 
       
   285                    [param('ns3::TagBuffer', 'buffer')], 
       
   286                    is_const=True)
   239     cls.add_output_stream_operator()
   287     cls.add_output_stream_operator()
   240     return
   288     return
   241 
   289 
   242 def register_Ns3Ipv4AddressChecker_methods(root_module, cls):
   290 def register_Ns3Ipv4AddressChecker_methods(root_module, cls):
   243     cls.add_constructor([])
   291     cls.add_constructor([])
   244     return
   292     return
   245 
   293 
   246 def register_Ns3Mac48Address_methods(root_module, cls):
   294 def register_Ns3Mac48Address_methods(root_module, cls):
   247     ## mac48-address.h: ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [copy constructor]
   295     ## mac48-address.h: ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [copy constructor]
   248     cls.add_constructor([param('ns3::Mac48Address&', 'arg0', is_const=True)], visibility='public')
   296     cls.add_constructor([param('ns3::Mac48Address&', 'arg0', is_const=True)])
   249     ## mac48-address.h: ns3::Mac48Address::Mac48Address() [constructor]
   297     ## mac48-address.h: ns3::Mac48Address::Mac48Address() [constructor]
   250     cls.add_constructor([], visibility='public')
   298     cls.add_constructor([])
   251     ## mac48-address.h: ns3::Mac48Address::Mac48Address(char const * str) [constructor]
   299     ## mac48-address.h: ns3::Mac48Address::Mac48Address(char const * str) [constructor]
   252     cls.add_constructor([param('char *', 'str', transfer_ownership=False, is_const=True)], visibility='public')
   300     cls.add_constructor([param('char *', 'str', transfer_ownership=False, is_const=True)])
   253     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::Allocate() [member function]
   301     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::Allocate() [member function]
   254     cls.add_method('Allocate', 'ns3::Mac48Address', [], is_static=True)
   302     cls.add_method('Allocate', 
       
   303                    'ns3::Mac48Address', 
       
   304                    [], 
       
   305                    is_static=True)
   255     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::ConvertFrom(ns3::Address const & address) [member function]
   306     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::ConvertFrom(ns3::Address const & address) [member function]
   256     cls.add_method('ConvertFrom', 'ns3::Mac48Address', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
   307     cls.add_method('ConvertFrom', 
       
   308                    'ns3::Mac48Address', 
       
   309                    [param('ns3::Address&', 'address', is_const=True)], 
       
   310                    is_static=True)
   257     ## mac48-address.h: void ns3::Mac48Address::CopyFrom(uint8_t const * buffer) [member function]
   311     ## mac48-address.h: void ns3::Mac48Address::CopyFrom(uint8_t const * buffer) [member function]
   258     cls.add_method('CopyFrom', 'void', [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True)])
   312     cls.add_method('CopyFrom', 
       
   313                    'void', 
       
   314                    [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True)])
   259     ## mac48-address.h: void ns3::Mac48Address::CopyTo(uint8_t * buffer) const [member function]
   315     ## mac48-address.h: void ns3::Mac48Address::CopyTo(uint8_t * buffer) const [member function]
   260     cls.add_method('CopyTo', 'void', [param('uint8_t *', 'buffer')], is_const=True)
   316     cls.add_method('CopyTo', 
       
   317                    'void', 
       
   318                    [param('uint8_t *', 'buffer')], 
       
   319                    is_const=True)
   261     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::GetBroadcast() [member function]
   320     ## mac48-address.h: static ns3::Mac48Address ns3::Mac48Address::GetBroadcast() [member function]
   262     cls.add_method('GetBroadcast', 'ns3::Mac48Address', [], is_static=True)
   321     cls.add_method('GetBroadcast', 
       
   322                    'ns3::Mac48Address', 
       
   323                    [], 
       
   324                    is_static=True)
   263     ## mac48-address.h: bool ns3::Mac48Address::IsBroadcast() const [member function]
   325     ## mac48-address.h: bool ns3::Mac48Address::IsBroadcast() const [member function]
   264     cls.add_method('IsBroadcast', 'bool', [], is_const=True)
   326     cls.add_method('IsBroadcast', 
       
   327                    'bool', 
       
   328                    [], 
       
   329                    is_const=True)
   265     ## mac48-address.h: static bool ns3::Mac48Address::IsMatchingType(ns3::Address const & address) [member function]
   330     ## mac48-address.h: static bool ns3::Mac48Address::IsMatchingType(ns3::Address const & address) [member function]
   266     cls.add_method('IsMatchingType', 'bool', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
   331     cls.add_method('IsMatchingType', 
       
   332                    'bool', 
       
   333                    [param('ns3::Address&', 'address', is_const=True)], 
       
   334                    is_static=True)
   267     ## mac48-address.h: bool ns3::Mac48Address::IsMulticast() const [member function]
   335     ## mac48-address.h: bool ns3::Mac48Address::IsMulticast() const [member function]
   268     cls.add_method('IsMulticast', 'bool', [], is_const=True)
   336     cls.add_method('IsMulticast', 
       
   337                    'bool', 
       
   338                    [], 
       
   339                    is_const=True)
   269     cls.add_output_stream_operator()
   340     cls.add_output_stream_operator()
   270     return
   341     return
   271 
   342 
   272 def register_Ns3Mac64Address_methods(root_module, cls):
   343 def register_Ns3Mac64Address_methods(root_module, cls):
   273     ## mac64-address.h: ns3::Mac64Address::Mac64Address(ns3::Mac64Address const & arg0) [copy constructor]
   344     ## mac64-address.h: ns3::Mac64Address::Mac64Address(ns3::Mac64Address const & arg0) [copy constructor]
   274     cls.add_constructor([param('ns3::Mac64Address&', 'arg0', is_const=True)], visibility='public')
   345     cls.add_constructor([param('ns3::Mac64Address&', 'arg0', is_const=True)])
   275     ## mac64-address.h: ns3::Mac64Address::Mac64Address() [constructor]
   346     ## mac64-address.h: ns3::Mac64Address::Mac64Address() [constructor]
   276     cls.add_constructor([], visibility='public')
   347     cls.add_constructor([])
   277     ## mac64-address.h: ns3::Mac64Address::Mac64Address(char const * str) [constructor]
   348     ## mac64-address.h: ns3::Mac64Address::Mac64Address(char const * str) [constructor]
   278     cls.add_constructor([param('char *', 'str', transfer_ownership=False, is_const=True)], visibility='public')
   349     cls.add_constructor([param('char *', 'str', transfer_ownership=False, is_const=True)])
   279     ## mac64-address.h: static ns3::Mac64Address ns3::Mac64Address::Allocate() [member function]
   350     ## mac64-address.h: static ns3::Mac64Address ns3::Mac64Address::Allocate() [member function]
   280     cls.add_method('Allocate', 'ns3::Mac64Address', [], is_static=True)
   351     cls.add_method('Allocate', 
       
   352                    'ns3::Mac64Address', 
       
   353                    [], 
       
   354                    is_static=True)
   281     ## mac64-address.h: static ns3::Mac64Address ns3::Mac64Address::ConvertFrom(ns3::Address const & address) [member function]
   355     ## mac64-address.h: static ns3::Mac64Address ns3::Mac64Address::ConvertFrom(ns3::Address const & address) [member function]
   282     cls.add_method('ConvertFrom', 'ns3::Mac64Address', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
   356     cls.add_method('ConvertFrom', 
       
   357                    'ns3::Mac64Address', 
       
   358                    [param('ns3::Address&', 'address', is_const=True)], 
       
   359                    is_static=True)
   283     ## mac64-address.h: void ns3::Mac64Address::CopyFrom(uint8_t const * buffer) [member function]
   360     ## mac64-address.h: void ns3::Mac64Address::CopyFrom(uint8_t const * buffer) [member function]
   284     cls.add_method('CopyFrom', 'void', [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True)])
   361     cls.add_method('CopyFrom', 
       
   362                    'void', 
       
   363                    [param('uint8_t *', 'buffer', transfer_ownership=False, is_const=True)])
   285     ## mac64-address.h: void ns3::Mac64Address::CopyTo(uint8_t * buffer) const [member function]
   364     ## mac64-address.h: void ns3::Mac64Address::CopyTo(uint8_t * buffer) const [member function]
   286     cls.add_method('CopyTo', 'void', [param('uint8_t *', 'buffer')], is_const=True)
   365     cls.add_method('CopyTo', 
       
   366                    'void', 
       
   367                    [param('uint8_t *', 'buffer')], 
       
   368                    is_const=True)
   287     ## mac64-address.h: static bool ns3::Mac64Address::IsMatchingType(ns3::Address const & address) [member function]
   369     ## mac64-address.h: static bool ns3::Mac64Address::IsMatchingType(ns3::Address const & address) [member function]
   288     cls.add_method('IsMatchingType', 'bool', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
   370     cls.add_method('IsMatchingType', 
       
   371                    'bool', 
       
   372                    [param('ns3::Address&', 'address', is_const=True)], 
       
   373                    is_static=True)
   289     cls.add_output_stream_operator()
   374     cls.add_output_stream_operator()
   290     return
   375     return
   291 
   376 
   292 def register_Ns3Ipv4AddressGenerator_methods(root_module, cls):
   377 def register_Ns3Ipv4AddressGenerator_methods(root_module, cls):
   293     ## 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]
   378     ## 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]
   294     cls.add_method('Init', 'void', [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)], is_static=True)
   379     cls.add_method('Init', 
       
   380                    'void', 
       
   381                    [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)], 
       
   382                    is_static=True)
   295     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::NextNetwork(ns3::Ipv4Mask const mask) [member function]
   383     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::NextNetwork(ns3::Ipv4Mask const mask) [member function]
   296     cls.add_method('NextNetwork', 'ns3::Ipv4Address', [param('ns3::Ipv4Mask', 'mask', is_const=True)], is_static=True)
   384     cls.add_method('NextNetwork', 
       
   385                    'ns3::Ipv4Address', 
       
   386                    [param('ns3::Ipv4Mask', 'mask', is_const=True)], 
       
   387                    is_static=True)
   297     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::GetNetwork(ns3::Ipv4Mask const mask) [member function]
   388     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::GetNetwork(ns3::Ipv4Mask const mask) [member function]
   298     cls.add_method('GetNetwork', 'ns3::Ipv4Address', [param('ns3::Ipv4Mask', 'mask', is_const=True)], is_static=True)
   389     cls.add_method('GetNetwork', 
       
   390                    'ns3::Ipv4Address', 
       
   391                    [param('ns3::Ipv4Mask', 'mask', is_const=True)], 
       
   392                    is_static=True)
   299     ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::InitAddress(ns3::Ipv4Address const addr, ns3::Ipv4Mask const mask) [member function]
   393     ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::InitAddress(ns3::Ipv4Address const addr, ns3::Ipv4Mask const mask) [member function]
   300     cls.add_method('InitAddress', 'void', [param('ns3::Ipv4Address', 'addr', is_const=True), param('ns3::Ipv4Mask', 'mask', is_const=True)], is_static=True)
   394     cls.add_method('InitAddress', 
       
   395                    'void', 
       
   396                    [param('ns3::Ipv4Address', 'addr', is_const=True), param('ns3::Ipv4Mask', 'mask', is_const=True)], 
       
   397                    is_static=True)
   301     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::NextAddress(ns3::Ipv4Mask const mask) [member function]
   398     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::NextAddress(ns3::Ipv4Mask const mask) [member function]
   302     cls.add_method('NextAddress', 'ns3::Ipv4Address', [param('ns3::Ipv4Mask', 'mask', is_const=True)], is_static=True)
   399     cls.add_method('NextAddress', 
       
   400                    'ns3::Ipv4Address', 
       
   401                    [param('ns3::Ipv4Mask', 'mask', is_const=True)], 
       
   402                    is_static=True)
   303     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::GetAddress(ns3::Ipv4Mask const mask) [member function]
   403     ## ipv4-address-generator.h: static ns3::Ipv4Address ns3::Ipv4AddressGenerator::GetAddress(ns3::Ipv4Mask const mask) [member function]
   304     cls.add_method('GetAddress', 'ns3::Ipv4Address', [param('ns3::Ipv4Mask', 'mask', is_const=True)], is_static=True)
   404     cls.add_method('GetAddress', 
       
   405                    'ns3::Ipv4Address', 
       
   406                    [param('ns3::Ipv4Mask', 'mask', is_const=True)], 
       
   407                    is_static=True)
   305     ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::Reset() [member function]
   408     ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::Reset() [member function]
   306     cls.add_method('Reset', 'void', [], is_static=True)
   409     cls.add_method('Reset', 
       
   410                    'void', 
       
   411                    [], 
       
   412                    is_static=True)
   307     ## ipv4-address-generator.h: static bool ns3::Ipv4AddressGenerator::AddAllocated(ns3::Ipv4Address const addr) [member function]
   413     ## ipv4-address-generator.h: static bool ns3::Ipv4AddressGenerator::AddAllocated(ns3::Ipv4Address const addr) [member function]
   308     cls.add_method('AddAllocated', 'bool', [param('ns3::Ipv4Address', 'addr', is_const=True)], is_static=True)
   414     cls.add_method('AddAllocated', 
       
   415                    'bool', 
       
   416                    [param('ns3::Ipv4Address', 'addr', is_const=True)], 
       
   417                    is_static=True)
   309     ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::TestMode() [member function]
   418     ## ipv4-address-generator.h: static void ns3::Ipv4AddressGenerator::TestMode() [member function]
   310     cls.add_method('TestMode', 'void', [], is_static=True)
   419     cls.add_method('TestMode', 
       
   420                    'void', 
       
   421                    [], 
       
   422                    is_static=True)
   311     cls.add_constructor([])
   423     cls.add_constructor([])
   312     return
   424     return
   313 
   425 
   314 def register_Ns3Mac48AddressChecker_methods(root_module, cls):
   426 def register_Ns3Mac48AddressChecker_methods(root_module, cls):
   315     cls.add_constructor([])
   427     cls.add_constructor([])
   319     cls.add_constructor([])
   431     cls.add_constructor([])
   320     return
   432     return
   321 
   433 
   322 def register_Ns3Ipv4Route_methods(root_module, cls):
   434 def register_Ns3Ipv4Route_methods(root_module, cls):
   323     ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route() [constructor]
   435     ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route() [constructor]
   324     cls.add_constructor([], visibility='public')
   436     cls.add_constructor([])
   325     ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route(ns3::Ipv4Route const & route) [copy constructor]
   437     ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route(ns3::Ipv4Route const & route) [copy constructor]
   326     cls.add_constructor([param('ns3::Ipv4Route&', 'route', is_const=True)], visibility='public')
   438     cls.add_constructor([param('ns3::Ipv4Route&', 'route', is_const=True)])
   327     ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route(ns3::Ipv4Route const * route) [constructor]
   439     ## ipv4-route.h: ns3::Ipv4Route::Ipv4Route(ns3::Ipv4Route const * route) [constructor]
   328     cls.add_constructor([param('ns3::Ipv4Route *', 'route', transfer_ownership=False, is_const=True)], visibility='public')
   440     cls.add_constructor([param('ns3::Ipv4Route *', 'route', transfer_ownership=False, is_const=True)])
   329     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateDefaultRoute(ns3::Ipv4Address nextHop, uint32_t interface) [member function]
   441     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateDefaultRoute(ns3::Ipv4Address nextHop, uint32_t interface) [member function]
   330     cls.add_method('CreateDefaultRoute', 'ns3::Ipv4Route', [param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], is_static=True)
   442     cls.add_method('CreateDefaultRoute', 
       
   443                    'ns3::Ipv4Route', 
       
   444                    [param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], 
       
   445                    is_static=True)
   331     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateHostRouteTo(ns3::Ipv4Address dest, ns3::Ipv4Address nextHop, uint32_t interface) [member function]
   446     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateHostRouteTo(ns3::Ipv4Address dest, ns3::Ipv4Address nextHop, uint32_t interface) [member function]
   332     cls.add_method('CreateHostRouteTo', 'ns3::Ipv4Route', [param('ns3::Ipv4Address', 'dest'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], is_static=True)
   447     cls.add_method('CreateHostRouteTo', 
       
   448                    'ns3::Ipv4Route', 
       
   449                    [param('ns3::Ipv4Address', 'dest'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], 
       
   450                    is_static=True)
   333     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateHostRouteTo(ns3::Ipv4Address dest, uint32_t interface) [member function]
   451     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateHostRouteTo(ns3::Ipv4Address dest, uint32_t interface) [member function]
   334     cls.add_method('CreateHostRouteTo', 'ns3::Ipv4Route', [param('ns3::Ipv4Address', 'dest'), param('uint32_t', 'interface')], is_static=True)
   452     cls.add_method('CreateHostRouteTo', 
       
   453                    'ns3::Ipv4Route', 
       
   454                    [param('ns3::Ipv4Address', 'dest'), param('uint32_t', 'interface')], 
       
   455                    is_static=True)
   335     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, ns3::Ipv4Address nextHop, uint32_t interface) [member function]
   456     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, ns3::Ipv4Address nextHop, uint32_t interface) [member function]
   336     cls.add_method('CreateNetworkRouteTo', 'ns3::Ipv4Route', [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], is_static=True)
   457     cls.add_method('CreateNetworkRouteTo', 
       
   458                    'ns3::Ipv4Route', 
       
   459                    [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], 
       
   460                    is_static=True)
   337     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, uint32_t interface) [member function]
   461     ## ipv4-route.h: static ns3::Ipv4Route ns3::Ipv4Route::CreateNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, uint32_t interface) [member function]
   338     cls.add_method('CreateNetworkRouteTo', 'ns3::Ipv4Route', [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('uint32_t', 'interface')], is_static=True)
   462     cls.add_method('CreateNetworkRouteTo', 
       
   463                    'ns3::Ipv4Route', 
       
   464                    [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('uint32_t', 'interface')], 
       
   465                    is_static=True)
   339     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4Route::GetDest() const [member function]
   466     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4Route::GetDest() const [member function]
   340     cls.add_method('GetDest', 'ns3::Ipv4Address', [], is_const=True)
   467     cls.add_method('GetDest', 
       
   468                    'ns3::Ipv4Address', 
       
   469                    [], 
       
   470                    is_const=True)
   341     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4Route::GetDestNetwork() const [member function]
   471     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4Route::GetDestNetwork() const [member function]
   342     cls.add_method('GetDestNetwork', 'ns3::Ipv4Address', [], is_const=True)
   472     cls.add_method('GetDestNetwork', 
       
   473                    'ns3::Ipv4Address', 
       
   474                    [], 
       
   475                    is_const=True)
   343     ## ipv4-route.h: ns3::Ipv4Mask ns3::Ipv4Route::GetDestNetworkMask() const [member function]
   476     ## ipv4-route.h: ns3::Ipv4Mask ns3::Ipv4Route::GetDestNetworkMask() const [member function]
   344     cls.add_method('GetDestNetworkMask', 'ns3::Ipv4Mask', [], is_const=True)
   477     cls.add_method('GetDestNetworkMask', 
       
   478                    'ns3::Ipv4Mask', 
       
   479                    [], 
       
   480                    is_const=True)
   345     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4Route::GetGateway() const [member function]
   481     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4Route::GetGateway() const [member function]
   346     cls.add_method('GetGateway', 'ns3::Ipv4Address', [], is_const=True)
   482     cls.add_method('GetGateway', 
       
   483                    'ns3::Ipv4Address', 
       
   484                    [], 
       
   485                    is_const=True)
   347     ## ipv4-route.h: uint32_t ns3::Ipv4Route::GetInterface() const [member function]
   486     ## ipv4-route.h: uint32_t ns3::Ipv4Route::GetInterface() const [member function]
   348     cls.add_method('GetInterface', 'uint32_t', [], is_const=True)
   487     cls.add_method('GetInterface', 
       
   488                    'uint32_t', 
       
   489                    [], 
       
   490                    is_const=True)
   349     ## ipv4-route.h: bool ns3::Ipv4Route::IsDefault() const [member function]
   491     ## ipv4-route.h: bool ns3::Ipv4Route::IsDefault() const [member function]
   350     cls.add_method('IsDefault', 'bool', [], is_const=True)
   492     cls.add_method('IsDefault', 
       
   493                    'bool', 
       
   494                    [], 
       
   495                    is_const=True)
   351     ## ipv4-route.h: bool ns3::Ipv4Route::IsGateway() const [member function]
   496     ## ipv4-route.h: bool ns3::Ipv4Route::IsGateway() const [member function]
   352     cls.add_method('IsGateway', 'bool', [], is_const=True)
   497     cls.add_method('IsGateway', 
       
   498                    'bool', 
       
   499                    [], 
       
   500                    is_const=True)
   353     ## ipv4-route.h: bool ns3::Ipv4Route::IsHost() const [member function]
   501     ## ipv4-route.h: bool ns3::Ipv4Route::IsHost() const [member function]
   354     cls.add_method('IsHost', 'bool', [], is_const=True)
   502     cls.add_method('IsHost', 
       
   503                    'bool', 
       
   504                    [], 
       
   505                    is_const=True)
   355     ## ipv4-route.h: bool ns3::Ipv4Route::IsNetwork() const [member function]
   506     ## ipv4-route.h: bool ns3::Ipv4Route::IsNetwork() const [member function]
   356     cls.add_method('IsNetwork', 'bool', [], is_const=True)
   507     cls.add_method('IsNetwork', 
       
   508                    'bool', 
       
   509                    [], 
       
   510                    is_const=True)
   357     cls.add_output_stream_operator()
   511     cls.add_output_stream_operator()
   358     return
   512     return
   359 
   513 
   360 def register_Ns3Ipv4MulticastRoute_methods(root_module, cls):
   514 def register_Ns3Ipv4MulticastRoute_methods(root_module, cls):
   361     ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute() [constructor]
   515     ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute() [constructor]
   362     cls.add_constructor([], visibility='public')
   516     cls.add_constructor([])
   363     ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute(ns3::Ipv4MulticastRoute const & route) [copy constructor]
   517     ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute(ns3::Ipv4MulticastRoute const & route) [copy constructor]
   364     cls.add_constructor([param('ns3::Ipv4MulticastRoute&', 'route', is_const=True)], visibility='public')
   518     cls.add_constructor([param('ns3::Ipv4MulticastRoute&', 'route', is_const=True)])
   365     ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute(ns3::Ipv4MulticastRoute const * route) [constructor]
   519     ## ipv4-route.h: ns3::Ipv4MulticastRoute::Ipv4MulticastRoute(ns3::Ipv4MulticastRoute const * route) [constructor]
   366     cls.add_constructor([param('ns3::Ipv4MulticastRoute *', 'route', transfer_ownership=False, is_const=True)], visibility='public')
   520     cls.add_constructor([param('ns3::Ipv4MulticastRoute *', 'route', transfer_ownership=False, is_const=True)])
   367     ## 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]
   521     ## 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]
   368     cls.add_method('CreateMulticastRoute', 'ns3::Ipv4MulticastRoute', [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int, std::allocator< unsigned int > >', 'outputInterfaces')], is_static=True)
   522     cls.add_method('CreateMulticastRoute', 
       
   523                    'ns3::Ipv4MulticastRoute', 
       
   524                    [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int, std::allocator< unsigned int > >', 'outputInterfaces')], 
       
   525                    is_static=True)
   369     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4MulticastRoute::GetGroup() const [member function]
   526     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4MulticastRoute::GetGroup() const [member function]
   370     cls.add_method('GetGroup', 'ns3::Ipv4Address', [], is_const=True)
   527     cls.add_method('GetGroup', 
       
   528                    'ns3::Ipv4Address', 
       
   529                    [], 
       
   530                    is_const=True)
   371     ## ipv4-route.h: uint32_t ns3::Ipv4MulticastRoute::GetInputInterface() const [member function]
   531     ## ipv4-route.h: uint32_t ns3::Ipv4MulticastRoute::GetInputInterface() const [member function]
   372     cls.add_method('GetInputInterface', 'uint32_t', [], is_const=True)
   532     cls.add_method('GetInputInterface', 
       
   533                    'uint32_t', 
       
   534                    [], 
       
   535                    is_const=True)
   373     ## ipv4-route.h: uint32_t ns3::Ipv4MulticastRoute::GetNOutputInterfaces() const [member function]
   536     ## ipv4-route.h: uint32_t ns3::Ipv4MulticastRoute::GetNOutputInterfaces() const [member function]
   374     cls.add_method('GetNOutputInterfaces', 'uint32_t', [], is_const=True)
   537     cls.add_method('GetNOutputInterfaces', 
       
   538                    'uint32_t', 
       
   539                    [], 
       
   540                    is_const=True)
   375     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4MulticastRoute::GetOrigin() const [member function]
   541     ## ipv4-route.h: ns3::Ipv4Address ns3::Ipv4MulticastRoute::GetOrigin() const [member function]
   376     cls.add_method('GetOrigin', 'ns3::Ipv4Address', [], is_const=True)
   542     cls.add_method('GetOrigin', 
       
   543                    'ns3::Ipv4Address', 
       
   544                    [], 
       
   545                    is_const=True)
   377     ## ipv4-route.h: uint32_t ns3::Ipv4MulticastRoute::GetOutputInterface(uint32_t n) const [member function]
   546     ## ipv4-route.h: uint32_t ns3::Ipv4MulticastRoute::GetOutputInterface(uint32_t n) const [member function]
   378     cls.add_method('GetOutputInterface', 'uint32_t', [param('uint32_t', 'n')], is_const=True)
   547     cls.add_method('GetOutputInterface', 
       
   548                    'uint32_t', 
       
   549                    [param('uint32_t', 'n')], 
       
   550                    is_const=True)
   379     ## ipv4-route.h: std::vector<unsigned int, std::allocator<unsigned int> > ns3::Ipv4MulticastRoute::GetOutputInterfaces() const [member function]
   551     ## ipv4-route.h: std::vector<unsigned int, std::allocator<unsigned int> > ns3::Ipv4MulticastRoute::GetOutputInterfaces() const [member function]
   380     cls.add_method('GetOutputInterfaces', 'std::vector< unsigned int, std::allocator< unsigned int > >', [], is_const=True)
   552     cls.add_method('GetOutputInterfaces', 
       
   553                    'std::vector< unsigned int, std::allocator< unsigned int > >', 
       
   554                    [], 
       
   555                    is_const=True)
   381     cls.add_output_stream_operator()
   556     cls.add_output_stream_operator()
   382     return
   557     return
   383 
   558 
   384 def register_Ns3AddressChecker_methods(root_module, cls):
   559 def register_Ns3AddressChecker_methods(root_module, cls):
   385     cls.add_constructor([])
   560     cls.add_constructor([])
   386     return
   561     return
   387 
   562 
   388 def register_Ns3PacketSocketAddress_methods(root_module, cls):
   563 def register_Ns3PacketSocketAddress_methods(root_module, cls):
   389     ## packet-socket-address.h: ns3::PacketSocketAddress::PacketSocketAddress() [constructor]
   564     ## packet-socket-address.h: ns3::PacketSocketAddress::PacketSocketAddress() [constructor]
   390     cls.add_constructor([], visibility='public')
   565     cls.add_constructor([])
   391     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetProtocol(uint16_t protocol) [member function]
   566     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetProtocol(uint16_t protocol) [member function]
   392     cls.add_method('SetProtocol', 'void', [param('uint16_t', 'protocol')])
   567     cls.add_method('SetProtocol', 
       
   568                    'void', 
       
   569                    [param('uint16_t', 'protocol')])
   393     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetAllDevices() [member function]
   570     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetAllDevices() [member function]
   394     cls.add_method('SetAllDevices', 'void', [])
   571     cls.add_method('SetAllDevices', 
       
   572                    'void', 
       
   573                    [])
   395     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetSingleDevice(uint32_t device) [member function]
   574     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetSingleDevice(uint32_t device) [member function]
   396     cls.add_method('SetSingleDevice', 'void', [param('uint32_t', 'device')])
   575     cls.add_method('SetSingleDevice', 
       
   576                    'void', 
       
   577                    [param('uint32_t', 'device')])
   397     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetPhysicalAddress(ns3::Address const address) [member function]
   578     ## packet-socket-address.h: void ns3::PacketSocketAddress::SetPhysicalAddress(ns3::Address const address) [member function]
   398     cls.add_method('SetPhysicalAddress', 'void', [param('ns3::Address', 'address', is_const=True)])
   579     cls.add_method('SetPhysicalAddress', 
       
   580                    'void', 
       
   581                    [param('ns3::Address', 'address', is_const=True)])
   399     ## packet-socket-address.h: uint16_t ns3::PacketSocketAddress::GetProtocol() const [member function]
   582     ## packet-socket-address.h: uint16_t ns3::PacketSocketAddress::GetProtocol() const [member function]
   400     cls.add_method('GetProtocol', 'uint16_t', [], is_const=True)
   583     cls.add_method('GetProtocol', 
       
   584                    'uint16_t', 
       
   585                    [], 
       
   586                    is_const=True)
   401     ## packet-socket-address.h: uint32_t ns3::PacketSocketAddress::GetSingleDevice() const [member function]
   587     ## packet-socket-address.h: uint32_t ns3::PacketSocketAddress::GetSingleDevice() const [member function]
   402     cls.add_method('GetSingleDevice', 'uint32_t', [], is_const=True)
   588     cls.add_method('GetSingleDevice', 
       
   589                    'uint32_t', 
       
   590                    [], 
       
   591                    is_const=True)
   403     ## packet-socket-address.h: bool ns3::PacketSocketAddress::IsSingleDevice() const [member function]
   592     ## packet-socket-address.h: bool ns3::PacketSocketAddress::IsSingleDevice() const [member function]
   404     cls.add_method('IsSingleDevice', 'bool', [], is_const=True)
   593     cls.add_method('IsSingleDevice', 
       
   594                    'bool', 
       
   595                    [], 
       
   596                    is_const=True)
   405     ## packet-socket-address.h: ns3::Address ns3::PacketSocketAddress::GetPhysicalAddress() const [member function]
   597     ## packet-socket-address.h: ns3::Address ns3::PacketSocketAddress::GetPhysicalAddress() const [member function]
   406     cls.add_method('GetPhysicalAddress', 'ns3::Address', [], is_const=True)
   598     cls.add_method('GetPhysicalAddress', 
       
   599                    'ns3::Address', 
       
   600                    [], 
       
   601                    is_const=True)
   407     ## packet-socket-address.h: static ns3::PacketSocketAddress ns3::PacketSocketAddress::ConvertFrom(ns3::Address const & address) [member function]
   602     ## packet-socket-address.h: static ns3::PacketSocketAddress ns3::PacketSocketAddress::ConvertFrom(ns3::Address const & address) [member function]
   408     cls.add_method('ConvertFrom', 'ns3::PacketSocketAddress', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
   603     cls.add_method('ConvertFrom', 
       
   604                    'ns3::PacketSocketAddress', 
       
   605                    [param('ns3::Address&', 'address', is_const=True)], 
       
   606                    is_static=True)
   409     ## packet-socket-address.h: static bool ns3::PacketSocketAddress::IsMatchingType(ns3::Address const & address) [member function]
   607     ## packet-socket-address.h: static bool ns3::PacketSocketAddress::IsMatchingType(ns3::Address const & address) [member function]
   410     cls.add_method('IsMatchingType', 'bool', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
   608     cls.add_method('IsMatchingType', 
       
   609                    'bool', 
       
   610                    [param('ns3::Address&', 'address', is_const=True)], 
       
   611                    is_static=True)
   411     return
   612     return
   412 
   613 
   413 def register_Ns3Ipv4Mask_methods(root_module, cls):
   614 def register_Ns3Ipv4Mask_methods(root_module, cls):
   414     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [copy constructor]
   615     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [copy constructor]
   415     cls.add_constructor([param('ns3::Ipv4Mask&', 'arg0', is_const=True)], visibility='public')
   616     cls.add_constructor([param('ns3::Ipv4Mask&', 'arg0', is_const=True)])
   416     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask() [constructor]
   617     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask() [constructor]
   417     cls.add_constructor([], visibility='public')
   618     cls.add_constructor([])
   418     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(uint32_t mask) [constructor]
   619     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(uint32_t mask) [constructor]
   419     cls.add_constructor([param('uint32_t', 'mask')], visibility='public')
   620     cls.add_constructor([param('uint32_t', 'mask')])
   420     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(char const * mask) [constructor]
   621     ## ipv4-address.h: ns3::Ipv4Mask::Ipv4Mask(char const * mask) [constructor]
   421     cls.add_constructor([param('char *', 'mask', transfer_ownership=False, is_const=True)], visibility='public')
   622     cls.add_constructor([param('char *', 'mask', transfer_ownership=False, is_const=True)])
   422     ## ipv4-address.h: uint32_t ns3::Ipv4Mask::Get() const [member function]
   623     ## ipv4-address.h: uint32_t ns3::Ipv4Mask::Get() const [member function]
   423     cls.add_method('Get', 'uint32_t', [], is_const=True)
   624     cls.add_method('Get', 
       
   625                    'uint32_t', 
       
   626                    [], 
       
   627                    is_const=True)
   424     ## ipv4-address.h: uint32_t ns3::Ipv4Mask::GetInverse() const [member function]
   628     ## ipv4-address.h: uint32_t ns3::Ipv4Mask::GetInverse() const [member function]
   425     cls.add_method('GetInverse', 'uint32_t', [], is_const=True)
   629     cls.add_method('GetInverse', 
       
   630                    'uint32_t', 
       
   631                    [], 
       
   632                    is_const=True)
   426     ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetLoopback() [member function]
   633     ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetLoopback() [member function]
   427     cls.add_method('GetLoopback', 'ns3::Ipv4Mask', [], is_static=True)
   634     cls.add_method('GetLoopback', 
       
   635                    'ns3::Ipv4Mask', 
       
   636                    [], 
       
   637                    is_static=True)
   428     ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetZero() [member function]
   638     ## ipv4-address.h: static ns3::Ipv4Mask ns3::Ipv4Mask::GetZero() [member function]
   429     cls.add_method('GetZero', 'ns3::Ipv4Mask', [], is_static=True)
   639     cls.add_method('GetZero', 
       
   640                    'ns3::Ipv4Mask', 
       
   641                    [], 
       
   642                    is_static=True)
   430     ## ipv4-address.h: bool ns3::Ipv4Mask::IsEqual(ns3::Ipv4Mask other) const [member function]
   643     ## ipv4-address.h: bool ns3::Ipv4Mask::IsEqual(ns3::Ipv4Mask other) const [member function]
   431     cls.add_method('IsEqual', 'bool', [param('ns3::Ipv4Mask', 'other')], is_const=True)
   644     cls.add_method('IsEqual', 
       
   645                    'bool', 
       
   646                    [param('ns3::Ipv4Mask', 'other')], 
       
   647                    is_const=True)
   432     ## ipv4-address.h: bool ns3::Ipv4Mask::IsMatch(ns3::Ipv4Address a, ns3::Ipv4Address b) const [member function]
   648     ## ipv4-address.h: bool ns3::Ipv4Mask::IsMatch(ns3::Ipv4Address a, ns3::Ipv4Address b) const [member function]
   433     cls.add_method('IsMatch', 'bool', [param('ns3::Ipv4Address', 'a'), param('ns3::Ipv4Address', 'b')], is_const=True)
   649     cls.add_method('IsMatch', 
       
   650                    'bool', 
       
   651                    [param('ns3::Ipv4Address', 'a'), param('ns3::Ipv4Address', 'b')], 
       
   652                    is_const=True)
   434     ## ipv4-address.h: void ns3::Ipv4Mask::Print(std::ostream & os) const [member function]
   653     ## ipv4-address.h: void ns3::Ipv4Mask::Print(std::ostream & os) const [member function]
   435     cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True)
   654     cls.add_method('Print', 
       
   655                    'void', 
       
   656                    [param('std::ostream&', 'os')], 
       
   657                    is_const=True)
   436     ## ipv4-address.h: void ns3::Ipv4Mask::Set(uint32_t mask) [member function]
   658     ## ipv4-address.h: void ns3::Ipv4Mask::Set(uint32_t mask) [member function]
   437     cls.add_method('Set', 'void', [param('uint32_t', 'mask')])
   659     cls.add_method('Set', 
       
   660                    'void', 
       
   661                    [param('uint32_t', 'mask')])
   438     cls.add_output_stream_operator()
   662     cls.add_output_stream_operator()
   439     return
   663     return
   440 
   664 
   441 def register_Ns3Ipv4AddressValue_methods(root_module, cls):
   665 def register_Ns3Ipv4AddressValue_methods(root_module, cls):
   442     ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue() [constructor]
   666     ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue() [constructor]
   443     cls.add_constructor([], visibility='public')
   667     cls.add_constructor([])
   444     ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4Address const & value) [constructor]
   668     ## ipv4-address.h: ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4Address const & value) [constructor]
   445     cls.add_constructor([param('ns3::Ipv4Address&', 'value', is_const=True)], visibility='public')
   669     cls.add_constructor([param('ns3::Ipv4Address&', 'value', is_const=True)])
   446     ## ipv4-address.h: void ns3::Ipv4AddressValue::Set(ns3::Ipv4Address const & value) [member function]
   670     ## ipv4-address.h: void ns3::Ipv4AddressValue::Set(ns3::Ipv4Address const & value) [member function]
   447     cls.add_method('Set', 'void', [param('ns3::Ipv4Address&', 'value', is_const=True)])
   671     cls.add_method('Set', 
       
   672                    'void', 
       
   673                    [param('ns3::Ipv4Address&', 'value', is_const=True)])
   448     ## ipv4-address.h: ns3::Ipv4Address ns3::Ipv4AddressValue::Get() const [member function]
   674     ## ipv4-address.h: ns3::Ipv4Address ns3::Ipv4AddressValue::Get() const [member function]
   449     cls.add_method('Get', 'ns3::Ipv4Address', [], is_const=True)
   675     cls.add_method('Get', 
       
   676                    'ns3::Ipv4Address', 
       
   677                    [], 
       
   678                    is_const=True)
   450     ## ipv4-address.h: ns3::Ptr<ns3::AttributeValue> ns3::Ipv4AddressValue::Copy() const [member function]
   679     ## ipv4-address.h: ns3::Ptr<ns3::AttributeValue> ns3::Ipv4AddressValue::Copy() const [member function]
   451     cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
   680     cls.add_method('Copy', 
       
   681                    'ns3::Ptr< ns3::AttributeValue >', 
       
   682                    [], 
       
   683                    is_const=True, is_virtual=True)
   452     ## ipv4-address.h: std::string ns3::Ipv4AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
   684     ## ipv4-address.h: std::string ns3::Ipv4AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
   453     cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True)
   685     cls.add_method('SerializeToString', 
       
   686                    'std::string', 
       
   687                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
   688                    is_const=True, is_virtual=True)
   454     ## ipv4-address.h: bool ns3::Ipv4AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   689     ## ipv4-address.h: bool ns3::Ipv4AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   455     cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True)
   690     cls.add_method('DeserializeFromString', 
       
   691                    'bool', 
       
   692                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
   693                    is_virtual=True)
   456     return
   694     return
   457 
   695 
   458 def register_Ns3Ipv4RoutingProtocol_methods(root_module, cls):
   696 def register_Ns3Ipv4RoutingProtocol_methods(root_module, cls):
   459     ## ipv4.h: ns3::Ipv4RoutingProtocol::IF_INDEX_ANY [variable]
   697     ## ipv4.h: ns3::Ipv4RoutingProtocol::IF_INDEX_ANY [variable]
   460     cls.add_static_attribute('IF_INDEX_ANY', retval('uint32_t', is_const=True), is_const=True)
   698     cls.add_static_attribute('IF_INDEX_ANY', retval('uint32_t', is_const=True), is_const=True)
   461     ## 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]
   699     ## 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]
   462     cls.add_method('RequestRoute', 'bool', [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')], is_pure_virtual=True, is_virtual=True)
   700     cls.add_method('RequestRoute', 
       
   701                    'bool', 
       
   702                    [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')], 
       
   703                    is_pure_virtual=True, is_virtual=True)
   463     ## ipv4.h: bool ns3::Ipv4RoutingProtocol::RequestIfIndex(ns3::Ipv4Address destination, uint32_t & ifIndex) [member function]
   704     ## ipv4.h: bool ns3::Ipv4RoutingProtocol::RequestIfIndex(ns3::Ipv4Address destination, uint32_t & ifIndex) [member function]
   464     cls.add_method('RequestIfIndex', 'bool', [param('ns3::Ipv4Address', 'destination'), param('uint32_t&', 'ifIndex')], is_pure_virtual=True, is_virtual=True)
   705     cls.add_method('RequestIfIndex', 
       
   706                    'bool', 
       
   707                    [param('ns3::Ipv4Address', 'destination'), param('uint32_t&', 'ifIndex')], 
       
   708                    is_pure_virtual=True, is_virtual=True)
   465     cls.add_constructor([])
   709     cls.add_constructor([])
   466     return
   710     return
   467 
   711 
   468 def register_Ns3Mac48AddressValue_methods(root_module, cls):
   712 def register_Ns3Mac48AddressValue_methods(root_module, cls):
   469     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue() [constructor]
   713     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue() [constructor]
   470     cls.add_constructor([], visibility='public')
   714     cls.add_constructor([])
   471     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48Address const & value) [constructor]
   715     ## mac48-address.h: ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48Address const & value) [constructor]
   472     cls.add_constructor([param('ns3::Mac48Address&', 'value', is_const=True)], visibility='public')
   716     cls.add_constructor([param('ns3::Mac48Address&', 'value', is_const=True)])
   473     ## mac48-address.h: void ns3::Mac48AddressValue::Set(ns3::Mac48Address const & value) [member function]
   717     ## mac48-address.h: void ns3::Mac48AddressValue::Set(ns3::Mac48Address const & value) [member function]
   474     cls.add_method('Set', 'void', [param('ns3::Mac48Address&', 'value', is_const=True)])
   718     cls.add_method('Set', 
       
   719                    'void', 
       
   720                    [param('ns3::Mac48Address&', 'value', is_const=True)])
   475     ## mac48-address.h: ns3::Mac48Address ns3::Mac48AddressValue::Get() const [member function]
   721     ## mac48-address.h: ns3::Mac48Address ns3::Mac48AddressValue::Get() const [member function]
   476     cls.add_method('Get', 'ns3::Mac48Address', [], is_const=True)
   722     cls.add_method('Get', 
       
   723                    'ns3::Mac48Address', 
       
   724                    [], 
       
   725                    is_const=True)
   477     ## mac48-address.h: ns3::Ptr<ns3::AttributeValue> ns3::Mac48AddressValue::Copy() const [member function]
   726     ## mac48-address.h: ns3::Ptr<ns3::AttributeValue> ns3::Mac48AddressValue::Copy() const [member function]
   478     cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
   727     cls.add_method('Copy', 
       
   728                    'ns3::Ptr< ns3::AttributeValue >', 
       
   729                    [], 
       
   730                    is_const=True, is_virtual=True)
   479     ## mac48-address.h: std::string ns3::Mac48AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
   731     ## mac48-address.h: std::string ns3::Mac48AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
   480     cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True)
   732     cls.add_method('SerializeToString', 
       
   733                    'std::string', 
       
   734                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
   735                    is_const=True, is_virtual=True)
   481     ## mac48-address.h: bool ns3::Mac48AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   736     ## mac48-address.h: bool ns3::Mac48AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   482     cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True)
   737     cls.add_method('DeserializeFromString', 
       
   738                    'bool', 
       
   739                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
   740                    is_virtual=True)
   483     return
   741     return
   484 
   742 
   485 def register_Ns3Ipv4MaskValue_methods(root_module, cls):
   743 def register_Ns3Ipv4MaskValue_methods(root_module, cls):
   486     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue() [constructor]
   744     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue() [constructor]
   487     cls.add_constructor([], visibility='public')
   745     cls.add_constructor([])
   488     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4Mask const & value) [constructor]
   746     ## ipv4-address.h: ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4Mask const & value) [constructor]
   489     cls.add_constructor([param('ns3::Ipv4Mask&', 'value', is_const=True)], visibility='public')
   747     cls.add_constructor([param('ns3::Ipv4Mask&', 'value', is_const=True)])
   490     ## ipv4-address.h: void ns3::Ipv4MaskValue::Set(ns3::Ipv4Mask const & value) [member function]
   748     ## ipv4-address.h: void ns3::Ipv4MaskValue::Set(ns3::Ipv4Mask const & value) [member function]
   491     cls.add_method('Set', 'void', [param('ns3::Ipv4Mask&', 'value', is_const=True)])
   749     cls.add_method('Set', 
       
   750                    'void', 
       
   751                    [param('ns3::Ipv4Mask&', 'value', is_const=True)])
   492     ## ipv4-address.h: ns3::Ipv4Mask ns3::Ipv4MaskValue::Get() const [member function]
   752     ## ipv4-address.h: ns3::Ipv4Mask ns3::Ipv4MaskValue::Get() const [member function]
   493     cls.add_method('Get', 'ns3::Ipv4Mask', [], is_const=True)
   753     cls.add_method('Get', 
       
   754                    'ns3::Ipv4Mask', 
       
   755                    [], 
       
   756                    is_const=True)
   494     ## ipv4-address.h: ns3::Ptr<ns3::AttributeValue> ns3::Ipv4MaskValue::Copy() const [member function]
   757     ## ipv4-address.h: ns3::Ptr<ns3::AttributeValue> ns3::Ipv4MaskValue::Copy() const [member function]
   495     cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
   758     cls.add_method('Copy', 
       
   759                    'ns3::Ptr< ns3::AttributeValue >', 
       
   760                    [], 
       
   761                    is_const=True, is_virtual=True)
   496     ## ipv4-address.h: std::string ns3::Ipv4MaskValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
   762     ## ipv4-address.h: std::string ns3::Ipv4MaskValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
   497     cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True)
   763     cls.add_method('SerializeToString', 
       
   764                    'std::string', 
       
   765                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
   766                    is_const=True, is_virtual=True)
   498     ## ipv4-address.h: bool ns3::Ipv4MaskValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   767     ## ipv4-address.h: bool ns3::Ipv4MaskValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   499     cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True)
   768     cls.add_method('DeserializeFromString', 
       
   769                    'bool', 
       
   770                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
   771                    is_virtual=True)
   500     return
   772     return
   501 
   773 
   502 def register_Ns3SocketAddressTag_methods(root_module, cls):
   774 def register_Ns3SocketAddressTag_methods(root_module, cls):
   503     ## socket.h: ns3::SocketAddressTag::SocketAddressTag() [constructor]
   775     ## socket.h: ns3::SocketAddressTag::SocketAddressTag() [constructor]
   504     cls.add_constructor([], visibility='public')
   776     cls.add_constructor([])
   505     ## socket.h: void ns3::SocketAddressTag::SetAddress(ns3::Address addr) [member function]
   777     ## socket.h: void ns3::SocketAddressTag::SetAddress(ns3::Address addr) [member function]
   506     cls.add_method('SetAddress', 'void', [param('ns3::Address', 'addr')])
   778     cls.add_method('SetAddress', 
       
   779                    'void', 
       
   780                    [param('ns3::Address', 'addr')])
   507     ## socket.h: ns3::Address ns3::SocketAddressTag::GetAddress() const [member function]
   781     ## socket.h: ns3::Address ns3::SocketAddressTag::GetAddress() const [member function]
   508     cls.add_method('GetAddress', 'ns3::Address', [], is_const=True)
   782     cls.add_method('GetAddress', 
       
   783                    'ns3::Address', 
       
   784                    [], 
       
   785                    is_const=True)
   509     ## socket.h: static ns3::TypeId ns3::SocketAddressTag::GetTypeId() [member function]
   786     ## socket.h: static ns3::TypeId ns3::SocketAddressTag::GetTypeId() [member function]
   510     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
   787     cls.add_method('GetTypeId', 
       
   788                    'ns3::TypeId', 
       
   789                    [], 
       
   790                    is_static=True)
   511     ## socket.h: ns3::TypeId ns3::SocketAddressTag::GetInstanceTypeId() const [member function]
   791     ## socket.h: ns3::TypeId ns3::SocketAddressTag::GetInstanceTypeId() const [member function]
   512     cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True)
   792     cls.add_method('GetInstanceTypeId', 
       
   793                    'ns3::TypeId', 
       
   794                    [], 
       
   795                    is_const=True, is_virtual=True)
   513     ## socket.h: uint32_t ns3::SocketAddressTag::GetSerializedSize() const [member function]
   796     ## socket.h: uint32_t ns3::SocketAddressTag::GetSerializedSize() const [member function]
   514     cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True, is_virtual=True)
   797     cls.add_method('GetSerializedSize', 
       
   798                    'uint32_t', 
       
   799                    [], 
       
   800                    is_const=True, is_virtual=True)
   515     ## socket.h: void ns3::SocketAddressTag::Serialize(ns3::TagBuffer i) const [member function]
   801     ## socket.h: void ns3::SocketAddressTag::Serialize(ns3::TagBuffer i) const [member function]
   516     cls.add_method('Serialize', 'void', [param('ns3::TagBuffer', 'i')], is_const=True, is_virtual=True)
   802     cls.add_method('Serialize', 
       
   803                    'void', 
       
   804                    [param('ns3::TagBuffer', 'i')], 
       
   805                    is_const=True, is_virtual=True)
   517     ## socket.h: void ns3::SocketAddressTag::Deserialize(ns3::TagBuffer i) [member function]
   806     ## socket.h: void ns3::SocketAddressTag::Deserialize(ns3::TagBuffer i) [member function]
   518     cls.add_method('Deserialize', 'void', [param('ns3::TagBuffer', 'i')], is_virtual=True)
   807     cls.add_method('Deserialize', 
       
   808                    'void', 
       
   809                    [param('ns3::TagBuffer', 'i')], 
       
   810                    is_virtual=True)
   519     ## socket.h: void ns3::SocketAddressTag::Print(std::ostream & os) const [member function]
   811     ## socket.h: void ns3::SocketAddressTag::Print(std::ostream & os) const [member function]
   520     cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True, is_virtual=True)
   812     cls.add_method('Print', 
       
   813                    'void', 
       
   814                    [param('std::ostream&', 'os')], 
       
   815                    is_const=True, is_virtual=True)
   521     return
   816     return
   522 
   817 
   523 def register_Ns3InetSocketAddress_methods(root_module, cls):
   818 def register_Ns3InetSocketAddress_methods(root_module, cls):
   524     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(ns3::Ipv4Address ipv4, uint16_t port) [constructor]
   819     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(ns3::Ipv4Address ipv4, uint16_t port) [constructor]
   525     cls.add_constructor([param('ns3::Ipv4Address', 'ipv4'), param('uint16_t', 'port')], visibility='public')
   820     cls.add_constructor([param('ns3::Ipv4Address', 'ipv4'), param('uint16_t', 'port')])
   526     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(ns3::Ipv4Address ipv4) [constructor]
   821     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(ns3::Ipv4Address ipv4) [constructor]
   527     cls.add_constructor([param('ns3::Ipv4Address', 'ipv4')], visibility='public')
   822     cls.add_constructor([param('ns3::Ipv4Address', 'ipv4')])
   528     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(uint16_t port) [constructor]
   823     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(uint16_t port) [constructor]
   529     cls.add_constructor([param('uint16_t', 'port')], visibility='public')
   824     cls.add_constructor([param('uint16_t', 'port')])
   530     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(char const * ipv4, uint16_t port) [constructor]
   825     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(char const * ipv4, uint16_t port) [constructor]
   531     cls.add_constructor([param('char *', 'ipv4', transfer_ownership=False, is_const=True), param('uint16_t', 'port')], visibility='public')
   826     cls.add_constructor([param('char *', 'ipv4', transfer_ownership=False, is_const=True), param('uint16_t', 'port')])
   532     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(char const * ipv4) [constructor]
   827     ## inet-socket-address.h: ns3::InetSocketAddress::InetSocketAddress(char const * ipv4) [constructor]
   533     cls.add_constructor([param('char *', 'ipv4', transfer_ownership=False, is_const=True)], visibility='public')
   828     cls.add_constructor([param('char *', 'ipv4', transfer_ownership=False, is_const=True)])
   534     ## inet-socket-address.h: uint16_t ns3::InetSocketAddress::GetPort() const [member function]
   829     ## inet-socket-address.h: uint16_t ns3::InetSocketAddress::GetPort() const [member function]
   535     cls.add_method('GetPort', 'uint16_t', [], is_const=True)
   830     cls.add_method('GetPort', 
       
   831                    'uint16_t', 
       
   832                    [], 
       
   833                    is_const=True)
   536     ## inet-socket-address.h: ns3::Ipv4Address ns3::InetSocketAddress::GetIpv4() const [member function]
   834     ## inet-socket-address.h: ns3::Ipv4Address ns3::InetSocketAddress::GetIpv4() const [member function]
   537     cls.add_method('GetIpv4', 'ns3::Ipv4Address', [], is_const=True)
   835     cls.add_method('GetIpv4', 
       
   836                    'ns3::Ipv4Address', 
       
   837                    [], 
       
   838                    is_const=True)
   538     ## inet-socket-address.h: void ns3::InetSocketAddress::SetPort(uint16_t port) [member function]
   839     ## inet-socket-address.h: void ns3::InetSocketAddress::SetPort(uint16_t port) [member function]
   539     cls.add_method('SetPort', 'void', [param('uint16_t', 'port')])
   840     cls.add_method('SetPort', 
       
   841                    'void', 
       
   842                    [param('uint16_t', 'port')])
   540     ## inet-socket-address.h: void ns3::InetSocketAddress::SetIpv4(ns3::Ipv4Address address) [member function]
   843     ## inet-socket-address.h: void ns3::InetSocketAddress::SetIpv4(ns3::Ipv4Address address) [member function]
   541     cls.add_method('SetIpv4', 'void', [param('ns3::Ipv4Address', 'address')])
   844     cls.add_method('SetIpv4', 
       
   845                    'void', 
       
   846                    [param('ns3::Ipv4Address', 'address')])
   542     ## inet-socket-address.h: static bool ns3::InetSocketAddress::IsMatchingType(ns3::Address const & address) [member function]
   847     ## inet-socket-address.h: static bool ns3::InetSocketAddress::IsMatchingType(ns3::Address const & address) [member function]
   543     cls.add_method('IsMatchingType', 'bool', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
   848     cls.add_method('IsMatchingType', 
       
   849                    'bool', 
       
   850                    [param('ns3::Address&', 'address', is_const=True)], 
       
   851                    is_static=True)
   544     ## inet-socket-address.h: static ns3::InetSocketAddress ns3::InetSocketAddress::ConvertFrom(ns3::Address const & address) [member function]
   852     ## inet-socket-address.h: static ns3::InetSocketAddress ns3::InetSocketAddress::ConvertFrom(ns3::Address const & address) [member function]
   545     cls.add_method('ConvertFrom', 'ns3::InetSocketAddress', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
   853     cls.add_method('ConvertFrom', 
       
   854                    'ns3::InetSocketAddress', 
       
   855                    [param('ns3::Address&', 'address', is_const=True)], 
       
   856                    is_static=True)
   546     return
   857     return
   547 
   858 
   548 def register_Ns3Ipv4Address_methods(root_module, cls):
   859 def register_Ns3Ipv4Address_methods(root_module, cls):
   549     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [copy constructor]
   860     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [copy constructor]
   550     cls.add_constructor([param('ns3::Ipv4Address&', 'arg0', is_const=True)], visibility='public')
   861     cls.add_constructor([param('ns3::Ipv4Address&', 'arg0', is_const=True)])
   551     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address() [constructor]
   862     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address() [constructor]
   552     cls.add_constructor([], visibility='public')
   863     cls.add_constructor([])
   553     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(uint32_t address) [constructor]
   864     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(uint32_t address) [constructor]
   554     cls.add_constructor([param('uint32_t', 'address')], visibility='public')
   865     cls.add_constructor([param('uint32_t', 'address')])
   555     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(char const * address) [constructor]
   866     ## ipv4-address.h: ns3::Ipv4Address::Ipv4Address(char const * address) [constructor]
   556     cls.add_constructor([param('char *', 'address', transfer_ownership=False, is_const=True)], visibility='public')
   867     cls.add_constructor([param('char *', 'address', transfer_ownership=False, is_const=True)])
   557     ## ipv4-address.h: ns3::Ipv4Address ns3::Ipv4Address::CombineMask(ns3::Ipv4Mask const & mask) const [member function]
   868     ## ipv4-address.h: ns3::Ipv4Address ns3::Ipv4Address::CombineMask(ns3::Ipv4Mask const & mask) const [member function]
   558     cls.add_method('CombineMask', 'ns3::Ipv4Address', [param('ns3::Ipv4Mask&', 'mask', is_const=True)], is_const=True)
   869     cls.add_method('CombineMask', 
       
   870                    'ns3::Ipv4Address', 
       
   871                    [param('ns3::Ipv4Mask&', 'mask', is_const=True)], 
       
   872                    is_const=True)
   559     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::ConvertFrom(ns3::Address const & address) [member function]
   873     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::ConvertFrom(ns3::Address const & address) [member function]
   560     cls.add_method('ConvertFrom', 'ns3::Ipv4Address', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
   874     cls.add_method('ConvertFrom', 
       
   875                    'ns3::Ipv4Address', 
       
   876                    [param('ns3::Address&', 'address', is_const=True)], 
       
   877                    is_static=True)
   561     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::Deserialize(uint8_t const * buf) [member function]
   878     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::Deserialize(uint8_t const * buf) [member function]
   562     cls.add_method('Deserialize', 'ns3::Ipv4Address', [param('uint8_t *', 'buf', transfer_ownership=False, is_const=True)], is_static=True)
   879     cls.add_method('Deserialize', 
       
   880                    'ns3::Ipv4Address', 
       
   881                    [param('uint8_t *', 'buf', transfer_ownership=False, is_const=True)], 
       
   882                    is_static=True)
   563     ## ipv4-address.h: uint32_t ns3::Ipv4Address::Get() const [member function]
   883     ## ipv4-address.h: uint32_t ns3::Ipv4Address::Get() const [member function]
   564     cls.add_method('Get', 'uint32_t', [], is_const=True)
   884     cls.add_method('Get', 
       
   885                    'uint32_t', 
       
   886                    [], 
       
   887                    is_const=True)
   565     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetAny() [member function]
   888     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetAny() [member function]
   566     cls.add_method('GetAny', 'ns3::Ipv4Address', [], is_static=True)
   889     cls.add_method('GetAny', 
       
   890                    'ns3::Ipv4Address', 
       
   891                    [], 
       
   892                    is_static=True)
   567     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetBroadcast() [member function]
   893     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetBroadcast() [member function]
   568     cls.add_method('GetBroadcast', 'ns3::Ipv4Address', [], is_static=True)
   894     cls.add_method('GetBroadcast', 
       
   895                    'ns3::Ipv4Address', 
       
   896                    [], 
       
   897                    is_static=True)
   569     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetLoopback() [member function]
   898     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetLoopback() [member function]
   570     cls.add_method('GetLoopback', 'ns3::Ipv4Address', [], is_static=True)
   899     cls.add_method('GetLoopback', 
       
   900                    'ns3::Ipv4Address', 
       
   901                    [], 
       
   902                    is_static=True)
   571     ## ipv4-address.h: ns3::Ipv4Address ns3::Ipv4Address::GetSubnetDirectedBroadcast(ns3::Ipv4Mask const & mask) const [member function]
   903     ## ipv4-address.h: ns3::Ipv4Address ns3::Ipv4Address::GetSubnetDirectedBroadcast(ns3::Ipv4Mask const & mask) const [member function]
   572     cls.add_method('GetSubnetDirectedBroadcast', 'ns3::Ipv4Address', [param('ns3::Ipv4Mask&', 'mask', is_const=True)], is_const=True)
   904     cls.add_method('GetSubnetDirectedBroadcast', 
       
   905                    'ns3::Ipv4Address', 
       
   906                    [param('ns3::Ipv4Mask&', 'mask', is_const=True)], 
       
   907                    is_const=True)
   573     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetZero() [member function]
   908     ## ipv4-address.h: static ns3::Ipv4Address ns3::Ipv4Address::GetZero() [member function]
   574     cls.add_method('GetZero', 'ns3::Ipv4Address', [], is_static=True)
   909     cls.add_method('GetZero', 
       
   910                    'ns3::Ipv4Address', 
       
   911                    [], 
       
   912                    is_static=True)
   575     ## ipv4-address.h: bool ns3::Ipv4Address::IsBroadcast() const [member function]
   913     ## ipv4-address.h: bool ns3::Ipv4Address::IsBroadcast() const [member function]
   576     cls.add_method('IsBroadcast', 'bool', [], is_const=True)
   914     cls.add_method('IsBroadcast', 
       
   915                    'bool', 
       
   916                    [], 
       
   917                    is_const=True)
   577     ## ipv4-address.h: bool ns3::Ipv4Address::IsEqual(ns3::Ipv4Address const & other) const [member function]
   918     ## ipv4-address.h: bool ns3::Ipv4Address::IsEqual(ns3::Ipv4Address const & other) const [member function]
   578     cls.add_method('IsEqual', 'bool', [param('ns3::Ipv4Address&', 'other', is_const=True)], is_const=True)
   919     cls.add_method('IsEqual', 
       
   920                    'bool', 
       
   921                    [param('ns3::Ipv4Address&', 'other', is_const=True)], 
       
   922                    is_const=True)
   579     ## ipv4-address.h: static bool ns3::Ipv4Address::IsMatchingType(ns3::Address const & address) [member function]
   923     ## ipv4-address.h: static bool ns3::Ipv4Address::IsMatchingType(ns3::Address const & address) [member function]
   580     cls.add_method('IsMatchingType', 'bool', [param('ns3::Address&', 'address', is_const=True)], is_static=True)
   924     cls.add_method('IsMatchingType', 
       
   925                    'bool', 
       
   926                    [param('ns3::Address&', 'address', is_const=True)], 
       
   927                    is_static=True)
   581     ## ipv4-address.h: bool ns3::Ipv4Address::IsMulticast() const [member function]
   928     ## ipv4-address.h: bool ns3::Ipv4Address::IsMulticast() const [member function]
   582     cls.add_method('IsMulticast', 'bool', [], is_const=True)
   929     cls.add_method('IsMulticast', 
       
   930                    'bool', 
       
   931                    [], 
       
   932                    is_const=True)
   583     ## ipv4-address.h: bool ns3::Ipv4Address::IsSubnetDirectedBroadcast(ns3::Ipv4Mask const & mask) const [member function]
   933     ## ipv4-address.h: bool ns3::Ipv4Address::IsSubnetDirectedBroadcast(ns3::Ipv4Mask const & mask) const [member function]
   584     cls.add_method('IsSubnetDirectedBroadcast', 'bool', [param('ns3::Ipv4Mask&', 'mask', is_const=True)], is_const=True)
   934     cls.add_method('IsSubnetDirectedBroadcast', 
       
   935                    'bool', 
       
   936                    [param('ns3::Ipv4Mask&', 'mask', is_const=True)], 
       
   937                    is_const=True)
   585     ## ipv4-address.h: void ns3::Ipv4Address::Print(std::ostream & os) const [member function]
   938     ## ipv4-address.h: void ns3::Ipv4Address::Print(std::ostream & os) const [member function]
   586     cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True)
   939     cls.add_method('Print', 
       
   940                    'void', 
       
   941                    [param('std::ostream&', 'os')], 
       
   942                    is_const=True)
   587     ## ipv4-address.h: void ns3::Ipv4Address::Serialize(uint8_t * buf) const [member function]
   943     ## ipv4-address.h: void ns3::Ipv4Address::Serialize(uint8_t * buf) const [member function]
   588     cls.add_method('Serialize', 'void', [param('uint8_t *', 'buf')], is_const=True)
   944     cls.add_method('Serialize', 
       
   945                    'void', 
       
   946                    [param('uint8_t *', 'buf')], 
       
   947                    is_const=True)
   589     ## ipv4-address.h: void ns3::Ipv4Address::Set(uint32_t address) [member function]
   948     ## ipv4-address.h: void ns3::Ipv4Address::Set(uint32_t address) [member function]
   590     cls.add_method('Set', 'void', [param('uint32_t', 'address')])
   949     cls.add_method('Set', 
       
   950                    'void', 
       
   951                    [param('uint32_t', 'address')])
   591     ## ipv4-address.h: void ns3::Ipv4Address::Set(char const * address) [member function]
   952     ## ipv4-address.h: void ns3::Ipv4Address::Set(char const * address) [member function]
   592     cls.add_method('Set', 'void', [param('char *', 'address', transfer_ownership=False, is_const=True)])
   953     cls.add_method('Set', 
       
   954                    'void', 
       
   955                    [param('char *', 'address', transfer_ownership=False, is_const=True)])
   593     cls.add_output_stream_operator()
   956     cls.add_output_stream_operator()
   594     return
   957     return
   595 
   958 
   596 def register_Ns3Application_methods(root_module, cls):
   959 def register_Ns3Application_methods(root_module, cls):
   597     ## application.h: static ns3::TypeId ns3::Application::GetTypeId() [member function]
   960     ## application.h: static ns3::TypeId ns3::Application::GetTypeId() [member function]
   598     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
   961     cls.add_method('GetTypeId', 
       
   962                    'ns3::TypeId', 
       
   963                    [], 
       
   964                    is_static=True)
   599     ## application.h: ns3::Application::Application() [constructor]
   965     ## application.h: ns3::Application::Application() [constructor]
   600     cls.add_constructor([], visibility='public')
   966     cls.add_constructor([])
   601     ## application.h: void ns3::Application::Start(ns3::Time const & startTime) [member function]
   967     ## application.h: void ns3::Application::Start(ns3::Time const & startTime) [member function]
   602     cls.add_method('Start', 'void', [param('ns3::Time&', 'startTime', is_const=True)])
   968     cls.add_method('Start', 
       
   969                    'void', 
       
   970                    [param('ns3::Time&', 'startTime', is_const=True)])
   603     ## application.h: void ns3::Application::Start(ns3::RandomVariable const & startVariable) [member function]
   971     ## application.h: void ns3::Application::Start(ns3::RandomVariable const & startVariable) [member function]
   604     cls.add_method('Start', 'void', [param('ns3::RandomVariable&', 'startVariable', is_const=True)])
   972     cls.add_method('Start', 
       
   973                    'void', 
       
   974                    [param('ns3::RandomVariable&', 'startVariable', is_const=True)])
   605     ## application.h: void ns3::Application::Stop(ns3::Time const & stopTime) [member function]
   975     ## application.h: void ns3::Application::Stop(ns3::Time const & stopTime) [member function]
   606     cls.add_method('Stop', 'void', [param('ns3::Time&', 'stopTime', is_const=True)])
   976     cls.add_method('Stop', 
       
   977                    'void', 
       
   978                    [param('ns3::Time&', 'stopTime', is_const=True)])
   607     ## application.h: void ns3::Application::Stop(ns3::RandomVariable const & stopVariable) [member function]
   979     ## application.h: void ns3::Application::Stop(ns3::RandomVariable const & stopVariable) [member function]
   608     cls.add_method('Stop', 'void', [param('ns3::RandomVariable&', 'stopVariable', is_const=True)])
   980     cls.add_method('Stop', 
       
   981                    'void', 
       
   982                    [param('ns3::RandomVariable&', 'stopVariable', is_const=True)])
   609     ## application.h: ns3::Ptr<ns3::Node> ns3::Application::GetNode() const [member function]
   983     ## application.h: ns3::Ptr<ns3::Node> ns3::Application::GetNode() const [member function]
   610     cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', [], is_const=True)
   984     cls.add_method('GetNode', 
       
   985                    'ns3::Ptr< ns3::Node >', 
       
   986                    [], 
       
   987                    is_const=True)
   611     ## application.h: void ns3::Application::SetNode(ns3::Ptr<ns3::Node> node) [member function]
   988     ## application.h: void ns3::Application::SetNode(ns3::Ptr<ns3::Node> node) [member function]
   612     cls.add_method('SetNode', 'void', [param('ns3::Ptr< ns3::Node >', 'node')])
   989     cls.add_method('SetNode', 
       
   990                    'void', 
       
   991                    [param('ns3::Ptr< ns3::Node >', 'node')])
   613     ## application.h: void ns3::Application::DoDispose() [member function]
   992     ## application.h: void ns3::Application::DoDispose() [member function]
   614     cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True)
   993     cls.add_method('DoDispose', 
       
   994                    'void', 
       
   995                    [], 
       
   996                    visibility='protected', is_virtual=True)
   615     ## application.h: void ns3::Application::StartApplication() [member function]
   997     ## application.h: void ns3::Application::StartApplication() [member function]
   616     cls.add_method('StartApplication', 'void', [], visibility='private', is_virtual=True)
   998     cls.add_method('StartApplication', 
       
   999                    'void', 
       
  1000                    [], 
       
  1001                    visibility='private', is_virtual=True)
   617     ## application.h: void ns3::Application::StopApplication() [member function]
  1002     ## application.h: void ns3::Application::StopApplication() [member function]
   618     cls.add_method('StopApplication', 'void', [], visibility='private', is_virtual=True)
  1003     cls.add_method('StopApplication', 
       
  1004                    'void', 
       
  1005                    [], 
       
  1006                    visibility='private', is_virtual=True)
   619     return
  1007     return
   620 
  1008 
   621 def register_Ns3Queue_methods(root_module, cls):
  1009 def register_Ns3Queue_methods(root_module, cls):
   622     ## queue.h: static ns3::TypeId ns3::Queue::GetTypeId() [member function]
  1010     ## queue.h: static ns3::TypeId ns3::Queue::GetTypeId() [member function]
   623     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
  1011     cls.add_method('GetTypeId', 
       
  1012                    'ns3::TypeId', 
       
  1013                    [], 
       
  1014                    is_static=True)
   624     ## queue.h: ns3::Queue::Queue() [constructor]
  1015     ## queue.h: ns3::Queue::Queue() [constructor]
   625     cls.add_constructor([], visibility='public')
  1016     cls.add_constructor([])
   626     ## queue.h: bool ns3::Queue::IsEmpty() const [member function]
  1017     ## queue.h: bool ns3::Queue::IsEmpty() const [member function]
   627     cls.add_method('IsEmpty', 'bool', [], is_const=True)
  1018     cls.add_method('IsEmpty', 
       
  1019                    'bool', 
       
  1020                    [], 
       
  1021                    is_const=True)
   628     ## queue.h: bool ns3::Queue::Enqueue(ns3::Ptr<ns3::Packet> p) [member function]
  1022     ## queue.h: bool ns3::Queue::Enqueue(ns3::Ptr<ns3::Packet> p) [member function]
   629     cls.add_method('Enqueue', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p')])
  1023     cls.add_method('Enqueue', 
       
  1024                    'bool', 
       
  1025                    [param('ns3::Ptr< ns3::Packet >', 'p')])
   630     ## queue.h: ns3::Ptr<ns3::Packet> ns3::Queue::Dequeue() [member function]
  1026     ## queue.h: ns3::Ptr<ns3::Packet> ns3::Queue::Dequeue() [member function]
   631     cls.add_method('Dequeue', 'ns3::Ptr< ns3::Packet >', [])
  1027     cls.add_method('Dequeue', 
       
  1028                    'ns3::Ptr< ns3::Packet >', 
       
  1029                    [])
   632     ## queue.h: ns3::Ptr<ns3::Packet> ns3::Queue::Peek() const [member function]
  1030     ## queue.h: ns3::Ptr<ns3::Packet> ns3::Queue::Peek() const [member function]
   633     cls.add_method('Peek', 'ns3::Ptr< ns3::Packet >', [], is_const=True)
  1031     cls.add_method('Peek', 
       
  1032                    'ns3::Ptr< ns3::Packet >', 
       
  1033                    [], 
       
  1034                    is_const=True)
   634     ## queue.h: void ns3::Queue::DequeueAll() [member function]
  1035     ## queue.h: void ns3::Queue::DequeueAll() [member function]
   635     cls.add_method('DequeueAll', 'void', [])
  1036     cls.add_method('DequeueAll', 
       
  1037                    'void', 
       
  1038                    [])
   636     ## queue.h: uint32_t ns3::Queue::GetNPackets() const [member function]
  1039     ## queue.h: uint32_t ns3::Queue::GetNPackets() const [member function]
   637     cls.add_method('GetNPackets', 'uint32_t', [], is_const=True)
  1040     cls.add_method('GetNPackets', 
       
  1041                    'uint32_t', 
       
  1042                    [], 
       
  1043                    is_const=True)
   638     ## queue.h: uint32_t ns3::Queue::GetNBytes() const [member function]
  1044     ## queue.h: uint32_t ns3::Queue::GetNBytes() const [member function]
   639     cls.add_method('GetNBytes', 'uint32_t', [], is_const=True)
  1045     cls.add_method('GetNBytes', 
       
  1046                    'uint32_t', 
       
  1047                    [], 
       
  1048                    is_const=True)
   640     ## queue.h: uint32_t ns3::Queue::GetTotalReceivedBytes() const [member function]
  1049     ## queue.h: uint32_t ns3::Queue::GetTotalReceivedBytes() const [member function]
   641     cls.add_method('GetTotalReceivedBytes', 'uint32_t', [], is_const=True)
  1050     cls.add_method('GetTotalReceivedBytes', 
       
  1051                    'uint32_t', 
       
  1052                    [], 
       
  1053                    is_const=True)
   642     ## queue.h: uint32_t ns3::Queue::GetTotalReceivedPackets() const [member function]
  1054     ## queue.h: uint32_t ns3::Queue::GetTotalReceivedPackets() const [member function]
   643     cls.add_method('GetTotalReceivedPackets', 'uint32_t', [], is_const=True)
  1055     cls.add_method('GetTotalReceivedPackets', 
       
  1056                    'uint32_t', 
       
  1057                    [], 
       
  1058                    is_const=True)
   644     ## queue.h: uint32_t ns3::Queue::GetTotalDroppedBytes() const [member function]
  1059     ## queue.h: uint32_t ns3::Queue::GetTotalDroppedBytes() const [member function]
   645     cls.add_method('GetTotalDroppedBytes', 'uint32_t', [], is_const=True)
  1060     cls.add_method('GetTotalDroppedBytes', 
       
  1061                    'uint32_t', 
       
  1062                    [], 
       
  1063                    is_const=True)
   646     ## queue.h: uint32_t ns3::Queue::GetTotalDroppedPackets() const [member function]
  1064     ## queue.h: uint32_t ns3::Queue::GetTotalDroppedPackets() const [member function]
   647     cls.add_method('GetTotalDroppedPackets', 'uint32_t', [], is_const=True)
  1065     cls.add_method('GetTotalDroppedPackets', 
       
  1066                    'uint32_t', 
       
  1067                    [], 
       
  1068                    is_const=True)
   648     ## queue.h: void ns3::Queue::ResetStatistics() [member function]
  1069     ## queue.h: void ns3::Queue::ResetStatistics() [member function]
   649     cls.add_method('ResetStatistics', 'void', [])
  1070     cls.add_method('ResetStatistics', 
       
  1071                    'void', 
       
  1072                    [])
   650     ## queue.h: void ns3::Queue::Drop(ns3::Ptr<ns3::Packet> packet) [member function]
  1073     ## queue.h: void ns3::Queue::Drop(ns3::Ptr<ns3::Packet> packet) [member function]
   651     cls.add_method('Drop', 'void', [param('ns3::Ptr< ns3::Packet >', 'packet')], visibility='protected')
  1074     cls.add_method('Drop', 
       
  1075                    'void', 
       
  1076                    [param('ns3::Ptr< ns3::Packet >', 'packet')], 
       
  1077                    visibility='protected')
   652     ## queue.h: bool ns3::Queue::DoEnqueue(ns3::Ptr<ns3::Packet> p) [member function]
  1078     ## queue.h: bool ns3::Queue::DoEnqueue(ns3::Ptr<ns3::Packet> p) [member function]
   653     cls.add_method('DoEnqueue', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p')], is_pure_virtual=True, visibility='private', is_virtual=True)
  1079     cls.add_method('DoEnqueue', 
       
  1080                    'bool', 
       
  1081                    [param('ns3::Ptr< ns3::Packet >', 'p')], 
       
  1082                    is_pure_virtual=True, visibility='private', is_virtual=True)
   654     ## queue.h: ns3::Ptr<ns3::Packet> ns3::Queue::DoDequeue() [member function]
  1083     ## queue.h: ns3::Ptr<ns3::Packet> ns3::Queue::DoDequeue() [member function]
   655     cls.add_method('DoDequeue', 'ns3::Ptr< ns3::Packet >', [], is_pure_virtual=True, visibility='private', is_virtual=True)
  1084     cls.add_method('DoDequeue', 
       
  1085                    'ns3::Ptr< ns3::Packet >', 
       
  1086                    [], 
       
  1087                    is_pure_virtual=True, visibility='private', is_virtual=True)
   656     ## queue.h: ns3::Ptr<ns3::Packet> ns3::Queue::DoPeek() const [member function]
  1088     ## queue.h: ns3::Ptr<ns3::Packet> ns3::Queue::DoPeek() const [member function]
   657     cls.add_method('DoPeek', 'ns3::Ptr< ns3::Packet >', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1089     cls.add_method('DoPeek', 
       
  1090                    'ns3::Ptr< ns3::Packet >', 
       
  1091                    [], 
       
  1092                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
   658     return
  1093     return
   659 
  1094 
   660 def register_Ns3Socket_methods(root_module, cls):
  1095 def register_Ns3Socket_methods(root_module, cls):
   661     ## socket.h: ns3::Socket::Socket() [constructor]
  1096     ## socket.h: ns3::Socket::Socket() [constructor]
   662     cls.add_constructor([], visibility='public')
  1097     cls.add_constructor([])
   663     ## socket.h: static ns3::Ptr<ns3::Socket> ns3::Socket::CreateSocket(ns3::Ptr<ns3::Node> node, ns3::TypeId tid) [member function]
  1098     ## socket.h: static ns3::Ptr<ns3::Socket> ns3::Socket::CreateSocket(ns3::Ptr<ns3::Node> node, ns3::TypeId tid) [member function]
   664     cls.add_method('CreateSocket', 'ns3::Ptr< ns3::Socket >', [param('ns3::Ptr< ns3::Node >', 'node'), param('ns3::TypeId', 'tid')], is_static=True)
  1099     cls.add_method('CreateSocket', 
       
  1100                    'ns3::Ptr< ns3::Socket >', 
       
  1101                    [param('ns3::Ptr< ns3::Node >', 'node'), param('ns3::TypeId', 'tid')], 
       
  1102                    is_static=True)
   665     ## socket.h: ns3::Socket::SocketErrno ns3::Socket::GetErrno() const [member function]
  1103     ## socket.h: ns3::Socket::SocketErrno ns3::Socket::GetErrno() const [member function]
   666     cls.add_method('GetErrno', 'ns3::Socket::SocketErrno', [], is_pure_virtual=True, is_const=True, is_virtual=True)
  1104     cls.add_method('GetErrno', 
       
  1105                    'ns3::Socket::SocketErrno', 
       
  1106                    [], 
       
  1107                    is_pure_virtual=True, is_const=True, is_virtual=True)
   667     ## socket.h: ns3::Ptr<ns3::Node> ns3::Socket::GetNode() const [member function]
  1108     ## socket.h: ns3::Ptr<ns3::Node> ns3::Socket::GetNode() const [member function]
   668     cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', [], is_pure_virtual=True, is_const=True, is_virtual=True)
  1109     cls.add_method('GetNode', 
       
  1110                    'ns3::Ptr< ns3::Node >', 
       
  1111                    [], 
       
  1112                    is_pure_virtual=True, is_const=True, is_virtual=True)
   669     ## socket.h: void ns3::Socket::SetConnectCallback(ns3::Callback<void, ns3::Ptr<ns3::Socket>, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> connectionSucceeded, ns3::Callback<void, ns3::Ptr<ns3::Socket>, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> connectionFailed) [member function]
  1113     ## socket.h: void ns3::Socket::SetConnectCallback(ns3::Callback<void, ns3::Ptr<ns3::Socket>, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> connectionSucceeded, ns3::Callback<void, ns3::Ptr<ns3::Socket>, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> connectionFailed) [member function]
   670     cls.add_method('SetConnectCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'connectionSucceeded'), param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'connectionFailed')])
  1114     cls.add_method('SetConnectCallback', 
       
  1115                    'void', 
       
  1116                    [param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'connectionSucceeded'), param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'connectionFailed')])
   671     ## socket.h: void ns3::Socket::SetAcceptCallback(ns3::Callback<bool, ns3::Ptr<ns3::Socket>, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty> connectionRequest, ns3::Callback<void, ns3::Ptr<ns3::Socket>, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty> newConnectionCreated) [member function]
  1117     ## socket.h: void ns3::Socket::SetAcceptCallback(ns3::Callback<bool, ns3::Ptr<ns3::Socket>, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty> connectionRequest, ns3::Callback<void, ns3::Ptr<ns3::Socket>, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty> newConnectionCreated) [member function]
   672     cls.add_method('SetAcceptCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::Socket >, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'connectionRequest'), param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'newConnectionCreated')])
  1118     cls.add_method('SetAcceptCallback', 
       
  1119                    'void', 
       
  1120                    [param('ns3::Callback< bool, ns3::Ptr< ns3::Socket >, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'connectionRequest'), param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'newConnectionCreated')])
   673     ## socket.h: bool ns3::Socket::SetDataSentCallback(ns3::Callback<void, ns3::Ptr<ns3::Socket>, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty> dataSent) [member function]
  1121     ## socket.h: bool ns3::Socket::SetDataSentCallback(ns3::Callback<void, ns3::Ptr<ns3::Socket>, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty> dataSent) [member function]
   674     cls.add_method('SetDataSentCallback', 'bool', [param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'dataSent')], is_virtual=True)
  1122     cls.add_method('SetDataSentCallback', 
       
  1123                    'bool', 
       
  1124                    [param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'dataSent')], 
       
  1125                    is_virtual=True)
   675     ## socket.h: void ns3::Socket::SetSendCallback(ns3::Callback<void, ns3::Ptr<ns3::Socket>, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty> sendCb) [member function]
  1126     ## socket.h: void ns3::Socket::SetSendCallback(ns3::Callback<void, ns3::Ptr<ns3::Socket>, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty> sendCb) [member function]
   676     cls.add_method('SetSendCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'sendCb')])
  1127     cls.add_method('SetSendCallback', 
       
  1128                    'void', 
       
  1129                    [param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'sendCb')])
   677     ## socket.h: void ns3::Socket::SetRecvCallback(ns3::Callback<void, ns3::Ptr<ns3::Socket>, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> arg0) [member function]
  1130     ## socket.h: void ns3::Socket::SetRecvCallback(ns3::Callback<void, ns3::Ptr<ns3::Socket>, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> arg0) [member function]
   678     cls.add_method('SetRecvCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'arg0')])
  1131     cls.add_method('SetRecvCallback', 
       
  1132                    'void', 
       
  1133                    [param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'arg0')])
   679     ## socket.h: int ns3::Socket::Bind(ns3::Address const & address) [member function]
  1134     ## socket.h: int ns3::Socket::Bind(ns3::Address const & address) [member function]
   680     cls.add_method('Bind', 'int', [param('ns3::Address&', 'address', is_const=True)], is_pure_virtual=True, is_virtual=True)
  1135     cls.add_method('Bind', 
       
  1136                    'int', 
       
  1137                    [param('ns3::Address&', 'address', is_const=True)], 
       
  1138                    is_pure_virtual=True, is_virtual=True)
   681     ## socket.h: int ns3::Socket::Bind() [member function]
  1139     ## socket.h: int ns3::Socket::Bind() [member function]
   682     cls.add_method('Bind', 'int', [], is_pure_virtual=True, is_virtual=True)
  1140     cls.add_method('Bind', 
       
  1141                    'int', 
       
  1142                    [], 
       
  1143                    is_pure_virtual=True, is_virtual=True)
   683     ## socket.h: int ns3::Socket::Close() [member function]
  1144     ## socket.h: int ns3::Socket::Close() [member function]
   684     cls.add_method('Close', 'int', [], is_pure_virtual=True, is_virtual=True)
  1145     cls.add_method('Close', 
       
  1146                    'int', 
       
  1147                    [], 
       
  1148                    is_pure_virtual=True, is_virtual=True)
   685     ## socket.h: int ns3::Socket::ShutdownSend() [member function]
  1149     ## socket.h: int ns3::Socket::ShutdownSend() [member function]
   686     cls.add_method('ShutdownSend', 'int', [], is_pure_virtual=True, is_virtual=True)
  1150     cls.add_method('ShutdownSend', 
       
  1151                    'int', 
       
  1152                    [], 
       
  1153                    is_pure_virtual=True, is_virtual=True)
   687     ## socket.h: int ns3::Socket::ShutdownRecv() [member function]
  1154     ## socket.h: int ns3::Socket::ShutdownRecv() [member function]
   688     cls.add_method('ShutdownRecv', 'int', [], is_pure_virtual=True, is_virtual=True)
  1155     cls.add_method('ShutdownRecv', 
       
  1156                    'int', 
       
  1157                    [], 
       
  1158                    is_pure_virtual=True, is_virtual=True)
   689     ## socket.h: int ns3::Socket::Connect(ns3::Address const & address) [member function]
  1159     ## socket.h: int ns3::Socket::Connect(ns3::Address const & address) [member function]
   690     cls.add_method('Connect', 'int', [param('ns3::Address&', 'address', is_const=True)], is_pure_virtual=True, is_virtual=True)
  1160     cls.add_method('Connect', 
       
  1161                    'int', 
       
  1162                    [param('ns3::Address&', 'address', is_const=True)], 
       
  1163                    is_pure_virtual=True, is_virtual=True)
   691     ## socket.h: int ns3::Socket::Listen(uint32_t queueLimit) [member function]
  1164     ## socket.h: int ns3::Socket::Listen(uint32_t queueLimit) [member function]
   692     cls.add_method('Listen', 'int', [param('uint32_t', 'queueLimit')], is_pure_virtual=True, is_virtual=True)
  1165     cls.add_method('Listen', 
       
  1166                    'int', 
       
  1167                    [param('uint32_t', 'queueLimit')], 
       
  1168                    is_pure_virtual=True, is_virtual=True)
   693     ## socket.h: uint32_t ns3::Socket::GetTxAvailable() const [member function]
  1169     ## socket.h: uint32_t ns3::Socket::GetTxAvailable() const [member function]
   694     cls.add_method('GetTxAvailable', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True)
  1170     cls.add_method('GetTxAvailable', 
       
  1171                    'uint32_t', 
       
  1172                    [], 
       
  1173                    is_pure_virtual=True, is_const=True, is_virtual=True)
   695     ## socket.h: int ns3::Socket::Send(ns3::Ptr<ns3::Packet> p, uint32_t flags) [member function]
  1174     ## socket.h: int ns3::Socket::Send(ns3::Ptr<ns3::Packet> p, uint32_t flags) [member function]
   696     cls.add_method('Send', 'int', [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'flags')], is_pure_virtual=True, is_virtual=True)
  1175     cls.add_method('Send', 
       
  1176                    'int', 
       
  1177                    [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'flags')], 
       
  1178                    is_pure_virtual=True, is_virtual=True)
   697     ## socket.h: int ns3::Socket::SendTo(ns3::Ptr<ns3::Packet> p, uint32_t flags, ns3::Address const & toAddress) [member function]
  1179     ## socket.h: int ns3::Socket::SendTo(ns3::Ptr<ns3::Packet> p, uint32_t flags, ns3::Address const & toAddress) [member function]
   698     cls.add_method('SendTo', 'int', [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'flags'), param('ns3::Address&', 'toAddress', is_const=True)], is_pure_virtual=True, is_virtual=True)
  1180     cls.add_method('SendTo', 
       
  1181                    'int', 
       
  1182                    [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'flags'), param('ns3::Address&', 'toAddress', is_const=True)], 
       
  1183                    is_pure_virtual=True, is_virtual=True)
   699     ## socket.h: uint32_t ns3::Socket::GetRxAvailable() const [member function]
  1184     ## socket.h: uint32_t ns3::Socket::GetRxAvailable() const [member function]
   700     cls.add_method('GetRxAvailable', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True)
  1185     cls.add_method('GetRxAvailable', 
       
  1186                    'uint32_t', 
       
  1187                    [], 
       
  1188                    is_pure_virtual=True, is_const=True, is_virtual=True)
   701     ## socket.h: ns3::Ptr<ns3::Packet> ns3::Socket::Recv(uint32_t maxSize, uint32_t flags) [member function]
  1189     ## socket.h: ns3::Ptr<ns3::Packet> ns3::Socket::Recv(uint32_t maxSize, uint32_t flags) [member function]
   702     cls.add_method('Recv', 'ns3::Ptr< ns3::Packet >', [param('uint32_t', 'maxSize'), param('uint32_t', 'flags')], is_pure_virtual=True, is_virtual=True)
  1190     cls.add_method('Recv', 
       
  1191                    'ns3::Ptr< ns3::Packet >', 
       
  1192                    [param('uint32_t', 'maxSize'), param('uint32_t', 'flags')], 
       
  1193                    is_pure_virtual=True, is_virtual=True)
   703     ## socket.h: ns3::Ptr<ns3::Packet> ns3::Socket::RecvFrom(uint32_t maxSize, uint32_t flags, ns3::Address & fromAddress) [member function]
  1194     ## socket.h: ns3::Ptr<ns3::Packet> ns3::Socket::RecvFrom(uint32_t maxSize, uint32_t flags, ns3::Address & fromAddress) [member function]
   704     cls.add_method('RecvFrom', 'ns3::Ptr< ns3::Packet >', [param('uint32_t', 'maxSize'), param('uint32_t', 'flags'), param('ns3::Address&', 'fromAddress')], is_pure_virtual=True, is_virtual=True)
  1195     cls.add_method('RecvFrom', 
       
  1196                    'ns3::Ptr< ns3::Packet >', 
       
  1197                    [param('uint32_t', 'maxSize'), param('uint32_t', 'flags'), param('ns3::Address&', 'fromAddress')], 
       
  1198                    is_pure_virtual=True, is_virtual=True)
   705     ## socket.h: int ns3::Socket::Send(ns3::Ptr<ns3::Packet> p) [member function]
  1199     ## socket.h: int ns3::Socket::Send(ns3::Ptr<ns3::Packet> p) [member function]
   706     cls.add_method('Send', 'int', [param('ns3::Ptr< ns3::Packet >', 'p')])
  1200     cls.add_method('Send', 
       
  1201                    'int', 
       
  1202                    [param('ns3::Ptr< ns3::Packet >', 'p')])
   707     ## socket.h: int ns3::Socket::Send(uint8_t const * buf, uint32_t size, uint32_t flags) [member function]
  1203     ## socket.h: int ns3::Socket::Send(uint8_t const * buf, uint32_t size, uint32_t flags) [member function]
   708     cls.add_method('Send', 'int', [param('uint8_t *', 'buf', transfer_ownership=False, is_const=True), param('uint32_t', 'size'), param('uint32_t', 'flags')])
  1204     cls.add_method('Send', 
       
  1205                    'int', 
       
  1206                    [param('uint8_t *', 'buf', transfer_ownership=False, is_const=True), param('uint32_t', 'size'), param('uint32_t', 'flags')])
   709     ## socket.h: int ns3::Socket::SendTo(uint8_t const * buf, uint32_t size, uint32_t flags, ns3::Address const & address) [member function]
  1207     ## socket.h: int ns3::Socket::SendTo(uint8_t const * buf, uint32_t size, uint32_t flags, ns3::Address const & address) [member function]
   710     cls.add_method('SendTo', 'int', [param('uint8_t *', 'buf', transfer_ownership=False, is_const=True), param('uint32_t', 'size'), param('uint32_t', 'flags'), param('ns3::Address&', 'address', is_const=True)])
  1208     cls.add_method('SendTo', 
       
  1209                    'int', 
       
  1210                    [param('uint8_t *', 'buf', transfer_ownership=False, is_const=True), param('uint32_t', 'size'), param('uint32_t', 'flags'), param('ns3::Address&', 'address', is_const=True)])
   711     ## socket.h: ns3::Ptr<ns3::Packet> ns3::Socket::Recv() [member function]
  1211     ## socket.h: ns3::Ptr<ns3::Packet> ns3::Socket::Recv() [member function]
   712     cls.add_method('Recv', 'ns3::Ptr< ns3::Packet >', [])
  1212     cls.add_method('Recv', 
       
  1213                    'ns3::Ptr< ns3::Packet >', 
       
  1214                    [])
   713     ## socket.h: int ns3::Socket::Recv(uint8_t * buf, uint32_t size, uint32_t flags) [member function]
  1215     ## socket.h: int ns3::Socket::Recv(uint8_t * buf, uint32_t size, uint32_t flags) [member function]
   714     cls.add_method('Recv', 'int', [param('uint8_t *', 'buf'), param('uint32_t', 'size'), param('uint32_t', 'flags')])
  1216     cls.add_method('Recv', 
       
  1217                    'int', 
       
  1218                    [param('uint8_t *', 'buf'), param('uint32_t', 'size'), param('uint32_t', 'flags')])
   715     ## socket.h: ns3::Ptr<ns3::Packet> ns3::Socket::RecvFrom(ns3::Address & fromAddress) [member function]
  1219     ## socket.h: ns3::Ptr<ns3::Packet> ns3::Socket::RecvFrom(ns3::Address & fromAddress) [member function]
   716     cls.add_method('RecvFrom', 'ns3::Ptr< ns3::Packet >', [param('ns3::Address&', 'fromAddress')])
  1220     cls.add_method('RecvFrom', 
       
  1221                    'ns3::Ptr< ns3::Packet >', 
       
  1222                    [param('ns3::Address&', 'fromAddress')])
   717     ## socket.h: int ns3::Socket::RecvFrom(uint8_t * buf, uint32_t size, uint32_t flags, ns3::Address & fromAddress) [member function]
  1223     ## socket.h: int ns3::Socket::RecvFrom(uint8_t * buf, uint32_t size, uint32_t flags, ns3::Address & fromAddress) [member function]
   718     cls.add_method('RecvFrom', 'int', [param('uint8_t *', 'buf'), param('uint32_t', 'size'), param('uint32_t', 'flags'), param('ns3::Address&', 'fromAddress')])
  1224     cls.add_method('RecvFrom', 
       
  1225                    'int', 
       
  1226                    [param('uint8_t *', 'buf'), param('uint32_t', 'size'), param('uint32_t', 'flags'), param('ns3::Address&', 'fromAddress')])
   719     ## socket.h: void ns3::Socket::NotifyConnectionSucceeded() [member function]
  1227     ## socket.h: void ns3::Socket::NotifyConnectionSucceeded() [member function]
   720     cls.add_method('NotifyConnectionSucceeded', 'void', [], visibility='protected')
  1228     cls.add_method('NotifyConnectionSucceeded', 
       
  1229                    'void', 
       
  1230                    [], 
       
  1231                    visibility='protected')
   721     ## socket.h: void ns3::Socket::NotifyConnectionFailed() [member function]
  1232     ## socket.h: void ns3::Socket::NotifyConnectionFailed() [member function]
   722     cls.add_method('NotifyConnectionFailed', 'void', [], visibility='protected')
  1233     cls.add_method('NotifyConnectionFailed', 
       
  1234                    'void', 
       
  1235                    [], 
       
  1236                    visibility='protected')
   723     ## socket.h: bool ns3::Socket::NotifyConnectionRequest(ns3::Address const & from) [member function]
  1237     ## socket.h: bool ns3::Socket::NotifyConnectionRequest(ns3::Address const & from) [member function]
   724     cls.add_method('NotifyConnectionRequest', 'bool', [param('ns3::Address&', 'from', is_const=True)], visibility='protected')
  1238     cls.add_method('NotifyConnectionRequest', 
       
  1239                    'bool', 
       
  1240                    [param('ns3::Address&', 'from', is_const=True)], 
       
  1241                    visibility='protected')
   725     ## socket.h: void ns3::Socket::NotifyNewConnectionCreated(ns3::Ptr<ns3::Socket> socket, ns3::Address const & from) [member function]
  1242     ## socket.h: void ns3::Socket::NotifyNewConnectionCreated(ns3::Ptr<ns3::Socket> socket, ns3::Address const & from) [member function]
   726     cls.add_method('NotifyNewConnectionCreated', 'void', [param('ns3::Ptr< ns3::Socket >', 'socket'), param('ns3::Address&', 'from', is_const=True)], visibility='protected')
  1243     cls.add_method('NotifyNewConnectionCreated', 
       
  1244                    'void', 
       
  1245                    [param('ns3::Ptr< ns3::Socket >', 'socket'), param('ns3::Address&', 'from', is_const=True)], 
       
  1246                    visibility='protected')
   727     ## socket.h: void ns3::Socket::NotifyDataSent(uint32_t size) [member function]
  1247     ## socket.h: void ns3::Socket::NotifyDataSent(uint32_t size) [member function]
   728     cls.add_method('NotifyDataSent', 'void', [param('uint32_t', 'size')], visibility='protected')
  1248     cls.add_method('NotifyDataSent', 
       
  1249                    'void', 
       
  1250                    [param('uint32_t', 'size')], 
       
  1251                    visibility='protected')
   729     ## socket.h: void ns3::Socket::NotifySend(uint32_t spaceAvailable) [member function]
  1252     ## socket.h: void ns3::Socket::NotifySend(uint32_t spaceAvailable) [member function]
   730     cls.add_method('NotifySend', 'void', [param('uint32_t', 'spaceAvailable')], visibility='protected')
  1253     cls.add_method('NotifySend', 
       
  1254                    'void', 
       
  1255                    [param('uint32_t', 'spaceAvailable')], 
       
  1256                    visibility='protected')
   731     ## socket.h: void ns3::Socket::NotifyDataRecv() [member function]
  1257     ## socket.h: void ns3::Socket::NotifyDataRecv() [member function]
   732     cls.add_method('NotifyDataRecv', 'void', [], visibility='protected')
  1258     cls.add_method('NotifyDataRecv', 
       
  1259                    'void', 
       
  1260                    [], 
       
  1261                    visibility='protected')
   733     return
  1262     return
   734 
  1263 
   735 def register_Ns3Ipv4Header_methods(root_module, cls):
  1264 def register_Ns3Ipv4Header_methods(root_module, cls):
   736     ## ipv4-header.h: ns3::Ipv4Header::Ipv4Header() [constructor]
  1265     ## ipv4-header.h: ns3::Ipv4Header::Ipv4Header() [constructor]
   737     cls.add_constructor([], visibility='public')
  1266     cls.add_constructor([])
   738     ## ipv4-header.h: void ns3::Ipv4Header::EnableChecksum() [member function]
  1267     ## ipv4-header.h: void ns3::Ipv4Header::EnableChecksum() [member function]
   739     cls.add_method('EnableChecksum', 'void', [])
  1268     cls.add_method('EnableChecksum', 
       
  1269                    'void', 
       
  1270                    [])
   740     ## ipv4-header.h: void ns3::Ipv4Header::SetPayloadSize(uint16_t size) [member function]
  1271     ## ipv4-header.h: void ns3::Ipv4Header::SetPayloadSize(uint16_t size) [member function]
   741     cls.add_method('SetPayloadSize', 'void', [param('uint16_t', 'size')])
  1272     cls.add_method('SetPayloadSize', 
       
  1273                    'void', 
       
  1274                    [param('uint16_t', 'size')])
   742     ## ipv4-header.h: void ns3::Ipv4Header::SetIdentification(uint16_t identification) [member function]
  1275     ## ipv4-header.h: void ns3::Ipv4Header::SetIdentification(uint16_t identification) [member function]
   743     cls.add_method('SetIdentification', 'void', [param('uint16_t', 'identification')])
  1276     cls.add_method('SetIdentification', 
       
  1277                    'void', 
       
  1278                    [param('uint16_t', 'identification')])
   744     ## ipv4-header.h: void ns3::Ipv4Header::SetTos(uint8_t tos) [member function]
  1279     ## ipv4-header.h: void ns3::Ipv4Header::SetTos(uint8_t tos) [member function]
   745     cls.add_method('SetTos', 'void', [param('uint8_t', 'tos')])
  1280     cls.add_method('SetTos', 
       
  1281                    'void', 
       
  1282                    [param('uint8_t', 'tos')])
   746     ## ipv4-header.h: void ns3::Ipv4Header::SetMoreFragments() [member function]
  1283     ## ipv4-header.h: void ns3::Ipv4Header::SetMoreFragments() [member function]
   747     cls.add_method('SetMoreFragments', 'void', [])
  1284     cls.add_method('SetMoreFragments', 
       
  1285                    'void', 
       
  1286                    [])
   748     ## ipv4-header.h: void ns3::Ipv4Header::SetLastFragment() [member function]
  1287     ## ipv4-header.h: void ns3::Ipv4Header::SetLastFragment() [member function]
   749     cls.add_method('SetLastFragment', 'void', [])
  1288     cls.add_method('SetLastFragment', 
       
  1289                    'void', 
       
  1290                    [])
   750     ## ipv4-header.h: void ns3::Ipv4Header::SetDontFragment() [member function]
  1291     ## ipv4-header.h: void ns3::Ipv4Header::SetDontFragment() [member function]
   751     cls.add_method('SetDontFragment', 'void', [])
  1292     cls.add_method('SetDontFragment', 
       
  1293                    'void', 
       
  1294                    [])
   752     ## ipv4-header.h: void ns3::Ipv4Header::SetMayFragment() [member function]
  1295     ## ipv4-header.h: void ns3::Ipv4Header::SetMayFragment() [member function]
   753     cls.add_method('SetMayFragment', 'void', [])
  1296     cls.add_method('SetMayFragment', 
       
  1297                    'void', 
       
  1298                    [])
   754     ## ipv4-header.h: void ns3::Ipv4Header::SetFragmentOffset(uint16_t offset) [member function]
  1299     ## ipv4-header.h: void ns3::Ipv4Header::SetFragmentOffset(uint16_t offset) [member function]
   755     cls.add_method('SetFragmentOffset', 'void', [param('uint16_t', 'offset')])
  1300     cls.add_method('SetFragmentOffset', 
       
  1301                    'void', 
       
  1302                    [param('uint16_t', 'offset')])
   756     ## ipv4-header.h: void ns3::Ipv4Header::SetTtl(uint8_t ttl) [member function]
  1303     ## ipv4-header.h: void ns3::Ipv4Header::SetTtl(uint8_t ttl) [member function]
   757     cls.add_method('SetTtl', 'void', [param('uint8_t', 'ttl')])
  1304     cls.add_method('SetTtl', 
       
  1305                    'void', 
       
  1306                    [param('uint8_t', 'ttl')])
   758     ## ipv4-header.h: void ns3::Ipv4Header::SetProtocol(uint8_t num) [member function]
  1307     ## ipv4-header.h: void ns3::Ipv4Header::SetProtocol(uint8_t num) [member function]
   759     cls.add_method('SetProtocol', 'void', [param('uint8_t', 'num')])
  1308     cls.add_method('SetProtocol', 
       
  1309                    'void', 
       
  1310                    [param('uint8_t', 'num')])
   760     ## ipv4-header.h: void ns3::Ipv4Header::SetSource(ns3::Ipv4Address source) [member function]
  1311     ## ipv4-header.h: void ns3::Ipv4Header::SetSource(ns3::Ipv4Address source) [member function]
   761     cls.add_method('SetSource', 'void', [param('ns3::Ipv4Address', 'source')])
  1312     cls.add_method('SetSource', 
       
  1313                    'void', 
       
  1314                    [param('ns3::Ipv4Address', 'source')])
   762     ## ipv4-header.h: void ns3::Ipv4Header::SetDestination(ns3::Ipv4Address destination) [member function]
  1315     ## ipv4-header.h: void ns3::Ipv4Header::SetDestination(ns3::Ipv4Address destination) [member function]
   763     cls.add_method('SetDestination', 'void', [param('ns3::Ipv4Address', 'destination')])
  1316     cls.add_method('SetDestination', 
       
  1317                    'void', 
       
  1318                    [param('ns3::Ipv4Address', 'destination')])
   764     ## ipv4-header.h: uint16_t ns3::Ipv4Header::GetPayloadSize() const [member function]
  1319     ## ipv4-header.h: uint16_t ns3::Ipv4Header::GetPayloadSize() const [member function]
   765     cls.add_method('GetPayloadSize', 'uint16_t', [], is_const=True)
  1320     cls.add_method('GetPayloadSize', 
       
  1321                    'uint16_t', 
       
  1322                    [], 
       
  1323                    is_const=True)
   766     ## ipv4-header.h: uint16_t ns3::Ipv4Header::GetIdentification() const [member function]
  1324     ## ipv4-header.h: uint16_t ns3::Ipv4Header::GetIdentification() const [member function]
   767     cls.add_method('GetIdentification', 'uint16_t', [], is_const=True)
  1325     cls.add_method('GetIdentification', 
       
  1326                    'uint16_t', 
       
  1327                    [], 
       
  1328                    is_const=True)
   768     ## ipv4-header.h: uint8_t ns3::Ipv4Header::GetTos() const [member function]
  1329     ## ipv4-header.h: uint8_t ns3::Ipv4Header::GetTos() const [member function]
   769     cls.add_method('GetTos', 'uint8_t', [], is_const=True)
  1330     cls.add_method('GetTos', 
       
  1331                    'uint8_t', 
       
  1332                    [], 
       
  1333                    is_const=True)
   770     ## ipv4-header.h: bool ns3::Ipv4Header::IsLastFragment() const [member function]
  1334     ## ipv4-header.h: bool ns3::Ipv4Header::IsLastFragment() const [member function]
   771     cls.add_method('IsLastFragment', 'bool', [], is_const=True)
  1335     cls.add_method('IsLastFragment', 
       
  1336                    'bool', 
       
  1337                    [], 
       
  1338                    is_const=True)
   772     ## ipv4-header.h: bool ns3::Ipv4Header::IsDontFragment() const [member function]
  1339     ## ipv4-header.h: bool ns3::Ipv4Header::IsDontFragment() const [member function]
   773     cls.add_method('IsDontFragment', 'bool', [], is_const=True)
  1340     cls.add_method('IsDontFragment', 
       
  1341                    'bool', 
       
  1342                    [], 
       
  1343                    is_const=True)
   774     ## ipv4-header.h: uint16_t ns3::Ipv4Header::GetFragmentOffset() const [member function]
  1344     ## ipv4-header.h: uint16_t ns3::Ipv4Header::GetFragmentOffset() const [member function]
   775     cls.add_method('GetFragmentOffset', 'uint16_t', [], is_const=True)
  1345     cls.add_method('GetFragmentOffset', 
       
  1346                    'uint16_t', 
       
  1347                    [], 
       
  1348                    is_const=True)
   776     ## ipv4-header.h: uint8_t ns3::Ipv4Header::GetTtl() const [member function]
  1349     ## ipv4-header.h: uint8_t ns3::Ipv4Header::GetTtl() const [member function]
   777     cls.add_method('GetTtl', 'uint8_t', [], is_const=True)
  1350     cls.add_method('GetTtl', 
       
  1351                    'uint8_t', 
       
  1352                    [], 
       
  1353                    is_const=True)
   778     ## ipv4-header.h: uint8_t ns3::Ipv4Header::GetProtocol() const [member function]
  1354     ## ipv4-header.h: uint8_t ns3::Ipv4Header::GetProtocol() const [member function]
   779     cls.add_method('GetProtocol', 'uint8_t', [], is_const=True)
  1355     cls.add_method('GetProtocol', 
       
  1356                    'uint8_t', 
       
  1357                    [], 
       
  1358                    is_const=True)
   780     ## ipv4-header.h: ns3::Ipv4Address ns3::Ipv4Header::GetSource() const [member function]
  1359     ## ipv4-header.h: ns3::Ipv4Address ns3::Ipv4Header::GetSource() const [member function]
   781     cls.add_method('GetSource', 'ns3::Ipv4Address', [], is_const=True)
  1360     cls.add_method('GetSource', 
       
  1361                    'ns3::Ipv4Address', 
       
  1362                    [], 
       
  1363                    is_const=True)
   782     ## ipv4-header.h: ns3::Ipv4Address ns3::Ipv4Header::GetDestination() const [member function]
  1364     ## ipv4-header.h: ns3::Ipv4Address ns3::Ipv4Header::GetDestination() const [member function]
   783     cls.add_method('GetDestination', 'ns3::Ipv4Address', [], is_const=True)
  1365     cls.add_method('GetDestination', 
       
  1366                    'ns3::Ipv4Address', 
       
  1367                    [], 
       
  1368                    is_const=True)
   784     ## ipv4-header.h: bool ns3::Ipv4Header::IsChecksumOk() const [member function]
  1369     ## ipv4-header.h: bool ns3::Ipv4Header::IsChecksumOk() const [member function]
   785     cls.add_method('IsChecksumOk', 'bool', [], is_const=True)
  1370     cls.add_method('IsChecksumOk', 
       
  1371                    'bool', 
       
  1372                    [], 
       
  1373                    is_const=True)
   786     ## ipv4-header.h: static ns3::TypeId ns3::Ipv4Header::GetTypeId() [member function]
  1374     ## ipv4-header.h: static ns3::TypeId ns3::Ipv4Header::GetTypeId() [member function]
   787     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
  1375     cls.add_method('GetTypeId', 
       
  1376                    'ns3::TypeId', 
       
  1377                    [], 
       
  1378                    is_static=True)
   788     ## ipv4-header.h: ns3::TypeId ns3::Ipv4Header::GetInstanceTypeId() const [member function]
  1379     ## ipv4-header.h: ns3::TypeId ns3::Ipv4Header::GetInstanceTypeId() const [member function]
   789     cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True)
  1380     cls.add_method('GetInstanceTypeId', 
       
  1381                    'ns3::TypeId', 
       
  1382                    [], 
       
  1383                    is_const=True, is_virtual=True)
   790     ## ipv4-header.h: void ns3::Ipv4Header::Print(std::ostream & os) const [member function]
  1384     ## ipv4-header.h: void ns3::Ipv4Header::Print(std::ostream & os) const [member function]
   791     cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True, is_virtual=True)
  1385     cls.add_method('Print', 
       
  1386                    'void', 
       
  1387                    [param('std::ostream&', 'os')], 
       
  1388                    is_const=True, is_virtual=True)
   792     ## ipv4-header.h: uint32_t ns3::Ipv4Header::GetSerializedSize() const [member function]
  1389     ## ipv4-header.h: uint32_t ns3::Ipv4Header::GetSerializedSize() const [member function]
   793     cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True, is_virtual=True)
  1390     cls.add_method('GetSerializedSize', 
       
  1391                    'uint32_t', 
       
  1392                    [], 
       
  1393                    is_const=True, is_virtual=True)
   794     ## ipv4-header.h: void ns3::Ipv4Header::Serialize(ns3::Buffer::Iterator start) const [member function]
  1394     ## ipv4-header.h: void ns3::Ipv4Header::Serialize(ns3::Buffer::Iterator start) const [member function]
   795     cls.add_method('Serialize', 'void', [param('ns3::Buffer::Iterator', 'start')], is_const=True, is_virtual=True)
  1395     cls.add_method('Serialize', 
       
  1396                    'void', 
       
  1397                    [param('ns3::Buffer::Iterator', 'start')], 
       
  1398                    is_const=True, is_virtual=True)
   796     ## ipv4-header.h: uint32_t ns3::Ipv4Header::Deserialize(ns3::Buffer::Iterator start) [member function]
  1399     ## ipv4-header.h: uint32_t ns3::Ipv4Header::Deserialize(ns3::Buffer::Iterator start) [member function]
   797     cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'start')], is_virtual=True)
  1400     cls.add_method('Deserialize', 
       
  1401                    'uint32_t', 
       
  1402                    [param('ns3::Buffer::Iterator', 'start')], 
       
  1403                    is_virtual=True)
   798     return
  1404     return
   799 
  1405 
   800 def register_Ns3UdpSocket_methods(root_module, cls):
  1406 def register_Ns3UdpSocket_methods(root_module, cls):
   801     ## udp-socket.h: static ns3::TypeId ns3::UdpSocket::GetTypeId() [member function]
  1407     ## udp-socket.h: static ns3::TypeId ns3::UdpSocket::GetTypeId() [member function]
   802     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
  1408     cls.add_method('GetTypeId', 
       
  1409                    'ns3::TypeId', 
       
  1410                    [], 
       
  1411                    is_static=True)
   803     ## udp-socket.h: ns3::UdpSocket::UdpSocket() [constructor]
  1412     ## udp-socket.h: ns3::UdpSocket::UdpSocket() [constructor]
   804     cls.add_constructor([], visibility='public')
  1413     cls.add_constructor([])
   805     ## udp-socket.h: void ns3::UdpSocket::SetRcvBufSize(uint32_t size) [member function]
  1414     ## udp-socket.h: void ns3::UdpSocket::SetRcvBufSize(uint32_t size) [member function]
   806     cls.add_method('SetRcvBufSize', 'void', [param('uint32_t', 'size')], is_pure_virtual=True, visibility='private', is_virtual=True)
  1415     cls.add_method('SetRcvBufSize', 
       
  1416                    'void', 
       
  1417                    [param('uint32_t', 'size')], 
       
  1418                    is_pure_virtual=True, visibility='private', is_virtual=True)
   807     ## udp-socket.h: uint32_t ns3::UdpSocket::GetRcvBufSize() const [member function]
  1419     ## udp-socket.h: uint32_t ns3::UdpSocket::GetRcvBufSize() const [member function]
   808     cls.add_method('GetRcvBufSize', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1420     cls.add_method('GetRcvBufSize', 
       
  1421                    'uint32_t', 
       
  1422                    [], 
       
  1423                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
   809     ## udp-socket.h: void ns3::UdpSocket::SetIpTtl(uint32_t ipTtl) [member function]
  1424     ## udp-socket.h: void ns3::UdpSocket::SetIpTtl(uint32_t ipTtl) [member function]
   810     cls.add_method('SetIpTtl', 'void', [param('uint32_t', 'ipTtl')], is_pure_virtual=True, visibility='private', is_virtual=True)
  1425     cls.add_method('SetIpTtl', 
       
  1426                    'void', 
       
  1427                    [param('uint32_t', 'ipTtl')], 
       
  1428                    is_pure_virtual=True, visibility='private', is_virtual=True)
   811     ## udp-socket.h: uint32_t ns3::UdpSocket::GetIpTtl() const [member function]
  1429     ## udp-socket.h: uint32_t ns3::UdpSocket::GetIpTtl() const [member function]
   812     cls.add_method('GetIpTtl', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1430     cls.add_method('GetIpTtl', 
       
  1431                    'uint32_t', 
       
  1432                    [], 
       
  1433                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
   813     ## udp-socket.h: void ns3::UdpSocket::SetIpMulticastTtl(uint32_t ipTtl) [member function]
  1434     ## udp-socket.h: void ns3::UdpSocket::SetIpMulticastTtl(uint32_t ipTtl) [member function]
   814     cls.add_method('SetIpMulticastTtl', 'void', [param('uint32_t', 'ipTtl')], is_pure_virtual=True, visibility='private', is_virtual=True)
  1435     cls.add_method('SetIpMulticastTtl', 
       
  1436                    'void', 
       
  1437                    [param('uint32_t', 'ipTtl')], 
       
  1438                    is_pure_virtual=True, visibility='private', is_virtual=True)
   815     ## udp-socket.h: uint32_t ns3::UdpSocket::GetIpMulticastTtl() const [member function]
  1439     ## udp-socket.h: uint32_t ns3::UdpSocket::GetIpMulticastTtl() const [member function]
   816     cls.add_method('GetIpMulticastTtl', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1440     cls.add_method('GetIpMulticastTtl', 
       
  1441                    'uint32_t', 
       
  1442                    [], 
       
  1443                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
   817     return
  1444     return
   818 
  1445 
   819 def register_Ns3NetDevice_methods(root_module, cls):
  1446 def register_Ns3NetDevice_methods(root_module, cls):
   820     ## net-device.h: static ns3::TypeId ns3::NetDevice::GetTypeId() [member function]
  1447     ## net-device.h: static ns3::TypeId ns3::NetDevice::GetTypeId() [member function]
   821     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
  1448     cls.add_method('GetTypeId', 
       
  1449                    'ns3::TypeId', 
       
  1450                    [], 
       
  1451                    is_static=True)
   822     ## net-device.h: void ns3::NetDevice::SetName(std::string const name) [member function]
  1452     ## net-device.h: void ns3::NetDevice::SetName(std::string const name) [member function]
   823     cls.add_method('SetName', 'void', [param('std::string', 'name', is_const=True)], is_pure_virtual=True, is_virtual=True)
  1453     cls.add_method('SetName', 
       
  1454                    'void', 
       
  1455                    [param('std::string', 'name', is_const=True)], 
       
  1456                    is_pure_virtual=True, is_virtual=True)
   824     ## net-device.h: std::string ns3::NetDevice::GetName() const [member function]
  1457     ## net-device.h: std::string ns3::NetDevice::GetName() const [member function]
   825     cls.add_method('GetName', 'std::string', [], is_pure_virtual=True, is_const=True, is_virtual=True)
  1458     cls.add_method('GetName', 
       
  1459                    'std::string', 
       
  1460                    [], 
       
  1461                    is_pure_virtual=True, is_const=True, is_virtual=True)
   826     ## net-device.h: void ns3::NetDevice::SetIfIndex(uint32_t const index) [member function]
  1462     ## net-device.h: void ns3::NetDevice::SetIfIndex(uint32_t const index) [member function]
   827     cls.add_method('SetIfIndex', 'void', [param('uint32_t', 'index', is_const=True)], is_pure_virtual=True, is_virtual=True)
  1463     cls.add_method('SetIfIndex', 
       
  1464                    'void', 
       
  1465                    [param('uint32_t', 'index', is_const=True)], 
       
  1466                    is_pure_virtual=True, is_virtual=True)
   828     ## net-device.h: uint32_t ns3::NetDevice::GetIfIndex() const [member function]
  1467     ## net-device.h: uint32_t ns3::NetDevice::GetIfIndex() const [member function]
   829     cls.add_method('GetIfIndex', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True)
  1468     cls.add_method('GetIfIndex', 
       
  1469                    'uint32_t', 
       
  1470                    [], 
       
  1471                    is_pure_virtual=True, is_const=True, is_virtual=True)
   830     ## net-device.h: ns3::Ptr<ns3::Channel> ns3::NetDevice::GetChannel() const [member function]
  1472     ## net-device.h: ns3::Ptr<ns3::Channel> ns3::NetDevice::GetChannel() const [member function]
   831     cls.add_method('GetChannel', 'ns3::Ptr< ns3::Channel >', [], is_pure_virtual=True, is_const=True, is_virtual=True)
  1473     cls.add_method('GetChannel', 
       
  1474                    'ns3::Ptr< ns3::Channel >', 
       
  1475                    [], 
       
  1476                    is_pure_virtual=True, is_const=True, is_virtual=True)
   832     ## net-device.h: ns3::Address ns3::NetDevice::GetAddress() const [member function]
  1477     ## net-device.h: ns3::Address ns3::NetDevice::GetAddress() const [member function]
   833     cls.add_method('GetAddress', 'ns3::Address', [], is_pure_virtual=True, is_const=True, is_virtual=True)
  1478     cls.add_method('GetAddress', 
       
  1479                    'ns3::Address', 
       
  1480                    [], 
       
  1481                    is_pure_virtual=True, is_const=True, is_virtual=True)
   834     ## net-device.h: bool ns3::NetDevice::SetMtu(uint16_t const mtu) [member function]
  1482     ## net-device.h: bool ns3::NetDevice::SetMtu(uint16_t const mtu) [member function]
   835     cls.add_method('SetMtu', 'bool', [param('uint16_t', 'mtu', is_const=True)], is_pure_virtual=True, is_virtual=True)
  1483     cls.add_method('SetMtu', 
       
  1484                    'bool', 
       
  1485                    [param('uint16_t', 'mtu', is_const=True)], 
       
  1486                    is_pure_virtual=True, is_virtual=True)
   836     ## net-device.h: uint16_t ns3::NetDevice::GetMtu() const [member function]
  1487     ## net-device.h: uint16_t ns3::NetDevice::GetMtu() const [member function]
   837     cls.add_method('GetMtu', 'uint16_t', [], is_pure_virtual=True, is_const=True, is_virtual=True)
  1488     cls.add_method('GetMtu', 
       
  1489                    'uint16_t', 
       
  1490                    [], 
       
  1491                    is_pure_virtual=True, is_const=True, is_virtual=True)
   838     ## net-device.h: bool ns3::NetDevice::IsLinkUp() const [member function]
  1492     ## net-device.h: bool ns3::NetDevice::IsLinkUp() const [member function]
   839     cls.add_method('IsLinkUp', 'bool', [], is_pure_virtual=True, is_const=True, is_virtual=True)
  1493     cls.add_method('IsLinkUp', 
       
  1494                    'bool', 
       
  1495                    [], 
       
  1496                    is_pure_virtual=True, is_const=True, is_virtual=True)
   840     ## net-device.h: void ns3::NetDevice::SetLinkChangeCallback(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function]
  1497     ## net-device.h: void ns3::NetDevice::SetLinkChangeCallback(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function]
   841     cls.add_method('SetLinkChangeCallback', 'void', [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')], is_pure_virtual=True, is_virtual=True)
  1498     cls.add_method('SetLinkChangeCallback', 
       
  1499                    'void', 
       
  1500                    [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')], 
       
  1501                    is_pure_virtual=True, is_virtual=True)
   842     ## net-device.h: bool ns3::NetDevice::IsBroadcast() const [member function]
  1502     ## net-device.h: bool ns3::NetDevice::IsBroadcast() const [member function]
   843     cls.add_method('IsBroadcast', 'bool', [], is_pure_virtual=True, is_const=True, is_virtual=True)
  1503     cls.add_method('IsBroadcast', 
       
  1504                    'bool', 
       
  1505                    [], 
       
  1506                    is_pure_virtual=True, is_const=True, is_virtual=True)
   844     ## net-device.h: ns3::Address ns3::NetDevice::GetBroadcast() const [member function]
  1507     ## net-device.h: ns3::Address ns3::NetDevice::GetBroadcast() const [member function]
   845     cls.add_method('GetBroadcast', 'ns3::Address', [], is_pure_virtual=True, is_const=True, is_virtual=True)
  1508     cls.add_method('GetBroadcast', 
       
  1509                    'ns3::Address', 
       
  1510                    [], 
       
  1511                    is_pure_virtual=True, is_const=True, is_virtual=True)
   846     ## net-device.h: bool ns3::NetDevice::IsMulticast() const [member function]
  1512     ## net-device.h: bool ns3::NetDevice::IsMulticast() const [member function]
   847     cls.add_method('IsMulticast', 'bool', [], is_pure_virtual=True, is_const=True, is_virtual=True)
  1513     cls.add_method('IsMulticast', 
       
  1514                    'bool', 
       
  1515                    [], 
       
  1516                    is_pure_virtual=True, is_const=True, is_virtual=True)
   848     ## net-device.h: ns3::Address ns3::NetDevice::GetMulticast() const [member function]
  1517     ## net-device.h: ns3::Address ns3::NetDevice::GetMulticast() const [member function]
   849     cls.add_method('GetMulticast', 'ns3::Address', [], is_pure_virtual=True, is_const=True, is_virtual=True)
  1518     cls.add_method('GetMulticast', 
       
  1519                    'ns3::Address', 
       
  1520                    [], 
       
  1521                    is_pure_virtual=True, is_const=True, is_virtual=True)
   850     ## net-device.h: ns3::Address ns3::NetDevice::MakeMulticastAddress(ns3::Ipv4Address multicastGroup) const [member function]
  1522     ## net-device.h: ns3::Address ns3::NetDevice::MakeMulticastAddress(ns3::Ipv4Address multicastGroup) const [member function]
   851     cls.add_method('MakeMulticastAddress', 'ns3::Address', [param('ns3::Ipv4Address', 'multicastGroup')], is_pure_virtual=True, is_const=True, is_virtual=True)
  1523     cls.add_method('MakeMulticastAddress', 
       
  1524                    'ns3::Address', 
       
  1525                    [param('ns3::Ipv4Address', 'multicastGroup')], 
       
  1526                    is_pure_virtual=True, is_const=True, is_virtual=True)
   852     ## net-device.h: bool ns3::NetDevice::IsPointToPoint() const [member function]
  1527     ## net-device.h: bool ns3::NetDevice::IsPointToPoint() const [member function]
   853     cls.add_method('IsPointToPoint', 'bool', [], is_pure_virtual=True, is_const=True, is_virtual=True)
  1528     cls.add_method('IsPointToPoint', 
       
  1529                    'bool', 
       
  1530                    [], 
       
  1531                    is_pure_virtual=True, is_const=True, is_virtual=True)
   854     ## net-device.h: bool ns3::NetDevice::Send(ns3::Ptr<ns3::Packet> packet, ns3::Address const & dest, uint16_t protocolNumber) [member function]
  1532     ## net-device.h: bool ns3::NetDevice::Send(ns3::Ptr<ns3::Packet> packet, ns3::Address const & dest, uint16_t protocolNumber) [member function]
   855     cls.add_method('Send', 'bool', [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address&', 'dest', is_const=True), param('uint16_t', 'protocolNumber')], is_pure_virtual=True, is_virtual=True)
  1533     cls.add_method('Send', 
       
  1534                    'bool', 
       
  1535                    [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address&', 'dest', is_const=True), param('uint16_t', 'protocolNumber')], 
       
  1536                    is_pure_virtual=True, is_virtual=True)
   856     ## net-device.h: bool ns3::NetDevice::SendFrom(ns3::Ptr<ns3::Packet> packet, ns3::Address const & source, ns3::Address const & dest, uint16_t protocolNumber) [member function]
  1537     ## net-device.h: bool ns3::NetDevice::SendFrom(ns3::Ptr<ns3::Packet> packet, ns3::Address const & source, ns3::Address const & dest, uint16_t protocolNumber) [member function]
   857     cls.add_method('SendFrom', 'bool', [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address&', 'source', is_const=True), param('ns3::Address&', 'dest', is_const=True), param('uint16_t', 'protocolNumber')], is_pure_virtual=True, is_virtual=True)
  1538     cls.add_method('SendFrom', 
       
  1539                    'bool', 
       
  1540                    [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address&', 'source', is_const=True), param('ns3::Address&', 'dest', is_const=True), param('uint16_t', 'protocolNumber')], 
       
  1541                    is_virtual=True)
   858     ## net-device.h: ns3::Ptr<ns3::Node> ns3::NetDevice::GetNode() const [member function]
  1542     ## net-device.h: ns3::Ptr<ns3::Node> ns3::NetDevice::GetNode() const [member function]
   859     cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', [], is_pure_virtual=True, is_const=True, is_virtual=True)
  1543     cls.add_method('GetNode', 
       
  1544                    'ns3::Ptr< ns3::Node >', 
       
  1545                    [], 
       
  1546                    is_pure_virtual=True, is_const=True, is_virtual=True)
   860     ## net-device.h: void ns3::NetDevice::SetNode(ns3::Ptr<ns3::Node> node) [member function]
  1547     ## net-device.h: void ns3::NetDevice::SetNode(ns3::Ptr<ns3::Node> node) [member function]
   861     cls.add_method('SetNode', 'void', [param('ns3::Ptr< ns3::Node >', 'node')], is_pure_virtual=True, is_virtual=True)
  1548     cls.add_method('SetNode', 
       
  1549                    'void', 
       
  1550                    [param('ns3::Ptr< ns3::Node >', 'node')], 
       
  1551                    is_pure_virtual=True, is_virtual=True)
   862     ## net-device.h: bool ns3::NetDevice::NeedsArp() const [member function]
  1552     ## net-device.h: bool ns3::NetDevice::NeedsArp() const [member function]
   863     cls.add_method('NeedsArp', 'bool', [], is_pure_virtual=True, is_const=True, is_virtual=True)
  1553     cls.add_method('NeedsArp', 
       
  1554                    'bool', 
       
  1555                    [], 
       
  1556                    is_pure_virtual=True, is_const=True, is_virtual=True)
   864     ## 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]
  1557     ## 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]
   865     cls.add_method('SetReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], is_pure_virtual=True, is_virtual=True)
  1558     cls.add_method('SetReceiveCallback', 
       
  1559                    'void', 
       
  1560                    [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], 
       
  1561                    is_pure_virtual=True, is_virtual=True)
   866     ## 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]
  1562     ## 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]
   867     cls.add_method('SetPromiscReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'cb')], is_virtual=True)
  1563     cls.add_method('SetPromiscReceiveCallback', 
       
  1564                    'void', 
       
  1565                    [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'cb')], 
       
  1566                    is_virtual=True)
   868     ## net-device.h: bool ns3::NetDevice::SupportsPromiscuous() const [member function]
  1567     ## net-device.h: bool ns3::NetDevice::SupportsPromiscuous() const [member function]
   869     cls.add_method('SupportsPromiscuous', 'bool', [], is_const=True, is_virtual=True)
  1568     cls.add_method('SupportsPromiscuous', 
       
  1569                    'bool', 
       
  1570                    [], 
       
  1571                    is_const=True, is_virtual=True)
   870     cls.add_constructor([])
  1572     cls.add_constructor([])
   871     return
  1573     return
   872 
  1574 
   873 def register_Ns3AddressValue_methods(root_module, cls):
  1575 def register_Ns3AddressValue_methods(root_module, cls):
   874     ## address.h: ns3::AddressValue::AddressValue() [constructor]
  1576     ## address.h: ns3::AddressValue::AddressValue() [constructor]
   875     cls.add_constructor([], visibility='public')
  1577     cls.add_constructor([])
   876     ## address.h: ns3::AddressValue::AddressValue(ns3::Address const & value) [constructor]
  1578     ## address.h: ns3::AddressValue::AddressValue(ns3::Address const & value) [constructor]
   877     cls.add_constructor([param('ns3::Address&', 'value', is_const=True)], visibility='public')
  1579     cls.add_constructor([param('ns3::Address&', 'value', is_const=True)])
   878     ## address.h: void ns3::AddressValue::Set(ns3::Address const & value) [member function]
  1580     ## address.h: void ns3::AddressValue::Set(ns3::Address const & value) [member function]
   879     cls.add_method('Set', 'void', [param('ns3::Address&', 'value', is_const=True)])
  1581     cls.add_method('Set', 
       
  1582                    'void', 
       
  1583                    [param('ns3::Address&', 'value', is_const=True)])
   880     ## address.h: ns3::Address ns3::AddressValue::Get() const [member function]
  1584     ## address.h: ns3::Address ns3::AddressValue::Get() const [member function]
   881     cls.add_method('Get', 'ns3::Address', [], is_const=True)
  1585     cls.add_method('Get', 
       
  1586                    'ns3::Address', 
       
  1587                    [], 
       
  1588                    is_const=True)
   882     ## address.h: ns3::Ptr<ns3::AttributeValue> ns3::AddressValue::Copy() const [member function]
  1589     ## address.h: ns3::Ptr<ns3::AttributeValue> ns3::AddressValue::Copy() const [member function]
   883     cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
  1590     cls.add_method('Copy', 
       
  1591                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1592                    [], 
       
  1593                    is_const=True, is_virtual=True)
   884     ## address.h: std::string ns3::AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1594     ## address.h: std::string ns3::AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
   885     cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True)
  1595     cls.add_method('SerializeToString', 
       
  1596                    'std::string', 
       
  1597                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1598                    is_const=True, is_virtual=True)
   886     ## address.h: bool ns3::AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1599     ## address.h: bool ns3::AddressValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   887     cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True)
  1600     cls.add_method('DeserializeFromString', 
       
  1601                    'bool', 
       
  1602                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1603                    is_virtual=True)
   888     return
  1604     return
   889 
  1605 
   890 def register_Ns3Node_methods(root_module, cls):
  1606 def register_Ns3Node_methods(root_module, cls):
   891     ## node.h: static ns3::TypeId ns3::Node::GetTypeId() [member function]
  1607     ## node.h: static ns3::TypeId ns3::Node::GetTypeId() [member function]
   892     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
  1608     cls.add_method('GetTypeId', 
       
  1609                    'ns3::TypeId', 
       
  1610                    [], 
       
  1611                    is_static=True)
   893     ## node.h: ns3::Node::Node() [constructor]
  1612     ## node.h: ns3::Node::Node() [constructor]
   894     cls.add_constructor([], visibility='public')
  1613     cls.add_constructor([])
   895     ## node.h: ns3::Node::Node(uint32_t systemId) [constructor]
  1614     ## node.h: ns3::Node::Node(uint32_t systemId) [constructor]
   896     cls.add_constructor([param('uint32_t', 'systemId')], visibility='public')
  1615     cls.add_constructor([param('uint32_t', 'systemId')])
   897     ## node.h: uint32_t ns3::Node::GetId() const [member function]
  1616     ## node.h: uint32_t ns3::Node::GetId() const [member function]
   898     cls.add_method('GetId', 'uint32_t', [], is_const=True)
  1617     cls.add_method('GetId', 
       
  1618                    'uint32_t', 
       
  1619                    [], 
       
  1620                    is_const=True)
   899     ## node.h: uint32_t ns3::Node::GetSystemId() const [member function]
  1621     ## node.h: uint32_t ns3::Node::GetSystemId() const [member function]
   900     cls.add_method('GetSystemId', 'uint32_t', [], is_const=True)
  1622     cls.add_method('GetSystemId', 
       
  1623                    'uint32_t', 
       
  1624                    [], 
       
  1625                    is_const=True)
   901     ## node.h: uint32_t ns3::Node::AddDevice(ns3::Ptr<ns3::NetDevice> device) [member function]
  1626     ## node.h: uint32_t ns3::Node::AddDevice(ns3::Ptr<ns3::NetDevice> device) [member function]
   902     cls.add_method('AddDevice', 'uint32_t', [param('ns3::Ptr< ns3::NetDevice >', 'device')])
  1627     cls.add_method('AddDevice', 
       
  1628                    'uint32_t', 
       
  1629                    [param('ns3::Ptr< ns3::NetDevice >', 'device')])
   903     ## node.h: ns3::Ptr<ns3::NetDevice> ns3::Node::GetDevice(uint32_t index) const [member function]
  1630     ## node.h: ns3::Ptr<ns3::NetDevice> ns3::Node::GetDevice(uint32_t index) const [member function]
   904     cls.add_method('GetDevice', 'ns3::Ptr< ns3::NetDevice >', [param('uint32_t', 'index')], is_const=True)
  1631     cls.add_method('GetDevice', 
       
  1632                    'ns3::Ptr< ns3::NetDevice >', 
       
  1633                    [param('uint32_t', 'index')], 
       
  1634                    is_const=True)
   905     ## node.h: uint32_t ns3::Node::GetNDevices() const [member function]
  1635     ## node.h: uint32_t ns3::Node::GetNDevices() const [member function]
   906     cls.add_method('GetNDevices', 'uint32_t', [], is_const=True)
  1636     cls.add_method('GetNDevices', 
       
  1637                    'uint32_t', 
       
  1638                    [], 
       
  1639                    is_const=True)
   907     ## node.h: uint32_t ns3::Node::AddApplication(ns3::Ptr<ns3::Application> application) [member function]
  1640     ## node.h: uint32_t ns3::Node::AddApplication(ns3::Ptr<ns3::Application> application) [member function]
   908     cls.add_method('AddApplication', 'uint32_t', [param('ns3::Ptr< ns3::Application >', 'application')])
  1641     cls.add_method('AddApplication', 
       
  1642                    'uint32_t', 
       
  1643                    [param('ns3::Ptr< ns3::Application >', 'application')])
   909     ## node.h: ns3::Ptr<ns3::Application> ns3::Node::GetApplication(uint32_t index) const [member function]
  1644     ## node.h: ns3::Ptr<ns3::Application> ns3::Node::GetApplication(uint32_t index) const [member function]
   910     cls.add_method('GetApplication', 'ns3::Ptr< ns3::Application >', [param('uint32_t', 'index')], is_const=True)
  1645     cls.add_method('GetApplication', 
       
  1646                    'ns3::Ptr< ns3::Application >', 
       
  1647                    [param('uint32_t', 'index')], 
       
  1648                    is_const=True)
   911     ## node.h: ns3::Ptr<ns3::Application> ns3::Node::GetFirstApplication(ns3::TypeId tid) [member function]
  1649     ## node.h: ns3::Ptr<ns3::Application> ns3::Node::GetFirstApplication(ns3::TypeId tid) [member function]
   912     cls.add_method('GetFirstApplication', 'ns3::Ptr< ns3::Application >', [param('ns3::TypeId', 'tid')])
  1650     cls.add_method('GetFirstApplication', 
       
  1651                    'ns3::Ptr< ns3::Application >', 
       
  1652                    [param('ns3::TypeId', 'tid')])
   913     ## node.h: uint32_t ns3::Node::GetNApplications() const [member function]
  1653     ## node.h: uint32_t ns3::Node::GetNApplications() const [member function]
   914     cls.add_method('GetNApplications', 'uint32_t', [], is_const=True)
  1654     cls.add_method('GetNApplications', 
       
  1655                    'uint32_t', 
       
  1656                    [], 
       
  1657                    is_const=True)
   915     ## 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]
  1658     ## 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]
   916     cls.add_method('RegisterProtocolHandler', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< 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')])
  1659     cls.add_method('RegisterProtocolHandler', 
       
  1660                    'void', 
       
  1661                    [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< 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')])
   917     ## 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]
  1662     ## 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]
   918     cls.add_method('UnregisterProtocolHandler', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'handler')])
  1663     cls.add_method('UnregisterProtocolHandler', 
       
  1664                    'void', 
       
  1665                    [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet >, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType >', 'handler')])
   919     ## node.h: void ns3::Node::DoDispose() [member function]
  1666     ## node.h: void ns3::Node::DoDispose() [member function]
   920     cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True)
  1667     cls.add_method('DoDispose', 
       
  1668                    'void', 
       
  1669                    [], 
       
  1670                    visibility='protected', is_virtual=True)
   921     ## node.h: void ns3::Node::NotifyDeviceAdded(ns3::Ptr<ns3::NetDevice> device) [member function]
  1671     ## node.h: void ns3::Node::NotifyDeviceAdded(ns3::Ptr<ns3::NetDevice> device) [member function]
   922     cls.add_method('NotifyDeviceAdded', 'void', [param('ns3::Ptr< ns3::NetDevice >', 'device')], visibility='private', is_virtual=True)
  1672     cls.add_method('NotifyDeviceAdded', 
       
  1673                    'void', 
       
  1674                    [param('ns3::Ptr< ns3::NetDevice >', 'device')], 
       
  1675                    visibility='private', is_virtual=True)
   923     return
  1676     return
   924 
  1677 
   925 def register_Ns3Channel_methods(root_module, cls):
  1678 def register_Ns3Channel_methods(root_module, cls):
   926     ## channel.h: static ns3::TypeId ns3::Channel::GetTypeId() [member function]
  1679     ## channel.h: static ns3::TypeId ns3::Channel::GetTypeId() [member function]
   927     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
  1680     cls.add_method('GetTypeId', 
       
  1681                    'ns3::TypeId', 
       
  1682                    [], 
       
  1683                    is_static=True)
   928     ## channel.h: ns3::Channel::Channel() [constructor]
  1684     ## channel.h: ns3::Channel::Channel() [constructor]
   929     cls.add_constructor([], visibility='public')
  1685     cls.add_constructor([])
   930     ## channel.h: ns3::Channel::Channel(std::string name) [constructor]
  1686     ## channel.h: ns3::Channel::Channel(std::string name) [constructor]
   931     cls.add_constructor([param('std::string', 'name')], visibility='public')
  1687     cls.add_constructor([param('std::string', 'name')])
   932     ## channel.h: void ns3::Channel::SetName(std::string arg0) [member function]
  1688     ## channel.h: void ns3::Channel::SetName(std::string arg0) [member function]
   933     cls.add_method('SetName', 'void', [param('std::string', 'arg0')])
  1689     cls.add_method('SetName', 
       
  1690                    'void', 
       
  1691                    [param('std::string', 'arg0')])
   934     ## channel.h: std::string ns3::Channel::GetName() [member function]
  1692     ## channel.h: std::string ns3::Channel::GetName() [member function]
   935     cls.add_method('GetName', 'std::string', [])
  1693     cls.add_method('GetName', 
       
  1694                    'std::string', 
       
  1695                    [])
   936     ## channel.h: uint32_t ns3::Channel::GetNDevices() const [member function]
  1696     ## channel.h: uint32_t ns3::Channel::GetNDevices() const [member function]
   937     cls.add_method('GetNDevices', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True)
  1697     cls.add_method('GetNDevices', 
       
  1698                    'uint32_t', 
       
  1699                    [], 
       
  1700                    is_pure_virtual=True, is_const=True, is_virtual=True)
   938     ## channel.h: ns3::Ptr<ns3::NetDevice> ns3::Channel::GetDevice(uint32_t i) const [member function]
  1701     ## channel.h: ns3::Ptr<ns3::NetDevice> ns3::Channel::GetDevice(uint32_t i) const [member function]
   939     cls.add_method('GetDevice', 'ns3::Ptr< ns3::NetDevice >', [param('uint32_t', 'i')], is_pure_virtual=True, is_const=True, is_virtual=True)
  1702     cls.add_method('GetDevice', 
       
  1703                    'ns3::Ptr< ns3::NetDevice >', 
       
  1704                    [param('uint32_t', 'i')], 
       
  1705                    is_pure_virtual=True, is_const=True, is_virtual=True)
   940     return
  1706     return
   941 
  1707 
   942 def register_Ns3TcpSocket_methods(root_module, cls):
  1708 def register_Ns3TcpSocket_methods(root_module, cls):
   943     ## tcp-socket.h: static ns3::TypeId ns3::TcpSocket::GetTypeId() [member function]
  1709     ## tcp-socket.h: static ns3::TypeId ns3::TcpSocket::GetTypeId() [member function]
   944     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
  1710     cls.add_method('GetTypeId', 
       
  1711                    'ns3::TypeId', 
       
  1712                    [], 
       
  1713                    is_static=True)
   945     ## tcp-socket.h: ns3::TcpSocket::TcpSocket() [constructor]
  1714     ## tcp-socket.h: ns3::TcpSocket::TcpSocket() [constructor]
   946     cls.add_constructor([], visibility='public')
  1715     cls.add_constructor([])
   947     ## tcp-socket.h: void ns3::TcpSocket::SetSndBufSize(uint32_t size) [member function]
  1716     ## tcp-socket.h: void ns3::TcpSocket::SetSndBufSize(uint32_t size) [member function]
   948     cls.add_method('SetSndBufSize', 'void', [param('uint32_t', 'size')], is_pure_virtual=True, visibility='private', is_virtual=True)
  1717     cls.add_method('SetSndBufSize', 
       
  1718                    'void', 
       
  1719                    [param('uint32_t', 'size')], 
       
  1720                    is_pure_virtual=True, visibility='private', is_virtual=True)
   949     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetSndBufSize() const [member function]
  1721     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetSndBufSize() const [member function]
   950     cls.add_method('GetSndBufSize', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1722     cls.add_method('GetSndBufSize', 
       
  1723                    'uint32_t', 
       
  1724                    [], 
       
  1725                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
   951     ## tcp-socket.h: void ns3::TcpSocket::SetRcvBufSize(uint32_t size) [member function]
  1726     ## tcp-socket.h: void ns3::TcpSocket::SetRcvBufSize(uint32_t size) [member function]
   952     cls.add_method('SetRcvBufSize', 'void', [param('uint32_t', 'size')], is_pure_virtual=True, visibility='private', is_virtual=True)
  1727     cls.add_method('SetRcvBufSize', 
       
  1728                    'void', 
       
  1729                    [param('uint32_t', 'size')], 
       
  1730                    is_pure_virtual=True, visibility='private', is_virtual=True)
   953     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetRcvBufSize() const [member function]
  1731     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetRcvBufSize() const [member function]
   954     cls.add_method('GetRcvBufSize', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1732     cls.add_method('GetRcvBufSize', 
       
  1733                    'uint32_t', 
       
  1734                    [], 
       
  1735                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
   955     ## tcp-socket.h: void ns3::TcpSocket::SetSegSize(uint32_t size) [member function]
  1736     ## tcp-socket.h: void ns3::TcpSocket::SetSegSize(uint32_t size) [member function]
   956     cls.add_method('SetSegSize', 'void', [param('uint32_t', 'size')], is_pure_virtual=True, visibility='private', is_virtual=True)
  1737     cls.add_method('SetSegSize', 
       
  1738                    'void', 
       
  1739                    [param('uint32_t', 'size')], 
       
  1740                    is_pure_virtual=True, visibility='private', is_virtual=True)
   957     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetSegSize() const [member function]
  1741     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetSegSize() const [member function]
   958     cls.add_method('GetSegSize', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1742     cls.add_method('GetSegSize', 
       
  1743                    'uint32_t', 
       
  1744                    [], 
       
  1745                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
   959     ## tcp-socket.h: void ns3::TcpSocket::SetAdvWin(uint32_t window) [member function]
  1746     ## tcp-socket.h: void ns3::TcpSocket::SetAdvWin(uint32_t window) [member function]
   960     cls.add_method('SetAdvWin', 'void', [param('uint32_t', 'window')], is_pure_virtual=True, visibility='private', is_virtual=True)
  1747     cls.add_method('SetAdvWin', 
       
  1748                    'void', 
       
  1749                    [param('uint32_t', 'window')], 
       
  1750                    is_pure_virtual=True, visibility='private', is_virtual=True)
   961     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetAdvWin() const [member function]
  1751     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetAdvWin() const [member function]
   962     cls.add_method('GetAdvWin', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1752     cls.add_method('GetAdvWin', 
       
  1753                    'uint32_t', 
       
  1754                    [], 
       
  1755                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
   963     ## tcp-socket.h: void ns3::TcpSocket::SetSSThresh(uint32_t threshold) [member function]
  1756     ## tcp-socket.h: void ns3::TcpSocket::SetSSThresh(uint32_t threshold) [member function]
   964     cls.add_method('SetSSThresh', 'void', [param('uint32_t', 'threshold')], is_pure_virtual=True, visibility='private', is_virtual=True)
  1757     cls.add_method('SetSSThresh', 
       
  1758                    'void', 
       
  1759                    [param('uint32_t', 'threshold')], 
       
  1760                    is_pure_virtual=True, visibility='private', is_virtual=True)
   965     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetSSThresh() const [member function]
  1761     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetSSThresh() const [member function]
   966     cls.add_method('GetSSThresh', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1762     cls.add_method('GetSSThresh', 
       
  1763                    'uint32_t', 
       
  1764                    [], 
       
  1765                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
   967     ## tcp-socket.h: void ns3::TcpSocket::SetInitialCwnd(uint32_t count) [member function]
  1766     ## tcp-socket.h: void ns3::TcpSocket::SetInitialCwnd(uint32_t count) [member function]
   968     cls.add_method('SetInitialCwnd', 'void', [param('uint32_t', 'count')], is_pure_virtual=True, visibility='private', is_virtual=True)
  1767     cls.add_method('SetInitialCwnd', 
       
  1768                    'void', 
       
  1769                    [param('uint32_t', 'count')], 
       
  1770                    is_pure_virtual=True, visibility='private', is_virtual=True)
   969     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetInitialCwnd() const [member function]
  1771     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetInitialCwnd() const [member function]
   970     cls.add_method('GetInitialCwnd', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1772     cls.add_method('GetInitialCwnd', 
       
  1773                    'uint32_t', 
       
  1774                    [], 
       
  1775                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
   971     ## tcp-socket.h: void ns3::TcpSocket::SetConnTimeout(ns3::Time timeout) [member function]
  1776     ## tcp-socket.h: void ns3::TcpSocket::SetConnTimeout(ns3::Time timeout) [member function]
   972     cls.add_method('SetConnTimeout', 'void', [param('ns3::Time', 'timeout')], is_pure_virtual=True, visibility='private', is_virtual=True)
  1777     cls.add_method('SetConnTimeout', 
       
  1778                    'void', 
       
  1779                    [param('ns3::Time', 'timeout')], 
       
  1780                    is_pure_virtual=True, visibility='private', is_virtual=True)
   973     ## tcp-socket.h: ns3::Time ns3::TcpSocket::GetConnTimeout() const [member function]
  1781     ## tcp-socket.h: ns3::Time ns3::TcpSocket::GetConnTimeout() const [member function]
   974     cls.add_method('GetConnTimeout', 'ns3::Time', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1782     cls.add_method('GetConnTimeout', 
       
  1783                    'ns3::Time', 
       
  1784                    [], 
       
  1785                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
   975     ## tcp-socket.h: void ns3::TcpSocket::SetConnCount(uint32_t count) [member function]
  1786     ## tcp-socket.h: void ns3::TcpSocket::SetConnCount(uint32_t count) [member function]
   976     cls.add_method('SetConnCount', 'void', [param('uint32_t', 'count')], is_pure_virtual=True, visibility='private', is_virtual=True)
  1787     cls.add_method('SetConnCount', 
       
  1788                    'void', 
       
  1789                    [param('uint32_t', 'count')], 
       
  1790                    is_pure_virtual=True, visibility='private', is_virtual=True)
   977     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetConnCount() const [member function]
  1791     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetConnCount() const [member function]
   978     cls.add_method('GetConnCount', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1792     cls.add_method('GetConnCount', 
       
  1793                    'uint32_t', 
       
  1794                    [], 
       
  1795                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
   979     ## tcp-socket.h: void ns3::TcpSocket::SetDelAckTimeout(ns3::Time timeout) [member function]
  1796     ## tcp-socket.h: void ns3::TcpSocket::SetDelAckTimeout(ns3::Time timeout) [member function]
   980     cls.add_method('SetDelAckTimeout', 'void', [param('ns3::Time', 'timeout')], is_pure_virtual=True, visibility='private', is_virtual=True)
  1797     cls.add_method('SetDelAckTimeout', 
       
  1798                    'void', 
       
  1799                    [param('ns3::Time', 'timeout')], 
       
  1800                    is_pure_virtual=True, visibility='private', is_virtual=True)
   981     ## tcp-socket.h: ns3::Time ns3::TcpSocket::GetDelAckTimeout() const [member function]
  1801     ## tcp-socket.h: ns3::Time ns3::TcpSocket::GetDelAckTimeout() const [member function]
   982     cls.add_method('GetDelAckTimeout', 'ns3::Time', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1802     cls.add_method('GetDelAckTimeout', 
       
  1803                    'ns3::Time', 
       
  1804                    [], 
       
  1805                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
   983     ## tcp-socket.h: void ns3::TcpSocket::SetDelAckMaxCount(uint32_t count) [member function]
  1806     ## tcp-socket.h: void ns3::TcpSocket::SetDelAckMaxCount(uint32_t count) [member function]
   984     cls.add_method('SetDelAckMaxCount', 'void', [param('uint32_t', 'count')], is_pure_virtual=True, visibility='private', is_virtual=True)
  1807     cls.add_method('SetDelAckMaxCount', 
       
  1808                    'void', 
       
  1809                    [param('uint32_t', 'count')], 
       
  1810                    is_pure_virtual=True, visibility='private', is_virtual=True)
   985     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetDelAckMaxCount() const [member function]
  1811     ## tcp-socket.h: uint32_t ns3::TcpSocket::GetDelAckMaxCount() const [member function]
   986     cls.add_method('GetDelAckMaxCount', 'uint32_t', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1812     cls.add_method('GetDelAckMaxCount', 
       
  1813                    'uint32_t', 
       
  1814                    [], 
       
  1815                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
   987     return
  1816     return
   988 
  1817 
   989 def register_Ns3EthernetHeader_methods(root_module, cls):
  1818 def register_Ns3EthernetHeader_methods(root_module, cls):
   990     ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader(bool hasPreamble) [constructor]
  1819     ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader(bool hasPreamble) [constructor]
   991     cls.add_constructor([param('bool', 'hasPreamble')], visibility='public')
  1820     cls.add_constructor([param('bool', 'hasPreamble')])
   992     ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader() [constructor]
  1821     ## ethernet-header.h: ns3::EthernetHeader::EthernetHeader() [constructor]
   993     cls.add_constructor([], visibility='public')
  1822     cls.add_constructor([])
   994     ## ethernet-header.h: void ns3::EthernetHeader::SetLengthType(uint16_t size) [member function]
  1823     ## ethernet-header.h: void ns3::EthernetHeader::SetLengthType(uint16_t size) [member function]
   995     cls.add_method('SetLengthType', 'void', [param('uint16_t', 'size')])
  1824     cls.add_method('SetLengthType', 
       
  1825                    'void', 
       
  1826                    [param('uint16_t', 'size')])
   996     ## ethernet-header.h: void ns3::EthernetHeader::SetSource(ns3::Mac48Address source) [member function]
  1827     ## ethernet-header.h: void ns3::EthernetHeader::SetSource(ns3::Mac48Address source) [member function]
   997     cls.add_method('SetSource', 'void', [param('ns3::Mac48Address', 'source')])
  1828     cls.add_method('SetSource', 
       
  1829                    'void', 
       
  1830                    [param('ns3::Mac48Address', 'source')])
   998     ## ethernet-header.h: void ns3::EthernetHeader::SetDestination(ns3::Mac48Address destination) [member function]
  1831     ## ethernet-header.h: void ns3::EthernetHeader::SetDestination(ns3::Mac48Address destination) [member function]
   999     cls.add_method('SetDestination', 'void', [param('ns3::Mac48Address', 'destination')])
  1832     cls.add_method('SetDestination', 
       
  1833                    'void', 
       
  1834                    [param('ns3::Mac48Address', 'destination')])
  1000     ## ethernet-header.h: void ns3::EthernetHeader::SetPreambleSfd(uint64_t preambleSfd) [member function]
  1835     ## ethernet-header.h: void ns3::EthernetHeader::SetPreambleSfd(uint64_t preambleSfd) [member function]
  1001     cls.add_method('SetPreambleSfd', 'void', [param('uint64_t', 'preambleSfd')])
  1836     cls.add_method('SetPreambleSfd', 
       
  1837                    'void', 
       
  1838                    [param('uint64_t', 'preambleSfd')])
  1002     ## ethernet-header.h: uint16_t ns3::EthernetHeader::GetLengthType() const [member function]
  1839     ## ethernet-header.h: uint16_t ns3::EthernetHeader::GetLengthType() const [member function]
  1003     cls.add_method('GetLengthType', 'uint16_t', [], is_const=True)
  1840     cls.add_method('GetLengthType', 
       
  1841                    'uint16_t', 
       
  1842                    [], 
       
  1843                    is_const=True)
  1004     ## ethernet-header.h: ns3::ethernet_header_t ns3::EthernetHeader::GetPacketType() const [member function]
  1844     ## ethernet-header.h: ns3::ethernet_header_t ns3::EthernetHeader::GetPacketType() const [member function]
  1005     cls.add_method('GetPacketType', 'ns3::ethernet_header_t', [], is_const=True)
  1845     cls.add_method('GetPacketType', 
       
  1846                    'ns3::ethernet_header_t', 
       
  1847                    [], 
       
  1848                    is_const=True)
  1006     ## ethernet-header.h: ns3::Mac48Address ns3::EthernetHeader::GetSource() const [member function]
  1849     ## ethernet-header.h: ns3::Mac48Address ns3::EthernetHeader::GetSource() const [member function]
  1007     cls.add_method('GetSource', 'ns3::Mac48Address', [], is_const=True)
  1850     cls.add_method('GetSource', 
       
  1851                    'ns3::Mac48Address', 
       
  1852                    [], 
       
  1853                    is_const=True)
  1008     ## ethernet-header.h: ns3::Mac48Address ns3::EthernetHeader::GetDestination() const [member function]
  1854     ## ethernet-header.h: ns3::Mac48Address ns3::EthernetHeader::GetDestination() const [member function]
  1009     cls.add_method('GetDestination', 'ns3::Mac48Address', [], is_const=True)
  1855     cls.add_method('GetDestination', 
       
  1856                    'ns3::Mac48Address', 
       
  1857                    [], 
       
  1858                    is_const=True)
  1010     ## ethernet-header.h: uint64_t ns3::EthernetHeader::GetPreambleSfd() const [member function]
  1859     ## ethernet-header.h: uint64_t ns3::EthernetHeader::GetPreambleSfd() const [member function]
  1011     cls.add_method('GetPreambleSfd', 'uint64_t', [], is_const=True)
  1860     cls.add_method('GetPreambleSfd', 
       
  1861                    'uint64_t', 
       
  1862                    [], 
       
  1863                    is_const=True)
  1012     ## ethernet-header.h: uint32_t ns3::EthernetHeader::GetHeaderSize() const [member function]
  1864     ## ethernet-header.h: uint32_t ns3::EthernetHeader::GetHeaderSize() const [member function]
  1013     cls.add_method('GetHeaderSize', 'uint32_t', [], is_const=True)
  1865     cls.add_method('GetHeaderSize', 
       
  1866                    'uint32_t', 
       
  1867                    [], 
       
  1868                    is_const=True)
  1014     ## ethernet-header.h: static ns3::TypeId ns3::EthernetHeader::GetTypeId() [member function]
  1869     ## ethernet-header.h: static ns3::TypeId ns3::EthernetHeader::GetTypeId() [member function]
  1015     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
  1870     cls.add_method('GetTypeId', 
       
  1871                    'ns3::TypeId', 
       
  1872                    [], 
       
  1873                    is_static=True)
  1016     ## ethernet-header.h: ns3::TypeId ns3::EthernetHeader::GetInstanceTypeId() const [member function]
  1874     ## ethernet-header.h: ns3::TypeId ns3::EthernetHeader::GetInstanceTypeId() const [member function]
  1017     cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True)
  1875     cls.add_method('GetInstanceTypeId', 
       
  1876                    'ns3::TypeId', 
       
  1877                    [], 
       
  1878                    is_const=True, is_virtual=True)
  1018     ## ethernet-header.h: void ns3::EthernetHeader::Print(std::ostream & os) const [member function]
  1879     ## ethernet-header.h: void ns3::EthernetHeader::Print(std::ostream & os) const [member function]
  1019     cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True, is_virtual=True)
  1880     cls.add_method('Print', 
       
  1881                    'void', 
       
  1882                    [param('std::ostream&', 'os')], 
       
  1883                    is_const=True, is_virtual=True)
  1020     ## ethernet-header.h: uint32_t ns3::EthernetHeader::GetSerializedSize() const [member function]
  1884     ## ethernet-header.h: uint32_t ns3::EthernetHeader::GetSerializedSize() const [member function]
  1021     cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True, is_virtual=True)
  1885     cls.add_method('GetSerializedSize', 
       
  1886                    'uint32_t', 
       
  1887                    [], 
       
  1888                    is_const=True, is_virtual=True)
  1022     ## ethernet-header.h: void ns3::EthernetHeader::Serialize(ns3::Buffer::Iterator start) const [member function]
  1889     ## ethernet-header.h: void ns3::EthernetHeader::Serialize(ns3::Buffer::Iterator start) const [member function]
  1023     cls.add_method('Serialize', 'void', [param('ns3::Buffer::Iterator', 'start')], is_const=True, is_virtual=True)
  1890     cls.add_method('Serialize', 
       
  1891                    'void', 
       
  1892                    [param('ns3::Buffer::Iterator', 'start')], 
       
  1893                    is_const=True, is_virtual=True)
  1024     ## ethernet-header.h: uint32_t ns3::EthernetHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
  1894     ## ethernet-header.h: uint32_t ns3::EthernetHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
  1025     cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'start')], is_virtual=True)
  1895     cls.add_method('Deserialize', 
       
  1896                    'uint32_t', 
       
  1897                    [param('ns3::Buffer::Iterator', 'start')], 
       
  1898                    is_virtual=True)
  1026     return
  1899     return
  1027 
  1900 
  1028 def register_Ns3SocketIpTtlTag_methods(root_module, cls):
  1901 def register_Ns3SocketIpTtlTag_methods(root_module, cls):
  1029     ## socket.h: ns3::SocketIpTtlTag::SocketIpTtlTag() [constructor]
  1902     ## socket.h: ns3::SocketIpTtlTag::SocketIpTtlTag() [constructor]
  1030     cls.add_constructor([], visibility='public')
  1903     cls.add_constructor([])
  1031     ## socket.h: void ns3::SocketIpTtlTag::SetTtl(uint8_t ttl) [member function]
  1904     ## socket.h: void ns3::SocketIpTtlTag::SetTtl(uint8_t ttl) [member function]
  1032     cls.add_method('SetTtl', 'void', [param('uint8_t', 'ttl')])
  1905     cls.add_method('SetTtl', 
       
  1906                    'void', 
       
  1907                    [param('uint8_t', 'ttl')])
  1033     ## socket.h: uint8_t ns3::SocketIpTtlTag::GetTtl() const [member function]
  1908     ## socket.h: uint8_t ns3::SocketIpTtlTag::GetTtl() const [member function]
  1034     cls.add_method('GetTtl', 'uint8_t', [], is_const=True)
  1909     cls.add_method('GetTtl', 
       
  1910                    'uint8_t', 
       
  1911                    [], 
       
  1912                    is_const=True)
  1035     ## socket.h: static ns3::TypeId ns3::SocketIpTtlTag::GetTypeId() [member function]
  1913     ## socket.h: static ns3::TypeId ns3::SocketIpTtlTag::GetTypeId() [member function]
  1036     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
  1914     cls.add_method('GetTypeId', 
       
  1915                    'ns3::TypeId', 
       
  1916                    [], 
       
  1917                    is_static=True)
  1037     ## socket.h: ns3::TypeId ns3::SocketIpTtlTag::GetInstanceTypeId() const [member function]
  1918     ## socket.h: ns3::TypeId ns3::SocketIpTtlTag::GetInstanceTypeId() const [member function]
  1038     cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True)
  1919     cls.add_method('GetInstanceTypeId', 
       
  1920                    'ns3::TypeId', 
       
  1921                    [], 
       
  1922                    is_const=True, is_virtual=True)
  1039     ## socket.h: uint32_t ns3::SocketIpTtlTag::GetSerializedSize() const [member function]
  1923     ## socket.h: uint32_t ns3::SocketIpTtlTag::GetSerializedSize() const [member function]
  1040     cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True, is_virtual=True)
  1924     cls.add_method('GetSerializedSize', 
       
  1925                    'uint32_t', 
       
  1926                    [], 
       
  1927                    is_const=True, is_virtual=True)
  1041     ## socket.h: void ns3::SocketIpTtlTag::Serialize(ns3::TagBuffer i) const [member function]
  1928     ## socket.h: void ns3::SocketIpTtlTag::Serialize(ns3::TagBuffer i) const [member function]
  1042     cls.add_method('Serialize', 'void', [param('ns3::TagBuffer', 'i')], is_const=True, is_virtual=True)
  1929     cls.add_method('Serialize', 
       
  1930                    'void', 
       
  1931                    [param('ns3::TagBuffer', 'i')], 
       
  1932                    is_const=True, is_virtual=True)
  1043     ## socket.h: void ns3::SocketIpTtlTag::Deserialize(ns3::TagBuffer i) [member function]
  1933     ## socket.h: void ns3::SocketIpTtlTag::Deserialize(ns3::TagBuffer i) [member function]
  1044     cls.add_method('Deserialize', 'void', [param('ns3::TagBuffer', 'i')], is_virtual=True)
  1934     cls.add_method('Deserialize', 
       
  1935                    'void', 
       
  1936                    [param('ns3::TagBuffer', 'i')], 
       
  1937                    is_virtual=True)
  1045     ## socket.h: void ns3::SocketIpTtlTag::Print(std::ostream & os) const [member function]
  1938     ## socket.h: void ns3::SocketIpTtlTag::Print(std::ostream & os) const [member function]
  1046     cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True, is_virtual=True)
  1939     cls.add_method('Print', 
       
  1940                    'void', 
       
  1941                    [param('std::ostream&', 'os')], 
       
  1942                    is_const=True, is_virtual=True)
  1047     return
  1943     return
  1048 
  1944 
  1049 def register_Ns3Ipv4_methods(root_module, cls):
  1945 def register_Ns3Ipv4_methods(root_module, cls):
  1050     ## ipv4.h: static ns3::TypeId ns3::Ipv4::GetTypeId() [member function]
  1946     ## ipv4.h: static ns3::TypeId ns3::Ipv4::GetTypeId() [member function]
  1051     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
  1947     cls.add_method('GetTypeId', 
       
  1948                    'ns3::TypeId', 
       
  1949                    [], 
       
  1950                    is_static=True)
  1052     ## ipv4.h: ns3::Ipv4::Ipv4() [constructor]
  1951     ## ipv4.h: ns3::Ipv4::Ipv4() [constructor]
  1053     cls.add_constructor([], visibility='public')
  1952     cls.add_constructor([])
  1054     ## ipv4.h: void ns3::Ipv4::AddRoutingProtocol(ns3::Ptr<ns3::Ipv4RoutingProtocol> routingProtocol, int16_t priority) [member function]
  1953     ## ipv4.h: void ns3::Ipv4::AddRoutingProtocol(ns3::Ptr<ns3::Ipv4RoutingProtocol> routingProtocol, int16_t priority) [member function]
  1055     cls.add_method('AddRoutingProtocol', 'void', [param('ns3::Ptr< ns3::Ipv4RoutingProtocol >', 'routingProtocol'), param('int16_t', 'priority')], is_pure_virtual=True, is_virtual=True)
  1954     cls.add_method('AddRoutingProtocol', 
       
  1955                    'void', 
       
  1956                    [param('ns3::Ptr< ns3::Ipv4RoutingProtocol >', 'routingProtocol'), param('int16_t', 'priority')], 
       
  1957                    is_pure_virtual=True, is_virtual=True)
  1056     ## ipv4.h: void ns3::Ipv4::AddHostRouteTo(ns3::Ipv4Address dest, ns3::Ipv4Address nextHop, uint32_t interface) [member function]
  1958     ## ipv4.h: void ns3::Ipv4::AddHostRouteTo(ns3::Ipv4Address dest, ns3::Ipv4Address nextHop, uint32_t interface) [member function]
  1057     cls.add_method('AddHostRouteTo', 'void', [param('ns3::Ipv4Address', 'dest'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], is_pure_virtual=True, is_virtual=True)
  1959     cls.add_method('AddHostRouteTo', 
       
  1960                    'void', 
       
  1961                    [param('ns3::Ipv4Address', 'dest'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], 
       
  1962                    is_pure_virtual=True, is_virtual=True)
  1058     ## ipv4.h: void ns3::Ipv4::AddHostRouteTo(ns3::Ipv4Address dest, uint32_t interface) [member function]
  1963     ## ipv4.h: void ns3::Ipv4::AddHostRouteTo(ns3::Ipv4Address dest, uint32_t interface) [member function]
  1059     cls.add_method('AddHostRouteTo', 'void', [param('ns3::Ipv4Address', 'dest'), param('uint32_t', 'interface')], is_pure_virtual=True, is_virtual=True)
  1964     cls.add_method('AddHostRouteTo', 
       
  1965                    'void', 
       
  1966                    [param('ns3::Ipv4Address', 'dest'), param('uint32_t', 'interface')], 
       
  1967                    is_pure_virtual=True, is_virtual=True)
  1060     ## ipv4.h: void ns3::Ipv4::AddNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, ns3::Ipv4Address nextHop, uint32_t interface) [member function]
  1968     ## ipv4.h: void ns3::Ipv4::AddNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, ns3::Ipv4Address nextHop, uint32_t interface) [member function]
  1061     cls.add_method('AddNetworkRouteTo', 'void', [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], is_pure_virtual=True, is_virtual=True)
  1969     cls.add_method('AddNetworkRouteTo', 
       
  1970                    'void', 
       
  1971                    [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], 
       
  1972                    is_pure_virtual=True, is_virtual=True)
  1062     ## ipv4.h: void ns3::Ipv4::AddNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, uint32_t interface) [member function]
  1973     ## ipv4.h: void ns3::Ipv4::AddNetworkRouteTo(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask, uint32_t interface) [member function]
  1063     cls.add_method('AddNetworkRouteTo', 'void', [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('uint32_t', 'interface')], is_pure_virtual=True, is_virtual=True)
  1974     cls.add_method('AddNetworkRouteTo', 
       
  1975                    'void', 
       
  1976                    [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('uint32_t', 'interface')], 
       
  1977                    is_pure_virtual=True, is_virtual=True)
  1064     ## ipv4.h: void ns3::Ipv4::SetDefaultRoute(ns3::Ipv4Address nextHop, uint32_t interface) [member function]
  1978     ## ipv4.h: void ns3::Ipv4::SetDefaultRoute(ns3::Ipv4Address nextHop, uint32_t interface) [member function]
  1065     cls.add_method('SetDefaultRoute', 'void', [param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], is_pure_virtual=True, is_virtual=True)
  1979     cls.add_method('SetDefaultRoute', 
       
  1980                    'void', 
       
  1981                    [param('ns3::Ipv4Address', 'nextHop'), param('uint32_t', 'interface')], 
       
  1982                    is_pure_virtual=True, is_virtual=True)
  1066     ## ipv4.h: uint32_t ns3::Ipv4::GetNRoutes() [member function]
  1983     ## ipv4.h: uint32_t ns3::Ipv4::GetNRoutes() [member function]
  1067     cls.add_method('GetNRoutes', 'uint32_t', [], is_pure_virtual=True, is_virtual=True)
  1984     cls.add_method('GetNRoutes', 
       
  1985                    'uint32_t', 
       
  1986                    [], 
       
  1987                    is_pure_virtual=True, is_virtual=True)
  1068     ## ipv4.h: ns3::Ipv4Route ns3::Ipv4::GetRoute(uint32_t i) [member function]
  1988     ## ipv4.h: ns3::Ipv4Route ns3::Ipv4::GetRoute(uint32_t i) [member function]
  1069     cls.add_method('GetRoute', 'ns3::Ipv4Route', [param('uint32_t', 'i')], is_pure_virtual=True, is_virtual=True)
  1989     cls.add_method('GetRoute', 
       
  1990                    'ns3::Ipv4Route', 
       
  1991                    [param('uint32_t', 'i')], 
       
  1992                    is_pure_virtual=True, is_virtual=True)
  1070     ## ipv4.h: void ns3::Ipv4::RemoveRoute(uint32_t i) [member function]
  1993     ## ipv4.h: void ns3::Ipv4::RemoveRoute(uint32_t i) [member function]
  1071     cls.add_method('RemoveRoute', 'void', [param('uint32_t', 'i')], is_pure_virtual=True, is_virtual=True)
  1994     cls.add_method('RemoveRoute', 
       
  1995                    'void', 
       
  1996                    [param('uint32_t', 'i')], 
       
  1997                    is_pure_virtual=True, is_virtual=True)
  1072     ## 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]
  1998     ## 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]
  1073     cls.add_method('AddMulticastRoute', 'void', [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int, std::allocator< unsigned int > >', 'outputInterfaces')], is_pure_virtual=True, is_virtual=True)
  1999     cls.add_method('AddMulticastRoute', 
       
  2000                    'void', 
       
  2001                    [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface'), param('std::vector< unsigned int, std::allocator< unsigned int > >', 'outputInterfaces')], 
       
  2002                    is_pure_virtual=True, is_virtual=True)
  1074     ## ipv4.h: void ns3::Ipv4::RemoveMulticastRoute(ns3::Ipv4Address origin, ns3::Ipv4Address group, uint32_t inputInterface) [member function]
  2003     ## ipv4.h: void ns3::Ipv4::RemoveMulticastRoute(ns3::Ipv4Address origin, ns3::Ipv4Address group, uint32_t inputInterface) [member function]
  1075     cls.add_method('RemoveMulticastRoute', 'void', [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface')], is_pure_virtual=True, is_virtual=True)
  2004     cls.add_method('RemoveMulticastRoute', 
       
  2005                    'void', 
       
  2006                    [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group'), param('uint32_t', 'inputInterface')], 
       
  2007                    is_pure_virtual=True, is_virtual=True)
  1076     ## ipv4.h: void ns3::Ipv4::SetDefaultMulticastRoute(uint32_t outputInterface) [member function]
  2008     ## ipv4.h: void ns3::Ipv4::SetDefaultMulticastRoute(uint32_t outputInterface) [member function]
  1077     cls.add_method('SetDefaultMulticastRoute', 'void', [param('uint32_t', 'outputInterface')], is_pure_virtual=True, is_virtual=True)
  2009     cls.add_method('SetDefaultMulticastRoute', 
       
  2010                    'void', 
       
  2011                    [param('uint32_t', 'outputInterface')], 
       
  2012                    is_pure_virtual=True, is_virtual=True)
  1078     ## ipv4.h: uint32_t ns3::Ipv4::GetNMulticastRoutes() const [member function]
  2013     ## ipv4.h: uint32_t ns3::Ipv4::GetNMulticastRoutes() const [member function]
  1079     cls.add_method('GetNMulticastRoutes', 'uint32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True)
  2014     cls.add_method('GetNMulticastRoutes', 
       
  2015                    'uint32_t', 
       
  2016                    [], 
       
  2017                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1080     ## ipv4.h: ns3::Ipv4MulticastRoute ns3::Ipv4::GetMulticastRoute(uint32_t i) const [member function]
  2018     ## ipv4.h: ns3::Ipv4MulticastRoute ns3::Ipv4::GetMulticastRoute(uint32_t i) const [member function]
  1081     cls.add_method('GetMulticastRoute', 'ns3::Ipv4MulticastRoute', [param('uint32_t', 'i')], is_pure_virtual=True, is_const=True, is_virtual=True)
  2019     cls.add_method('GetMulticastRoute', 
       
  2020                    'ns3::Ipv4MulticastRoute', 
       
  2021                    [param('uint32_t', 'i')], 
       
  2022                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1082     ## ipv4.h: void ns3::Ipv4::RemoveMulticastRoute(uint32_t i) [member function]
  2023     ## ipv4.h: void ns3::Ipv4::RemoveMulticastRoute(uint32_t i) [member function]
  1083     cls.add_method('RemoveMulticastRoute', 'void', [param('uint32_t', 'i')], is_pure_virtual=True, is_virtual=True)
  2024     cls.add_method('RemoveMulticastRoute', 
       
  2025                    'void', 
       
  2026                    [param('uint32_t', 'i')], 
       
  2027                    is_pure_virtual=True, is_virtual=True)
  1084     ## ipv4.h: uint32_t ns3::Ipv4::AddInterface(ns3::Ptr<ns3::NetDevice> device) [member function]
  2028     ## ipv4.h: uint32_t ns3::Ipv4::AddInterface(ns3::Ptr<ns3::NetDevice> device) [member function]
  1085     cls.add_method('AddInterface', 'uint32_t', [param('ns3::Ptr< ns3::NetDevice >', 'device')], is_pure_virtual=True, is_virtual=True)
  2029     cls.add_method('AddInterface', 
       
  2030                    'uint32_t', 
       
  2031                    [param('ns3::Ptr< ns3::NetDevice >', 'device')], 
       
  2032                    is_pure_virtual=True, is_virtual=True)
  1086     ## ipv4.h: uint32_t ns3::Ipv4::GetNInterfaces() [member function]
  2033     ## ipv4.h: uint32_t ns3::Ipv4::GetNInterfaces() [member function]
  1087     cls.add_method('GetNInterfaces', 'uint32_t', [], is_pure_virtual=True, is_virtual=True)
  2034     cls.add_method('GetNInterfaces', 
       
  2035                    'uint32_t', 
       
  2036                    [], 
       
  2037                    is_pure_virtual=True, is_virtual=True)
  1088     ## ipv4.h: uint32_t ns3::Ipv4::FindInterfaceForAddr(ns3::Ipv4Address addr) const [member function]
  2038     ## ipv4.h: uint32_t ns3::Ipv4::FindInterfaceForAddr(ns3::Ipv4Address addr) const [member function]
  1089     cls.add_method('FindInterfaceForAddr', 'uint32_t', [param('ns3::Ipv4Address', 'addr')], is_pure_virtual=True, is_const=True, is_virtual=True)
  2039     cls.add_method('FindInterfaceForAddr', 
       
  2040                    'uint32_t', 
       
  2041                    [param('ns3::Ipv4Address', 'addr')], 
       
  2042                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1090     ## ipv4.h: uint32_t ns3::Ipv4::FindInterfaceForAddr(ns3::Ipv4Address addr, ns3::Ipv4Mask mask) const [member function]
  2043     ## ipv4.h: uint32_t ns3::Ipv4::FindInterfaceForAddr(ns3::Ipv4Address addr, ns3::Ipv4Mask mask) const [member function]
  1091     cls.add_method('FindInterfaceForAddr', 'uint32_t', [param('ns3::Ipv4Address', 'addr'), param('ns3::Ipv4Mask', 'mask')], is_pure_virtual=True, is_const=True, is_virtual=True)
  2044     cls.add_method('FindInterfaceForAddr', 
       
  2045                    'uint32_t', 
       
  2046                    [param('ns3::Ipv4Address', 'addr'), param('ns3::Ipv4Mask', 'mask')], 
       
  2047                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1092     ## ipv4.h: int32_t ns3::Ipv4::FindInterfaceForDevice(ns3::Ptr<ns3::NetDevice> nd) const [member function]
  2048     ## ipv4.h: int32_t ns3::Ipv4::FindInterfaceForDevice(ns3::Ptr<ns3::NetDevice> nd) const [member function]
  1093     cls.add_method('FindInterfaceForDevice', 'int32_t', [param('ns3::Ptr< ns3::NetDevice >', 'nd')], is_pure_virtual=True, is_const=True, is_virtual=True)
  2049     cls.add_method('FindInterfaceForDevice', 
       
  2050                    'int32_t', 
       
  2051                    [param('ns3::Ptr< ns3::NetDevice >', 'nd')], 
       
  2052                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1094     ## ipv4.h: ns3::Ptr<ns3::NetDevice> ns3::Ipv4::GetNetDevice(uint32_t i) [member function]
  2053     ## ipv4.h: ns3::Ptr<ns3::NetDevice> ns3::Ipv4::GetNetDevice(uint32_t i) [member function]
  1095     cls.add_method('GetNetDevice', 'ns3::Ptr< ns3::NetDevice >', [param('uint32_t', 'i')], is_pure_virtual=True, is_virtual=True)
  2054     cls.add_method('GetNetDevice', 
       
  2055                    'ns3::Ptr< ns3::NetDevice >', 
       
  2056                    [param('uint32_t', 'i')], 
       
  2057                    is_pure_virtual=True, is_virtual=True)
  1096     ## ipv4.h: void ns3::Ipv4::JoinMulticastGroup(ns3::Ipv4Address origin, ns3::Ipv4Address group) [member function]
  2058     ## ipv4.h: void ns3::Ipv4::JoinMulticastGroup(ns3::Ipv4Address origin, ns3::Ipv4Address group) [member function]
  1097     cls.add_method('JoinMulticastGroup', 'void', [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group')], is_pure_virtual=True, is_virtual=True)
  2059     cls.add_method('JoinMulticastGroup', 
       
  2060                    'void', 
       
  2061                    [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group')], 
       
  2062                    is_pure_virtual=True, is_virtual=True)
  1098     ## ipv4.h: void ns3::Ipv4::LeaveMulticastGroup(ns3::Ipv4Address origin, ns3::Ipv4Address group) [member function]
  2063     ## ipv4.h: void ns3::Ipv4::LeaveMulticastGroup(ns3::Ipv4Address origin, ns3::Ipv4Address group) [member function]
  1099     cls.add_method('LeaveMulticastGroup', 'void', [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group')], is_pure_virtual=True, is_virtual=True)
  2064     cls.add_method('LeaveMulticastGroup', 
       
  2065                    'void', 
       
  2066                    [param('ns3::Ipv4Address', 'origin'), param('ns3::Ipv4Address', 'group')], 
       
  2067                    is_pure_virtual=True, is_virtual=True)
  1100     ## ipv4.h: void ns3::Ipv4::SetAddress(uint32_t i, ns3::Ipv4Address address) [member function]
  2068     ## ipv4.h: void ns3::Ipv4::SetAddress(uint32_t i, ns3::Ipv4Address address) [member function]
  1101     cls.add_method('SetAddress', 'void', [param('uint32_t', 'i'), param('ns3::Ipv4Address', 'address')], is_pure_virtual=True, is_virtual=True)
  2069     cls.add_method('SetAddress', 
       
  2070                    'void', 
       
  2071                    [param('uint32_t', 'i'), param('ns3::Ipv4Address', 'address')], 
       
  2072                    is_pure_virtual=True, is_virtual=True)
  1102     ## ipv4.h: void ns3::Ipv4::SetNetworkMask(uint32_t i, ns3::Ipv4Mask mask) [member function]
  2073     ## ipv4.h: void ns3::Ipv4::SetNetworkMask(uint32_t i, ns3::Ipv4Mask mask) [member function]
  1103     cls.add_method('SetNetworkMask', 'void', [param('uint32_t', 'i'), param('ns3::Ipv4Mask', 'mask')], is_pure_virtual=True, is_virtual=True)
  2074     cls.add_method('SetNetworkMask', 
       
  2075                    'void', 
       
  2076                    [param('uint32_t', 'i'), param('ns3::Ipv4Mask', 'mask')], 
       
  2077                    is_pure_virtual=True, is_virtual=True)
  1104     ## ipv4.h: ns3::Ipv4Mask ns3::Ipv4::GetNetworkMask(uint32_t i) const [member function]
  2078     ## ipv4.h: ns3::Ipv4Mask ns3::Ipv4::GetNetworkMask(uint32_t i) const [member function]
  1105     cls.add_method('GetNetworkMask', 'ns3::Ipv4Mask', [param('uint32_t', 'i')], is_pure_virtual=True, is_const=True, is_virtual=True)
  2079     cls.add_method('GetNetworkMask', 
       
  2080                    'ns3::Ipv4Mask', 
       
  2081                    [param('uint32_t', 'i')], 
       
  2082                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1106     ## ipv4.h: void ns3::Ipv4::SetMetric(uint32_t i, uint16_t metric) [member function]
  2083     ## ipv4.h: void ns3::Ipv4::SetMetric(uint32_t i, uint16_t metric) [member function]
  1107     cls.add_method('SetMetric', 'void', [param('uint32_t', 'i'), param('uint16_t', 'metric')], is_pure_virtual=True, is_virtual=True)
  2084     cls.add_method('SetMetric', 
       
  2085                    'void', 
       
  2086                    [param('uint32_t', 'i'), param('uint16_t', 'metric')], 
       
  2087                    is_pure_virtual=True, is_virtual=True)
  1108     ## ipv4.h: uint16_t ns3::Ipv4::GetMetric(uint32_t i) const [member function]
  2088     ## ipv4.h: uint16_t ns3::Ipv4::GetMetric(uint32_t i) const [member function]
  1109     cls.add_method('GetMetric', 'uint16_t', [param('uint32_t', 'i')], is_pure_virtual=True, is_const=True, is_virtual=True)
  2089     cls.add_method('GetMetric', 
       
  2090                    'uint16_t', 
       
  2091                    [param('uint32_t', 'i')], 
       
  2092                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1110     ## ipv4.h: ns3::Ipv4Address ns3::Ipv4::GetAddress(uint32_t i) const [member function]
  2093     ## ipv4.h: ns3::Ipv4Address ns3::Ipv4::GetAddress(uint32_t i) const [member function]
  1111     cls.add_method('GetAddress', 'ns3::Ipv4Address', [param('uint32_t', 'i')], is_pure_virtual=True, is_const=True, is_virtual=True)
  2094     cls.add_method('GetAddress', 
       
  2095                    'ns3::Ipv4Address', 
       
  2096                    [param('uint32_t', 'i')], 
       
  2097                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1112     ## ipv4.h: ns3::Ipv4Address ns3::Ipv4::GetSourceAddress(ns3::Ipv4Address destination) const [member function]
  2098     ## ipv4.h: ns3::Ipv4Address ns3::Ipv4::GetSourceAddress(ns3::Ipv4Address destination) const [member function]
  1113     cls.add_method('GetSourceAddress', 'ns3::Ipv4Address', [param('ns3::Ipv4Address', 'destination')], is_pure_virtual=True, is_const=True, is_virtual=True)
  2099     cls.add_method('GetSourceAddress', 
       
  2100                    'ns3::Ipv4Address', 
       
  2101                    [param('ns3::Ipv4Address', 'destination')], 
       
  2102                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1114     ## ipv4.h: bool ns3::Ipv4::GetIfIndexForDestination(ns3::Ipv4Address dest, uint32_t & ifIndex) const [member function]
  2103     ## ipv4.h: bool ns3::Ipv4::GetIfIndexForDestination(ns3::Ipv4Address dest, uint32_t & ifIndex) const [member function]
  1115     cls.add_method('GetIfIndexForDestination', 'bool', [param('ns3::Ipv4Address', 'dest'), param('uint32_t&', 'ifIndex')], is_pure_virtual=True, is_const=True, is_virtual=True)
  2104     cls.add_method('GetIfIndexForDestination', 
       
  2105                    'bool', 
       
  2106                    [param('ns3::Ipv4Address', 'dest'), param('uint32_t&', 'ifIndex')], 
       
  2107                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1116     ## ipv4.h: uint16_t ns3::Ipv4::GetMtu(uint32_t i) const [member function]
  2108     ## ipv4.h: uint16_t ns3::Ipv4::GetMtu(uint32_t i) const [member function]
  1117     cls.add_method('GetMtu', 'uint16_t', [param('uint32_t', 'i')], is_pure_virtual=True, is_const=True, is_virtual=True)
  2109     cls.add_method('GetMtu', 
       
  2110                    'uint16_t', 
       
  2111                    [param('uint32_t', 'i')], 
       
  2112                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1118     ## ipv4.h: bool ns3::Ipv4::IsUp(uint32_t i) const [member function]
  2113     ## ipv4.h: bool ns3::Ipv4::IsUp(uint32_t i) const [member function]
  1119     cls.add_method('IsUp', 'bool', [param('uint32_t', 'i')], is_pure_virtual=True, is_const=True, is_virtual=True)
  2114     cls.add_method('IsUp', 
       
  2115                    'bool', 
       
  2116                    [param('uint32_t', 'i')], 
       
  2117                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1120     ## ipv4.h: void ns3::Ipv4::SetUp(uint32_t i) [member function]
  2118     ## ipv4.h: void ns3::Ipv4::SetUp(uint32_t i) [member function]
  1121     cls.add_method('SetUp', 'void', [param('uint32_t', 'i')], is_pure_virtual=True, is_virtual=True)
  2119     cls.add_method('SetUp', 
       
  2120                    'void', 
       
  2121                    [param('uint32_t', 'i')], 
       
  2122                    is_pure_virtual=True, is_virtual=True)
  1122     ## ipv4.h: void ns3::Ipv4::SetDown(uint32_t i) [member function]
  2123     ## ipv4.h: void ns3::Ipv4::SetDown(uint32_t i) [member function]
  1123     cls.add_method('SetDown', 'void', [param('uint32_t', 'i')], is_pure_virtual=True, is_virtual=True)
  2124     cls.add_method('SetDown', 
       
  2125                    'void', 
       
  2126                    [param('uint32_t', 'i')], 
       
  2127                    is_pure_virtual=True, is_virtual=True)
  1124     ## ipv4.h: uint32_t ns3::Ipv4::GetIfIndexByAddress(ns3::Ipv4Address addr, ns3::Ipv4Mask mask=ns3::Ipv4Mask(((const char*)"255.255.255.255"))) [member function]
  2128     ## ipv4.h: uint32_t ns3::Ipv4::GetIfIndexByAddress(ns3::Ipv4Address addr, ns3::Ipv4Mask mask=ns3::Ipv4Mask(((const char*)"255.255.255.255"))) [member function]
  1125     cls.add_method('GetIfIndexByAddress', 'uint32_t', [param('ns3::Ipv4Address', 'addr'), param('ns3::Ipv4Mask', 'mask', default_value='ns3::Ipv4Mask(((const char*)"255.255.255.255"))')], is_virtual=True)
  2129     cls.add_method('GetIfIndexByAddress', 
       
  2130                    'uint32_t', 
       
  2131                    [param('ns3::Ipv4Address', 'addr'), param('ns3::Ipv4Mask', 'mask', default_value='ns3::Ipv4Mask(((const char*)"255.255.255.255"))')], 
       
  2132                    is_virtual=True)
  1126     return
  2133     return
  1127 
  2134 
  1128 def register_Ns3SocketFactory_methods(root_module, cls):
  2135 def register_Ns3SocketFactory_methods(root_module, cls):
  1129     ## socket-factory.h: static ns3::TypeId ns3::SocketFactory::GetTypeId() [member function]
  2136     ## socket-factory.h: static ns3::TypeId ns3::SocketFactory::GetTypeId() [member function]
  1130     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
  2137     cls.add_method('GetTypeId', 
       
  2138                    'ns3::TypeId', 
       
  2139                    [], 
       
  2140                    is_static=True)
  1131     ## socket-factory.h: ns3::SocketFactory::SocketFactory() [constructor]
  2141     ## socket-factory.h: ns3::SocketFactory::SocketFactory() [constructor]
  1132     cls.add_constructor([], visibility='public')
  2142     cls.add_constructor([])
  1133     ## socket-factory.h: ns3::Ptr<ns3::Socket> ns3::SocketFactory::CreateSocket() [member function]
  2143     ## socket-factory.h: ns3::Ptr<ns3::Socket> ns3::SocketFactory::CreateSocket() [member function]
  1134     cls.add_method('CreateSocket', 'ns3::Ptr< ns3::Socket >', [], is_pure_virtual=True, is_virtual=True)
  2144     cls.add_method('CreateSocket', 
       
  2145                    'ns3::Ptr< ns3::Socket >', 
       
  2146                    [], 
       
  2147                    is_pure_virtual=True, is_virtual=True)
  1135     return
  2148     return
  1136 
  2149 
  1137 def register_Ns3DropTailQueue_methods(root_module, cls):
  2150 def register_Ns3DropTailQueue_methods(root_module, cls):
  1138     ## drop-tail-queue.h: static ns3::TypeId ns3::DropTailQueue::GetTypeId() [member function]
  2151     ## drop-tail-queue.h: static ns3::TypeId ns3::DropTailQueue::GetTypeId() [member function]
  1139     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
  2152     cls.add_method('GetTypeId', 
       
  2153                    'ns3::TypeId', 
       
  2154                    [], 
       
  2155                    is_static=True)
  1140     ## drop-tail-queue.h: ns3::DropTailQueue::DropTailQueue() [constructor]
  2156     ## drop-tail-queue.h: ns3::DropTailQueue::DropTailQueue() [constructor]
  1141     cls.add_constructor([], visibility='public')
  2157     cls.add_constructor([])
  1142     ## drop-tail-queue.h: bool ns3::DropTailQueue::DoEnqueue(ns3::Ptr<ns3::Packet> p) [member function]
  2158     ## drop-tail-queue.h: bool ns3::DropTailQueue::DoEnqueue(ns3::Ptr<ns3::Packet> p) [member function]
  1143     cls.add_method('DoEnqueue', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p')], visibility='private', is_virtual=True)
  2159     cls.add_method('DoEnqueue', 
       
  2160                    'bool', 
       
  2161                    [param('ns3::Ptr< ns3::Packet >', 'p')], 
       
  2162                    visibility='private', is_virtual=True)
  1144     ## drop-tail-queue.h: ns3::Ptr<ns3::Packet> ns3::DropTailQueue::DoDequeue() [member function]
  2163     ## drop-tail-queue.h: ns3::Ptr<ns3::Packet> ns3::DropTailQueue::DoDequeue() [member function]
  1145     cls.add_method('DoDequeue', 'ns3::Ptr< ns3::Packet >', [], visibility='private', is_virtual=True)
  2164     cls.add_method('DoDequeue', 
       
  2165                    'ns3::Ptr< ns3::Packet >', 
       
  2166                    [], 
       
  2167                    visibility='private', is_virtual=True)
  1146     ## drop-tail-queue.h: ns3::Ptr<ns3::Packet> ns3::DropTailQueue::DoPeek() const [member function]
  2168     ## drop-tail-queue.h: ns3::Ptr<ns3::Packet> ns3::DropTailQueue::DoPeek() const [member function]
  1147     cls.add_method('DoPeek', 'ns3::Ptr< ns3::Packet >', [], is_const=True, visibility='private', is_virtual=True)
  2169     cls.add_method('DoPeek', 
       
  2170                    'ns3::Ptr< ns3::Packet >', 
       
  2171                    [], 
       
  2172                    is_const=True, visibility='private', is_virtual=True)
  1148     return
  2173     return
  1149 
  2174 
  1150 def register_Ns3EthernetTrailer_methods(root_module, cls):
  2175 def register_Ns3EthernetTrailer_methods(root_module, cls):
  1151     ## ethernet-trailer.h: ns3::EthernetTrailer::EthernetTrailer() [constructor]
  2176     ## ethernet-trailer.h: ns3::EthernetTrailer::EthernetTrailer() [constructor]
  1152     cls.add_constructor([], visibility='public')
  2177     cls.add_constructor([])
  1153     ## ethernet-trailer.h: static void ns3::EthernetTrailer::EnableFcs(bool enable) [member function]
  2178     ## ethernet-trailer.h: static void ns3::EthernetTrailer::EnableFcs(bool enable) [member function]
  1154     cls.add_method('EnableFcs', 'void', [param('bool', 'enable')], is_static=True)
  2179     cls.add_method('EnableFcs', 
       
  2180                    'void', 
       
  2181                    [param('bool', 'enable')], 
       
  2182                    is_static=True)
  1155     ## ethernet-trailer.h: void ns3::EthernetTrailer::CalcFcs(ns3::Ptr<ns3::Packet> p) [member function]
  2183     ## ethernet-trailer.h: void ns3::EthernetTrailer::CalcFcs(ns3::Ptr<ns3::Packet> p) [member function]
  1156     cls.add_method('CalcFcs', 'void', [param('ns3::Ptr< ns3::Packet >', 'p')])
  2184     cls.add_method('CalcFcs', 
       
  2185                    'void', 
       
  2186                    [param('ns3::Ptr< ns3::Packet >', 'p')])
  1157     ## ethernet-trailer.h: void ns3::EthernetTrailer::SetFcs(uint32_t fcs) [member function]
  2187     ## ethernet-trailer.h: void ns3::EthernetTrailer::SetFcs(uint32_t fcs) [member function]
  1158     cls.add_method('SetFcs', 'void', [param('uint32_t', 'fcs')])
  2188     cls.add_method('SetFcs', 
       
  2189                    'void', 
       
  2190                    [param('uint32_t', 'fcs')])
  1159     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::GetFcs() [member function]
  2191     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::GetFcs() [member function]
  1160     cls.add_method('GetFcs', 'uint32_t', [])
  2192     cls.add_method('GetFcs', 
       
  2193                    'uint32_t', 
       
  2194                    [])
  1161     ## ethernet-trailer.h: bool ns3::EthernetTrailer::CheckFcs(ns3::Ptr<ns3::Packet> p) const [member function]
  2195     ## ethernet-trailer.h: bool ns3::EthernetTrailer::CheckFcs(ns3::Ptr<ns3::Packet> p) const [member function]
  1162     cls.add_method('CheckFcs', 'bool', [param('ns3::Ptr< ns3::Packet >', 'p')], is_const=True)
  2196     cls.add_method('CheckFcs', 
       
  2197                    'bool', 
       
  2198                    [param('ns3::Ptr< ns3::Packet >', 'p')], 
       
  2199                    is_const=True)
  1163     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::GetTrailerSize() const [member function]
  2200     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::GetTrailerSize() const [member function]
  1164     cls.add_method('GetTrailerSize', 'uint32_t', [], is_const=True)
  2201     cls.add_method('GetTrailerSize', 
       
  2202                    'uint32_t', 
       
  2203                    [], 
       
  2204                    is_const=True)
  1165     ## ethernet-trailer.h: static ns3::TypeId ns3::EthernetTrailer::GetTypeId() [member function]
  2205     ## ethernet-trailer.h: static ns3::TypeId ns3::EthernetTrailer::GetTypeId() [member function]
  1166     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
  2206     cls.add_method('GetTypeId', 
       
  2207                    'ns3::TypeId', 
       
  2208                    [], 
       
  2209                    is_static=True)
  1167     ## ethernet-trailer.h: ns3::TypeId ns3::EthernetTrailer::GetInstanceTypeId() const [member function]
  2210     ## ethernet-trailer.h: ns3::TypeId ns3::EthernetTrailer::GetInstanceTypeId() const [member function]
  1168     cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True)
  2211     cls.add_method('GetInstanceTypeId', 
       
  2212                    'ns3::TypeId', 
       
  2213                    [], 
       
  2214                    is_const=True, is_virtual=True)
  1169     ## ethernet-trailer.h: void ns3::EthernetTrailer::Print(std::ostream & os) const [member function]
  2215     ## ethernet-trailer.h: void ns3::EthernetTrailer::Print(std::ostream & os) const [member function]
  1170     cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True, is_virtual=True)
  2216     cls.add_method('Print', 
       
  2217                    'void', 
       
  2218                    [param('std::ostream&', 'os')], 
       
  2219                    is_const=True, is_virtual=True)
  1171     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::GetSerializedSize() const [member function]
  2220     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::GetSerializedSize() const [member function]
  1172     cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True, is_virtual=True)
  2221     cls.add_method('GetSerializedSize', 
       
  2222                    'uint32_t', 
       
  2223                    [], 
       
  2224                    is_const=True, is_virtual=True)
  1173     ## ethernet-trailer.h: void ns3::EthernetTrailer::Serialize(ns3::Buffer::Iterator end) const [member function]
  2225     ## ethernet-trailer.h: void ns3::EthernetTrailer::Serialize(ns3::Buffer::Iterator end) const [member function]
  1174     cls.add_method('Serialize', 'void', [param('ns3::Buffer::Iterator', 'end')], is_const=True, is_virtual=True)
  2226     cls.add_method('Serialize', 
       
  2227                    'void', 
       
  2228                    [param('ns3::Buffer::Iterator', 'end')], 
       
  2229                    is_const=True, is_virtual=True)
  1175     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::Deserialize(ns3::Buffer::Iterator end) [member function]
  2230     ## ethernet-trailer.h: uint32_t ns3::EthernetTrailer::Deserialize(ns3::Buffer::Iterator end) [member function]
  1176     cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'end')], is_virtual=True)
  2231     cls.add_method('Deserialize', 
       
  2232                    'uint32_t', 
       
  2233                    [param('ns3::Buffer::Iterator', 'end')], 
       
  2234                    is_virtual=True)
  1177     return
  2235     return
  1178 
  2236 
  1179 def register_Ns3LlcSnapHeader_methods(root_module, cls):
  2237 def register_Ns3LlcSnapHeader_methods(root_module, cls):
  1180     ## llc-snap-header.h: ns3::LlcSnapHeader::LlcSnapHeader() [constructor]
  2238     ## llc-snap-header.h: ns3::LlcSnapHeader::LlcSnapHeader() [constructor]
  1181     cls.add_constructor([], visibility='public')
  2239     cls.add_constructor([])
  1182     ## llc-snap-header.h: void ns3::LlcSnapHeader::SetType(uint16_t type) [member function]
  2240     ## llc-snap-header.h: void ns3::LlcSnapHeader::SetType(uint16_t type) [member function]
  1183     cls.add_method('SetType', 'void', [param('uint16_t', 'type')])
  2241     cls.add_method('SetType', 
       
  2242                    'void', 
       
  2243                    [param('uint16_t', 'type')])
  1184     ## llc-snap-header.h: uint16_t ns3::LlcSnapHeader::GetType() [member function]
  2244     ## llc-snap-header.h: uint16_t ns3::LlcSnapHeader::GetType() [member function]
  1185     cls.add_method('GetType', 'uint16_t', [])
  2245     cls.add_method('GetType', 
       
  2246                    'uint16_t', 
       
  2247                    [])
  1186     ## llc-snap-header.h: static ns3::TypeId ns3::LlcSnapHeader::GetTypeId() [member function]
  2248     ## llc-snap-header.h: static ns3::TypeId ns3::LlcSnapHeader::GetTypeId() [member function]
  1187     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
  2249     cls.add_method('GetTypeId', 
       
  2250                    'ns3::TypeId', 
       
  2251                    [], 
       
  2252                    is_static=True)
  1188     ## llc-snap-header.h: ns3::TypeId ns3::LlcSnapHeader::GetInstanceTypeId() const [member function]
  2253     ## llc-snap-header.h: ns3::TypeId ns3::LlcSnapHeader::GetInstanceTypeId() const [member function]
  1189     cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True)
  2254     cls.add_method('GetInstanceTypeId', 
       
  2255                    'ns3::TypeId', 
       
  2256                    [], 
       
  2257                    is_const=True, is_virtual=True)
  1190     ## llc-snap-header.h: void ns3::LlcSnapHeader::Print(std::ostream & os) const [member function]
  2258     ## llc-snap-header.h: void ns3::LlcSnapHeader::Print(std::ostream & os) const [member function]
  1191     cls.add_method('Print', 'void', [param('std::ostream&', 'os')], is_const=True, is_virtual=True)
  2259     cls.add_method('Print', 
       
  2260                    'void', 
       
  2261                    [param('std::ostream&', 'os')], 
       
  2262                    is_const=True, is_virtual=True)
  1192     ## llc-snap-header.h: uint32_t ns3::LlcSnapHeader::GetSerializedSize() const [member function]
  2263     ## llc-snap-header.h: uint32_t ns3::LlcSnapHeader::GetSerializedSize() const [member function]
  1193     cls.add_method('GetSerializedSize', 'uint32_t', [], is_const=True, is_virtual=True)
  2264     cls.add_method('GetSerializedSize', 
       
  2265                    'uint32_t', 
       
  2266                    [], 
       
  2267                    is_const=True, is_virtual=True)
  1194     ## llc-snap-header.h: void ns3::LlcSnapHeader::Serialize(ns3::Buffer::Iterator start) const [member function]
  2268     ## llc-snap-header.h: void ns3::LlcSnapHeader::Serialize(ns3::Buffer::Iterator start) const [member function]
  1195     cls.add_method('Serialize', 'void', [param('ns3::Buffer::Iterator', 'start')], is_const=True, is_virtual=True)
  2269     cls.add_method('Serialize', 
       
  2270                    'void', 
       
  2271                    [param('ns3::Buffer::Iterator', 'start')], 
       
  2272                    is_const=True, is_virtual=True)
  1196     ## llc-snap-header.h: uint32_t ns3::LlcSnapHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
  2273     ## llc-snap-header.h: uint32_t ns3::LlcSnapHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
  1197     cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'start')], is_virtual=True)
  2274     cls.add_method('Deserialize', 
       
  2275                    'uint32_t', 
       
  2276                    [param('ns3::Buffer::Iterator', 'start')], 
       
  2277                    is_virtual=True)
  1198     return
  2278     return
  1199 
  2279 
  1200 def register_Ns3UdpSocketFactory_methods(root_module, cls):
  2280 def register_Ns3UdpSocketFactory_methods(root_module, cls):
  1201     ## udp-socket-factory.h: static ns3::TypeId ns3::UdpSocketFactory::GetTypeId() [member function]
  2281     ## udp-socket-factory.h: static ns3::TypeId ns3::UdpSocketFactory::GetTypeId() [member function]
  1202     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
  2282     cls.add_method('GetTypeId', 
       
  2283                    'ns3::TypeId', 
       
  2284                    [], 
       
  2285                    is_static=True)
  1203     cls.add_constructor([])
  2286     cls.add_constructor([])
  1204     return
  2287     return
  1205 
  2288 
  1206 def register_Ns3SimpleNetDevice_methods(root_module, cls):
  2289 def register_Ns3SimpleNetDevice_methods(root_module, cls):
  1207     ## simple-net-device.h: static ns3::TypeId ns3::SimpleNetDevice::GetTypeId() [member function]
  2290     ## simple-net-device.h: static ns3::TypeId ns3::SimpleNetDevice::GetTypeId() [member function]
  1208     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
  2291     cls.add_method('GetTypeId', 
       
  2292                    'ns3::TypeId', 
       
  2293                    [], 
       
  2294                    is_static=True)
  1209     ## simple-net-device.h: ns3::SimpleNetDevice::SimpleNetDevice() [constructor]
  2295     ## simple-net-device.h: ns3::SimpleNetDevice::SimpleNetDevice() [constructor]
  1210     cls.add_constructor([], visibility='public')
  2296     cls.add_constructor([])
  1211     ## simple-net-device.h: void ns3::SimpleNetDevice::Receive(ns3::Ptr<ns3::Packet> packet, uint16_t protocol, ns3::Mac48Address to, ns3::Mac48Address from) [member function]
  2297     ## simple-net-device.h: void ns3::SimpleNetDevice::Receive(ns3::Ptr<ns3::Packet> packet, uint16_t protocol, ns3::Mac48Address to, ns3::Mac48Address from) [member function]
  1212     cls.add_method('Receive', 'void', [param('ns3::Ptr< ns3::Packet >', 'packet'), param('uint16_t', 'protocol'), param('ns3::Mac48Address', 'to'), param('ns3::Mac48Address', 'from')])
  2298     cls.add_method('Receive', 
       
  2299                    'void', 
       
  2300                    [param('ns3::Ptr< ns3::Packet >', 'packet'), param('uint16_t', 'protocol'), param('ns3::Mac48Address', 'to'), param('ns3::Mac48Address', 'from')])
  1213     ## simple-net-device.h: void ns3::SimpleNetDevice::SetChannel(ns3::Ptr<ns3::SimpleChannel> channel) [member function]
  2301     ## simple-net-device.h: void ns3::SimpleNetDevice::SetChannel(ns3::Ptr<ns3::SimpleChannel> channel) [member function]
  1214     cls.add_method('SetChannel', 'void', [param('ns3::Ptr< ns3::SimpleChannel >', 'channel')])
  2302     cls.add_method('SetChannel', 
       
  2303                    'void', 
       
  2304                    [param('ns3::Ptr< ns3::SimpleChannel >', 'channel')])
  1215     ## simple-net-device.h: void ns3::SimpleNetDevice::SetAddress(ns3::Mac48Address address) [member function]
  2305     ## simple-net-device.h: void ns3::SimpleNetDevice::SetAddress(ns3::Mac48Address address) [member function]
  1216     cls.add_method('SetAddress', 'void', [param('ns3::Mac48Address', 'address')])
  2306     cls.add_method('SetAddress', 
       
  2307                    'void', 
       
  2308                    [param('ns3::Mac48Address', 'address')])
  1217     ## simple-net-device.h: void ns3::SimpleNetDevice::SetName(std::string const name) [member function]
  2309     ## simple-net-device.h: void ns3::SimpleNetDevice::SetName(std::string const name) [member function]
  1218     cls.add_method('SetName', 'void', [param('std::string', 'name', is_const=True)], is_virtual=True)
  2310     cls.add_method('SetName', 
       
  2311                    'void', 
       
  2312                    [param('std::string', 'name', is_const=True)], 
       
  2313                    is_virtual=True)
  1219     ## simple-net-device.h: std::string ns3::SimpleNetDevice::GetName() const [member function]
  2314     ## simple-net-device.h: std::string ns3::SimpleNetDevice::GetName() const [member function]
  1220     cls.add_method('GetName', 'std::string', [], is_const=True, is_virtual=True)
  2315     cls.add_method('GetName', 
       
  2316                    'std::string', 
       
  2317                    [], 
       
  2318                    is_const=True, is_virtual=True)
  1221     ## simple-net-device.h: void ns3::SimpleNetDevice::SetIfIndex(uint32_t const index) [member function]
  2319     ## simple-net-device.h: void ns3::SimpleNetDevice::SetIfIndex(uint32_t const index) [member function]
  1222     cls.add_method('SetIfIndex', 'void', [param('uint32_t', 'index', is_const=True)], is_virtual=True)
  2320     cls.add_method('SetIfIndex', 
       
  2321                    'void', 
       
  2322                    [param('uint32_t', 'index', is_const=True)], 
       
  2323                    is_virtual=True)
  1223     ## simple-net-device.h: uint32_t ns3::SimpleNetDevice::GetIfIndex() const [member function]
  2324     ## simple-net-device.h: uint32_t ns3::SimpleNetDevice::GetIfIndex() const [member function]
  1224     cls.add_method('GetIfIndex', 'uint32_t', [], is_const=True, is_virtual=True)
  2325     cls.add_method('GetIfIndex', 
       
  2326                    'uint32_t', 
       
  2327                    [], 
       
  2328                    is_const=True, is_virtual=True)
  1225     ## simple-net-device.h: ns3::Ptr<ns3::Channel> ns3::SimpleNetDevice::GetChannel() const [member function]
  2329     ## simple-net-device.h: ns3::Ptr<ns3::Channel> ns3::SimpleNetDevice::GetChannel() const [member function]
  1226     cls.add_method('GetChannel', 'ns3::Ptr< ns3::Channel >', [], is_const=True, is_virtual=True)
  2330     cls.add_method('GetChannel', 
       
  2331                    'ns3::Ptr< ns3::Channel >', 
       
  2332                    [], 
       
  2333                    is_const=True, is_virtual=True)
  1227     ## simple-net-device.h: ns3::Address ns3::SimpleNetDevice::GetAddress() const [member function]
  2334     ## simple-net-device.h: ns3::Address ns3::SimpleNetDevice::GetAddress() const [member function]
  1228     cls.add_method('GetAddress', 'ns3::Address', [], is_const=True, is_virtual=True)
  2335     cls.add_method('GetAddress', 
       
  2336                    'ns3::Address', 
       
  2337                    [], 
       
  2338                    is_const=True, is_virtual=True)
  1229     ## simple-net-device.h: bool ns3::SimpleNetDevice::SetMtu(uint16_t const mtu) [member function]
  2339     ## simple-net-device.h: bool ns3::SimpleNetDevice::SetMtu(uint16_t const mtu) [member function]
  1230     cls.add_method('SetMtu', 'bool', [param('uint16_t', 'mtu', is_const=True)], is_virtual=True)
  2340     cls.add_method('SetMtu', 
       
  2341                    'bool', 
       
  2342                    [param('uint16_t', 'mtu', is_const=True)], 
       
  2343                    is_virtual=True)
  1231     ## simple-net-device.h: uint16_t ns3::SimpleNetDevice::GetMtu() const [member function]
  2344     ## simple-net-device.h: uint16_t ns3::SimpleNetDevice::GetMtu() const [member function]
  1232     cls.add_method('GetMtu', 'uint16_t', [], is_const=True, is_virtual=True)
  2345     cls.add_method('GetMtu', 
       
  2346                    'uint16_t', 
       
  2347                    [], 
       
  2348                    is_const=True, is_virtual=True)
  1233     ## simple-net-device.h: bool ns3::SimpleNetDevice::IsLinkUp() const [member function]
  2349     ## simple-net-device.h: bool ns3::SimpleNetDevice::IsLinkUp() const [member function]
  1234     cls.add_method('IsLinkUp', 'bool', [], is_const=True, is_virtual=True)
  2350     cls.add_method('IsLinkUp', 
       
  2351                    'bool', 
       
  2352                    [], 
       
  2353                    is_const=True, is_virtual=True)
  1235     ## simple-net-device.h: void ns3::SimpleNetDevice::SetLinkChangeCallback(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function]
  2354     ## simple-net-device.h: void ns3::SimpleNetDevice::SetLinkChangeCallback(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function]
  1236     cls.add_method('SetLinkChangeCallback', 'void', [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')], is_virtual=True)
  2355     cls.add_method('SetLinkChangeCallback', 
       
  2356                    'void', 
       
  2357                    [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')], 
       
  2358                    is_virtual=True)
  1237     ## simple-net-device.h: bool ns3::SimpleNetDevice::IsBroadcast() const [member function]
  2359     ## simple-net-device.h: bool ns3::SimpleNetDevice::IsBroadcast() const [member function]
  1238     cls.add_method('IsBroadcast', 'bool', [], is_const=True, is_virtual=True)
  2360     cls.add_method('IsBroadcast', 
       
  2361                    'bool', 
       
  2362                    [], 
       
  2363                    is_const=True, is_virtual=True)
  1239     ## simple-net-device.h: ns3::Address ns3::SimpleNetDevice::GetBroadcast() const [member function]
  2364     ## simple-net-device.h: ns3::Address ns3::SimpleNetDevice::GetBroadcast() const [member function]
  1240     cls.add_method('GetBroadcast', 'ns3::Address', [], is_const=True, is_virtual=True)
  2365     cls.add_method('GetBroadcast', 
       
  2366                    'ns3::Address', 
       
  2367                    [], 
       
  2368                    is_const=True, is_virtual=True)
  1241     ## simple-net-device.h: bool ns3::SimpleNetDevice::IsMulticast() const [member function]
  2369     ## simple-net-device.h: bool ns3::SimpleNetDevice::IsMulticast() const [member function]
  1242     cls.add_method('IsMulticast', 'bool', [], is_const=True, is_virtual=True)
  2370     cls.add_method('IsMulticast', 
       
  2371                    'bool', 
       
  2372                    [], 
       
  2373                    is_const=True, is_virtual=True)
  1243     ## simple-net-device.h: ns3::Address ns3::SimpleNetDevice::GetMulticast() const [member function]
  2374     ## simple-net-device.h: ns3::Address ns3::SimpleNetDevice::GetMulticast() const [member function]
  1244     cls.add_method('GetMulticast', 'ns3::Address', [], is_const=True, is_virtual=True)
  2375     cls.add_method('GetMulticast', 
       
  2376                    'ns3::Address', 
       
  2377                    [], 
       
  2378                    is_const=True, is_virtual=True)
  1245     ## simple-net-device.h: ns3::Address ns3::SimpleNetDevice::MakeMulticastAddress(ns3::Ipv4Address multicastGroup) const [member function]
  2379     ## simple-net-device.h: ns3::Address ns3::SimpleNetDevice::MakeMulticastAddress(ns3::Ipv4Address multicastGroup) const [member function]
  1246     cls.add_method('MakeMulticastAddress', 'ns3::Address', [param('ns3::Ipv4Address', 'multicastGroup')], is_const=True, is_virtual=True)
  2380     cls.add_method('MakeMulticastAddress', 
       
  2381                    'ns3::Address', 
       
  2382                    [param('ns3::Ipv4Address', 'multicastGroup')], 
       
  2383                    is_const=True, is_virtual=True)
  1247     ## simple-net-device.h: bool ns3::SimpleNetDevice::IsPointToPoint() const [member function]
  2384     ## simple-net-device.h: bool ns3::SimpleNetDevice::IsPointToPoint() const [member function]
  1248     cls.add_method('IsPointToPoint', 'bool', [], is_const=True, is_virtual=True)
  2385     cls.add_method('IsPointToPoint', 
       
  2386                    'bool', 
       
  2387                    [], 
       
  2388                    is_const=True, is_virtual=True)
  1249     ## simple-net-device.h: bool ns3::SimpleNetDevice::Send(ns3::Ptr<ns3::Packet> packet, ns3::Address const & dest, uint16_t protocolNumber) [member function]
  2389     ## simple-net-device.h: bool ns3::SimpleNetDevice::Send(ns3::Ptr<ns3::Packet> packet, ns3::Address const & dest, uint16_t protocolNumber) [member function]
  1250     cls.add_method('Send', 'bool', [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address&', 'dest', is_const=True), param('uint16_t', 'protocolNumber')], is_virtual=True)
  2390     cls.add_method('Send', 
       
  2391                    'bool', 
       
  2392                    [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address&', 'dest', is_const=True), param('uint16_t', 'protocolNumber')], 
       
  2393                    is_virtual=True)
  1251     ## simple-net-device.h: bool ns3::SimpleNetDevice::SendFrom(ns3::Ptr<ns3::Packet> packet, ns3::Address const & source, ns3::Address const & dest, uint16_t protocolNumber) [member function]
  2394     ## simple-net-device.h: bool ns3::SimpleNetDevice::SendFrom(ns3::Ptr<ns3::Packet> packet, ns3::Address const & source, ns3::Address const & dest, uint16_t protocolNumber) [member function]
  1252     cls.add_method('SendFrom', 'bool', [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address&', 'source', is_const=True), param('ns3::Address&', 'dest', is_const=True), param('uint16_t', 'protocolNumber')], is_virtual=True)
  2395     cls.add_method('SendFrom', 
       
  2396                    'bool', 
       
  2397                    [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address&', 'source', is_const=True), param('ns3::Address&', 'dest', is_const=True), param('uint16_t', 'protocolNumber')], 
       
  2398                    is_virtual=True)
  1253     ## simple-net-device.h: ns3::Ptr<ns3::Node> ns3::SimpleNetDevice::GetNode() const [member function]
  2399     ## simple-net-device.h: ns3::Ptr<ns3::Node> ns3::SimpleNetDevice::GetNode() const [member function]
  1254     cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', [], is_const=True, is_virtual=True)
  2400     cls.add_method('GetNode', 
       
  2401                    'ns3::Ptr< ns3::Node >', 
       
  2402                    [], 
       
  2403                    is_const=True, is_virtual=True)
  1255     ## simple-net-device.h: void ns3::SimpleNetDevice::SetNode(ns3::Ptr<ns3::Node> node) [member function]
  2404     ## simple-net-device.h: void ns3::SimpleNetDevice::SetNode(ns3::Ptr<ns3::Node> node) [member function]
  1256     cls.add_method('SetNode', 'void', [param('ns3::Ptr< ns3::Node >', 'node')], is_virtual=True)
  2405     cls.add_method('SetNode', 
       
  2406                    'void', 
       
  2407                    [param('ns3::Ptr< ns3::Node >', 'node')], 
       
  2408                    is_virtual=True)
  1257     ## simple-net-device.h: bool ns3::SimpleNetDevice::NeedsArp() const [member function]
  2409     ## simple-net-device.h: bool ns3::SimpleNetDevice::NeedsArp() const [member function]
  1258     cls.add_method('NeedsArp', 'bool', [], is_const=True, is_virtual=True)
  2410     cls.add_method('NeedsArp', 
       
  2411                    'bool', 
       
  2412                    [], 
       
  2413                    is_const=True, is_virtual=True)
  1259     ## 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]
  2414     ## 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]
  1260     cls.add_method('SetReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], is_virtual=True)
  2415     cls.add_method('SetReceiveCallback', 
       
  2416                    'void', 
       
  2417                    [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet >, unsigned short, ns3::Address const&, ns3::empty, ns3::empty >', 'cb')], 
       
  2418                    is_virtual=True)
  1261     ## simple-net-device.h: void ns3::SimpleNetDevice::DoDispose() [member function]
  2419     ## simple-net-device.h: void ns3::SimpleNetDevice::DoDispose() [member function]
  1262     cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True)
  2420     cls.add_method('DoDispose', 
       
  2421                    'void', 
       
  2422                    [], 
       
  2423                    visibility='protected', is_virtual=True)
  1263     return
  2424     return
  1264 
  2425 
  1265 def register_Ns3SimpleChannel_methods(root_module, cls):
  2426 def register_Ns3SimpleChannel_methods(root_module, cls):
  1266     ## simple-channel.h: static ns3::TypeId ns3::SimpleChannel::GetTypeId() [member function]
  2427     ## simple-channel.h: static ns3::TypeId ns3::SimpleChannel::GetTypeId() [member function]
  1267     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
  2428     cls.add_method('GetTypeId', 
       
  2429                    'ns3::TypeId', 
       
  2430                    [], 
       
  2431                    is_static=True)
  1268     ## simple-channel.h: ns3::SimpleChannel::SimpleChannel() [constructor]
  2432     ## simple-channel.h: ns3::SimpleChannel::SimpleChannel() [constructor]
  1269     cls.add_constructor([], visibility='public')
  2433     cls.add_constructor([])
  1270     ## simple-channel.h: void ns3::SimpleChannel::Send(ns3::Ptr<ns3::Packet> p, uint16_t protocol, ns3::Mac48Address to, ns3::Mac48Address from, ns3::Ptr<ns3::SimpleNetDevice> sender) [member function]
  2434     ## simple-channel.h: void ns3::SimpleChannel::Send(ns3::Ptr<ns3::Packet> p, uint16_t protocol, ns3::Mac48Address to, ns3::Mac48Address from, ns3::Ptr<ns3::SimpleNetDevice> sender) [member function]
  1271     cls.add_method('Send', 'void', [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint16_t', 'protocol'), param('ns3::Mac48Address', 'to'), param('ns3::Mac48Address', 'from'), param('ns3::Ptr< ns3::SimpleNetDevice >', 'sender')])
  2435     cls.add_method('Send', 
       
  2436                    'void', 
       
  2437                    [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint16_t', 'protocol'), param('ns3::Mac48Address', 'to'), param('ns3::Mac48Address', 'from'), param('ns3::Ptr< ns3::SimpleNetDevice >', 'sender')])
  1272     ## simple-channel.h: void ns3::SimpleChannel::Add(ns3::Ptr<ns3::SimpleNetDevice> device) [member function]
  2438     ## simple-channel.h: void ns3::SimpleChannel::Add(ns3::Ptr<ns3::SimpleNetDevice> device) [member function]
  1273     cls.add_method('Add', 'void', [param('ns3::Ptr< ns3::SimpleNetDevice >', 'device')])
  2439     cls.add_method('Add', 
       
  2440                    'void', 
       
  2441                    [param('ns3::Ptr< ns3::SimpleNetDevice >', 'device')])
  1274     ## simple-channel.h: uint32_t ns3::SimpleChannel::GetNDevices() const [member function]
  2442     ## simple-channel.h: uint32_t ns3::SimpleChannel::GetNDevices() const [member function]
  1275     cls.add_method('GetNDevices', 'uint32_t', [], is_const=True, is_virtual=True)
  2443     cls.add_method('GetNDevices', 
       
  2444                    'uint32_t', 
       
  2445                    [], 
       
  2446                    is_const=True, is_virtual=True)
  1276     ## simple-channel.h: ns3::Ptr<ns3::NetDevice> ns3::SimpleChannel::GetDevice(uint32_t i) const [member function]
  2447     ## simple-channel.h: ns3::Ptr<ns3::NetDevice> ns3::SimpleChannel::GetDevice(uint32_t i) const [member function]
  1277     cls.add_method('GetDevice', 'ns3::Ptr< ns3::NetDevice >', [param('uint32_t', 'i')], is_const=True, is_virtual=True)
  2448     cls.add_method('GetDevice', 
       
  2449                    'ns3::Ptr< ns3::NetDevice >', 
       
  2450                    [param('uint32_t', 'i')], 
       
  2451                    is_const=True, is_virtual=True)
  1278     return
  2452     return
  1279 
  2453 
  1280 def register_Ns3TcpSocketFactory_methods(root_module, cls):
  2454 def register_Ns3TcpSocketFactory_methods(root_module, cls):
  1281     ## tcp-socket-factory.h: static ns3::TypeId ns3::TcpSocketFactory::GetTypeId() [member function]
  2455     ## tcp-socket-factory.h: static ns3::TypeId ns3::TcpSocketFactory::GetTypeId() [member function]
  1282     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
  2456     cls.add_method('GetTypeId', 
       
  2457                    'ns3::TypeId', 
       
  2458                    [], 
       
  2459                    is_static=True)
  1283     cls.add_constructor([])
  2460     cls.add_constructor([])
  1284     return
  2461     return
  1285 
  2462 
  1286 def register_Ns3PacketSocketFactory_methods(root_module, cls):
  2463 def register_Ns3PacketSocketFactory_methods(root_module, cls):
  1287     ## packet-socket-factory.h: static ns3::TypeId ns3::PacketSocketFactory::GetTypeId() [member function]
  2464     ## packet-socket-factory.h: static ns3::TypeId ns3::PacketSocketFactory::GetTypeId() [member function]
  1288     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
  2465     cls.add_method('GetTypeId', 
       
  2466                    'ns3::TypeId', 
       
  2467                    [], 
       
  2468                    is_static=True)
  1289     ## packet-socket-factory.h: ns3::PacketSocketFactory::PacketSocketFactory() [constructor]
  2469     ## packet-socket-factory.h: ns3::PacketSocketFactory::PacketSocketFactory() [constructor]
  1290     cls.add_constructor([], visibility='public')
  2470     cls.add_constructor([])
  1291     ## packet-socket-factory.h: ns3::Ptr<ns3::Socket> ns3::PacketSocketFactory::CreateSocket() [member function]
  2471     ## packet-socket-factory.h: ns3::Ptr<ns3::Socket> ns3::PacketSocketFactory::CreateSocket() [member function]
  1292     cls.add_method('CreateSocket', 'ns3::Ptr< ns3::Socket >', [], is_virtual=True)
  2472     cls.add_method('CreateSocket', 
       
  2473                    'ns3::Ptr< ns3::Socket >', 
       
  2474                    [], 
       
  2475                    is_virtual=True)
  1293     return
  2476     return
  1294 
  2477 
  1295 def register_functions(root_module):
  2478 def register_functions(root_module):
  1296     module = root_module
  2479     module = root_module
  1297     ## mac48-address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeMac48AddressChecker() [free function]
  2480     ## mac48-address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeMac48AddressChecker() [free function]
  1298     module.add_function('MakeMac48AddressChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [])
  2481     module.add_function('MakeMac48AddressChecker', 
       
  2482                         'ns3::Ptr< ns3::AttributeChecker const >', 
       
  2483                         [])
  1299     ## ipv4-address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeIpv4AddressChecker() [free function]
  2484     ## ipv4-address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeIpv4AddressChecker() [free function]
  1300     module.add_function('MakeIpv4AddressChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [])
  2485     module.add_function('MakeIpv4AddressChecker', 
       
  2486                         'ns3::Ptr< ns3::AttributeChecker const >', 
       
  2487                         [])
  1301     ## address-utils.h: extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Mac48Address ad) [free function]
  2488     ## address-utils.h: extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Mac48Address ad) [free function]
  1302     module.add_function('WriteTo', 'void', [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Mac48Address', 'ad')])
  2489     module.add_function('WriteTo', 
       
  2490                         'void', 
       
  2491                         [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Mac48Address', 'ad')])
  1303     ## address-utils.h: extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Address const & ad) [free function]
  2492     ## address-utils.h: extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Address const & ad) [free function]
  1304     module.add_function('WriteTo', 'void', [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Address&', 'ad', is_const=True)])
  2493     module.add_function('WriteTo', 
       
  2494                         'void', 
       
  2495                         [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Address&', 'ad', is_const=True)])
  1305     ## address-utils.h: extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Ipv4Address ad) [free function]
  2496     ## address-utils.h: extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Ipv4Address ad) [free function]
  1306     module.add_function('WriteTo', 'void', [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Ipv4Address', 'ad')])
  2497     module.add_function('WriteTo', 
       
  2498                         'void', 
       
  2499                         [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Ipv4Address', 'ad')])
  1307     ## address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeAddressChecker() [free function]
  2500     ## address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeAddressChecker() [free function]
  1308     module.add_function('MakeAddressChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [])
  2501     module.add_function('MakeAddressChecker', 
       
  2502                         'ns3::Ptr< ns3::AttributeChecker const >', 
       
  2503                         [])
  1309     ## ipv4-address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeIpv4MaskChecker() [free function]
  2504     ## ipv4-address.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeIpv4MaskChecker() [free function]
  1310     module.add_function('MakeIpv4MaskChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [])
  2505     module.add_function('MakeIpv4MaskChecker', 
       
  2506                         'ns3::Ptr< ns3::AttributeChecker const >', 
       
  2507                         [])
  1311     ## address-utils.h: extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Mac48Address & ad) [free function]
  2508     ## address-utils.h: extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Mac48Address & ad) [free function]
  1312     module.add_function('ReadFrom', 'void', [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Mac48Address&', 'ad')])
  2509     module.add_function('ReadFrom', 
       
  2510                         'void', 
       
  2511                         [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Mac48Address&', 'ad')])
  1313     ## address-utils.h: extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Address & ad, uint32_t len) [free function]
  2512     ## address-utils.h: extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Address & ad, uint32_t len) [free function]
  1314     module.add_function('ReadFrom', 'void', [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Address&', 'ad'), param('uint32_t', 'len')])
  2513     module.add_function('ReadFrom', 
       
  2514                         'void', 
       
  2515                         [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Address&', 'ad'), param('uint32_t', 'len')])
  1315     ## address-utils.h: extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Ipv4Address & ad) [free function]
  2516     ## address-utils.h: extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Ipv4Address & ad) [free function]
  1316     module.add_function('ReadFrom', 'void', [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Ipv4Address&', 'ad')])
  2517     module.add_function('ReadFrom', 
       
  2518                         'void', 
       
  2519                         [param('ns3::Buffer::Iterator&', 'i'), param('ns3::Ipv4Address&', 'ad')])
  1317     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
  2520     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
  1318     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
  2521     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
  1319     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
  2522     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
  1320     register_functions_ns3_olsr(module.get_submodule('olsr'), root_module)
  2523     register_functions_ns3_olsr(module.get_submodule('olsr'), root_module)
  1321     return
  2524     return