ns-3.5: bindings/python/ns3_module_common.py@2eaebe77d66b

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

     3 def register_types(module):

     4     root_module = module.get_root()

     6     ## error-model.h: ns3::ErrorUnit [enumeration]

     7     module.add_enum('ErrorUnit', ['EU_BIT', 'EU_BYTE', 'EU_PKT'])

     8     ## buffer.h: ns3::Buffer [class]

     9     module.add_class('Buffer')

    10     ## buffer.h: ns3::Buffer::Iterator [class]

    11     module.add_class('Iterator', outer_class=root_module['ns3::Buffer'])

    12     ## packet.h: ns3::ByteTagIterator [class]

    13     module.add_class('ByteTagIterator')

    14     ## packet.h: ns3::ByteTagIterator::Item [class]

    15     module.add_class('Item', outer_class=root_module['ns3::ByteTagIterator'])

    16     ## byte-tag-list.h: ns3::ByteTagList [class]

    17     module.add_class('ByteTagList')

    18     ## byte-tag-list.h: ns3::ByteTagList::Iterator [class]

    19     module.add_class('Iterator', outer_class=root_module['ns3::ByteTagList'])

    20     ## byte-tag-list.h: ns3::ByteTagList::Iterator::Item [struct]

    21     module.add_class('Item', outer_class=root_module['ns3::ByteTagList::Iterator'])

    22     ## data-rate.h: ns3::DataRate [class]

    23     module.add_class('DataRate')

    24     ## packet.h: ns3::Packet [class]

    25     module.add_class('Packet', memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))

    26     ## packet-metadata.h: ns3::PacketMetadata [class]

    27     module.add_class('PacketMetadata')

    28     ## packet-metadata.h: ns3::PacketMetadata::Item [struct]

    29     module.add_class('Item', outer_class=root_module['ns3::PacketMetadata'])

    30     ## packet-metadata.h: ns3::PacketMetadata::Item [enumeration]

    31     module.add_enum('', ['PAYLOAD', 'HEADER', 'TRAILER'], outer_class=root_module['ns3::PacketMetadata::Item'])

    32     ## packet-metadata.h: ns3::PacketMetadata::ItemIterator [class]

    33     module.add_class('ItemIterator', outer_class=root_module['ns3::PacketMetadata'])

    34     ## packet.h: ns3::PacketTagIterator [class]

    35     module.add_class('PacketTagIterator')

    36     ## packet.h: ns3::PacketTagIterator::Item [class]

    37     module.add_class('Item', outer_class=root_module['ns3::PacketTagIterator'])

    38     ## packet-tag-list.h: ns3::PacketTagList [class]

    39     module.add_class('PacketTagList')

    40     ## packet-tag-list.h: ns3::PacketTagList::TagData [struct]

    41     module.add_class('TagData', outer_class=root_module['ns3::PacketTagList'])

    42     ## tag.h: ns3::Tag [class]

    43     module.add_class('Tag', parent=root_module['ns3::ObjectBase'])

    44     ## tag-buffer.h: ns3::TagBuffer [class]

    45     module.add_class('TagBuffer')

    46     ## chunk.h: ns3::Chunk [class]

    47     module.add_class('Chunk', parent=root_module['ns3::ObjectBase'])

    48     ## data-rate.h: ns3::DataRateChecker [class]

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

    50     ## data-rate.h: ns3::DataRateValue [class]

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

    52     ## header.h: ns3::Header [class]

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

    54     ## pcap-writer.h: ns3::PcapWriter [class]

    55     module.add_class('PcapWriter', parent=root_module['ns3::RefCountBase'])

    56     ## trailer.h: ns3::Trailer [class]

    57     module.add_class('Trailer', parent=root_module['ns3::Chunk'])

    58     ## error-model.h: ns3::ErrorModel [class]

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

    60     ## error-model.h: ns3::ListErrorModel [class]

    61     module.add_class('ListErrorModel', parent=root_module['ns3::ErrorModel'])

    62     ## error-model.h: ns3::RateErrorModel [class]

    63     module.add_class('RateErrorModel', parent=root_module['ns3::ErrorModel'])

    65     ## Register a nested module for the namespace Config

    67     nested_module = module.add_cpp_namespace('Config')

    68     register_types_ns3_Config(nested_module)

    71     ## Register a nested module for the namespace TimeStepPrecision

    73     nested_module = module.add_cpp_namespace('TimeStepPrecision')

    74     register_types_ns3_TimeStepPrecision(nested_module)

    77     ## Register a nested module for the namespace addressUtils

    79     nested_module = module.add_cpp_namespace('addressUtils')

    80     register_types_ns3_addressUtils(nested_module)

    83     ## Register a nested module for the namespace internal

    85     nested_module = module.add_cpp_namespace('internal')

    86     register_types_ns3_internal(nested_module)

    89     ## Register a nested module for the namespace olsr

    91     nested_module = module.add_cpp_namespace('olsr')

    92     register_types_ns3_olsr(nested_module)

    95 def register_types_ns3_Config(module):

    96     root_module = module.get_root()

    99 def register_types_ns3_TimeStepPrecision(module):

   100     root_module = module.get_root()

   103 def register_types_ns3_addressUtils(module):

   104     root_module = module.get_root()

   107 def register_types_ns3_internal(module):

   108     root_module = module.get_root()

   111 def register_types_ns3_olsr(module):

   112     root_module = module.get_root()

   115 def register_methods(root_module):

   116     register_Ns3Buffer_methods(root_module, root_module['ns3::Buffer'])

   117     register_Ns3BufferIterator_methods(root_module, root_module['ns3::Buffer::Iterator'])

   118     register_Ns3ByteTagIterator_methods(root_module, root_module['ns3::ByteTagIterator'])

   119     register_Ns3ByteTagIteratorItem_methods(root_module, root_module['ns3::ByteTagIterator::Item'])

   120     register_Ns3ByteTagList_methods(root_module, root_module['ns3::ByteTagList'])

   121     register_Ns3ByteTagListIterator_methods(root_module, root_module['ns3::ByteTagList::Iterator'])

   122     register_Ns3ByteTagListIteratorItem_methods(root_module, root_module['ns3::ByteTagList::Iterator::Item'])

   123     register_Ns3DataRate_methods(root_module, root_module['ns3::DataRate'])

   124     register_Ns3Packet_methods(root_module, root_module['ns3::Packet'])

   125     register_Ns3PacketMetadata_methods(root_module, root_module['ns3::PacketMetadata'])

   126     register_Ns3PacketMetadataItem_methods(root_module, root_module['ns3::PacketMetadata::Item'])

   127     register_Ns3PacketMetadataItemIterator_methods(root_module, root_module['ns3::PacketMetadata::ItemIterator'])

   128     register_Ns3PacketTagIterator_methods(root_module, root_module['ns3::PacketTagIterator'])

   129     register_Ns3PacketTagIteratorItem_methods(root_module, root_module['ns3::PacketTagIterator::Item'])

   130     register_Ns3PacketTagList_methods(root_module, root_module['ns3::PacketTagList'])

   131     register_Ns3PacketTagListTagData_methods(root_module, root_module['ns3::PacketTagList::TagData'])

   132     register_Ns3Tag_methods(root_module, root_module['ns3::Tag'])

   133     register_Ns3TagBuffer_methods(root_module, root_module['ns3::TagBuffer'])

   134     register_Ns3Chunk_methods(root_module, root_module['ns3::Chunk'])

   135     register_Ns3DataRateChecker_methods(root_module, root_module['ns3::DataRateChecker'])

   136     register_Ns3DataRateValue_methods(root_module, root_module['ns3::DataRateValue'])

   137     register_Ns3Header_methods(root_module, root_module['ns3::Header'])

   138     register_Ns3PcapWriter_methods(root_module, root_module['ns3::PcapWriter'])

   139     register_Ns3Trailer_methods(root_module, root_module['ns3::Trailer'])

   140     register_Ns3ErrorModel_methods(root_module, root_module['ns3::ErrorModel'])

   141     register_Ns3ListErrorModel_methods(root_module, root_module['ns3::ListErrorModel'])

   142     register_Ns3RateErrorModel_methods(root_module, root_module['ns3::RateErrorModel'])

   143     return

   145 def register_Ns3Buffer_methods(root_module, cls):

   146     ## buffer.h: uint32_t ns3::Buffer::GetSize() const [member function]

   147     cls.add_method('GetSize',

   148                    'uint32_t',

   149                    [],

   150                    is_const=True)

   151     ## buffer.h: uint8_t const * ns3::Buffer::PeekData() const [member function]

   152     cls.add_method('PeekData',

   153                    'uint8_t const *',

   154                    [],

   155                    is_const=True)

   156     ## buffer.h: bool ns3::Buffer::AddAtStart(uint32_t start) [member function]

   157     cls.add_method('AddAtStart',

   158                    'bool',

   159                    [param('uint32_t', 'start')])

   160     ## buffer.h: bool ns3::Buffer::AddAtEnd(uint32_t end) [member function]

   161     cls.add_method('AddAtEnd',

   162                    'bool',

   163                    [param('uint32_t', 'end')])

   164     ## buffer.h: void ns3::Buffer::AddAtEnd(ns3::Buffer const & o) [member function]

   165     cls.add_method('AddAtEnd',

   166                    'void',

   167                    [param('ns3::Buffer const &', 'o')])

   168     ## buffer.h: void ns3::Buffer::RemoveAtStart(uint32_t start) [member function]

   169     cls.add_method('RemoveAtStart',

   170                    'void',

   171                    [param('uint32_t', 'start')])

   172     ## buffer.h: void ns3::Buffer::RemoveAtEnd(uint32_t end) [member function]

   173     cls.add_method('RemoveAtEnd',

   174                    'void',

   175                    [param('uint32_t', 'end')])

   176     ## buffer.h: ns3::Buffer ns3::Buffer::CreateFragment(uint32_t start, uint32_t length) const [member function]

   177     cls.add_method('CreateFragment',

   178                    'ns3::Buffer',

   179                    [param('uint32_t', 'start'), param('uint32_t', 'length')],

   180                    is_const=True)

   181     ## buffer.h: ns3::Buffer::Iterator ns3::Buffer::Begin() const [member function]

   182     cls.add_method('Begin',

   183                    'ns3::Buffer::Iterator',

   184                    [],

   185                    is_const=True)

   186     ## buffer.h: ns3::Buffer::Iterator ns3::Buffer::End() const [member function]

   187     cls.add_method('End',

   188                    'ns3::Buffer::Iterator',

   189                    [],

   190                    is_const=True)

   191     ## buffer.h: ns3::Buffer ns3::Buffer::CreateFullCopy() const [member function]

   192     cls.add_method('CreateFullCopy',

   193                    'ns3::Buffer',

   194                    [],

   195                    is_const=True)

   196     ## buffer.h: int32_t ns3::Buffer::GetCurrentStartOffset() const [member function]

   197     cls.add_method('GetCurrentStartOffset',

   198                    'int32_t',

   199                    [],

   200                    is_const=True)

   201     ## buffer.h: int32_t ns3::Buffer::GetCurrentEndOffset() const [member function]

   202     cls.add_method('GetCurrentEndOffset',

   203                    'int32_t',

   204                    [],

   205                    is_const=True)

   206     ## buffer.h: void ns3::Buffer::CopyData(std::ostream * os, uint32_t size) const [member function]

   207     cls.add_method('CopyData',

   208                    'void',

   209                    [param('std::ostream *', 'os'), param('uint32_t', 'size')],

   210                    is_const=True)

   211     ## buffer.h: ns3::Buffer::Buffer(ns3::Buffer const & o) [copy constructor]

   212     cls.add_constructor([param('ns3::Buffer const &', 'o')])

   213     ## buffer.h: ns3::Buffer::Buffer() [constructor]

   214     cls.add_constructor([])

   215     ## buffer.h: ns3::Buffer::Buffer(uint32_t dataSize) [constructor]

   216     cls.add_constructor([param('uint32_t', 'dataSize')])

   217     return

   219 def register_Ns3BufferIterator_methods(root_module, cls):

   220     ## buffer.h: ns3::Buffer::Iterator::Iterator(ns3::Buffer::Iterator const & arg0) [copy constructor]

   221     cls.add_constructor([param('ns3::Buffer::Iterator const &', 'arg0')])

   222     ## buffer.h: ns3::Buffer::Iterator::Iterator() [constructor]

   223     cls.add_constructor([])

   224     ## buffer.h: void ns3::Buffer::Iterator::Next() [member function]

   225     cls.add_method('Next',

   226                    'void',

   227                    [])

   228     ## buffer.h: void ns3::Buffer::Iterator::Prev() [member function]

   229     cls.add_method('Prev',

   230                    'void',

   231                    [])

   232     ## buffer.h: void ns3::Buffer::Iterator::Next(uint32_t delta) [member function]

   233     cls.add_method('Next',

   234                    'void',

   235                    [param('uint32_t', 'delta')])

   236     ## buffer.h: void ns3::Buffer::Iterator::Prev(uint32_t delta) [member function]

   237     cls.add_method('Prev',

   238                    'void',

   239                    [param('uint32_t', 'delta')])

   240     ## buffer.h: uint32_t ns3::Buffer::Iterator::GetDistanceFrom(ns3::Buffer::Iterator const & o) const [member function]

   241     cls.add_method('GetDistanceFrom',

   242                    'uint32_t',

   243                    [param('ns3::Buffer::Iterator const &', 'o')],

   244                    is_const=True)

   245     ## buffer.h: bool ns3::Buffer::Iterator::IsEnd() const [member function]

   246     cls.add_method('IsEnd',

   247                    'bool',

   248                    [],

   249                    is_const=True)

   250     ## buffer.h: bool ns3::Buffer::Iterator::IsStart() const [member function]

   251     cls.add_method('IsStart',

   252                    'bool',

   253                    [],

   254                    is_const=True)

   255     ## buffer.h: void ns3::Buffer::Iterator::WriteU8(uint8_t data) [member function]

   256     cls.add_method('WriteU8',

   257                    'void',

   258                    [param('uint8_t', 'data')])

   259     ## buffer.h: void ns3::Buffer::Iterator::WriteU8(uint8_t data, uint32_t len) [member function]

   260     cls.add_method('WriteU8',

   261                    'void',

   262                    [param('uint8_t', 'data'), param('uint32_t', 'len')])

   263     ## buffer.h: void ns3::Buffer::Iterator::WriteU16(uint16_t data) [member function]

   264     cls.add_method('WriteU16',

   265                    'void',

   266                    [param('uint16_t', 'data')])

   267     ## buffer.h: void ns3::Buffer::Iterator::WriteU32(uint32_t data) [member function]

   268     cls.add_method('WriteU32',

   269                    'void',

   270                    [param('uint32_t', 'data')])

   271     ## buffer.h: void ns3::Buffer::Iterator::WriteU64(uint64_t data) [member function]

   272     cls.add_method('WriteU64',

   273                    'void',

   274                    [param('uint64_t', 'data')])

   275     ## buffer.h: void ns3::Buffer::Iterator::WriteHtolsbU16(uint16_t data) [member function]

   276     cls.add_method('WriteHtolsbU16',

   277                    'void',

   278                    [param('uint16_t', 'data')])

   279     ## buffer.h: void ns3::Buffer::Iterator::WriteHtolsbU32(uint32_t data) [member function]

   280     cls.add_method('WriteHtolsbU32',

   281                    'void',

   282                    [param('uint32_t', 'data')])

   283     ## buffer.h: void ns3::Buffer::Iterator::WriteHtolsbU64(uint64_t data) [member function]

   284     cls.add_method('WriteHtolsbU64',

   285                    'void',

   286                    [param('uint64_t', 'data')])

   287     ## buffer.h: void ns3::Buffer::Iterator::WriteHtonU16(uint16_t data) [member function]

   288     cls.add_method('WriteHtonU16',

   289                    'void',

   290                    [param('uint16_t', 'data')])

   291     ## buffer.h: void ns3::Buffer::Iterator::WriteHtonU32(uint32_t data) [member function]

   292     cls.add_method('WriteHtonU32',

   293                    'void',

   294                    [param('uint32_t', 'data')])

   295     ## buffer.h: void ns3::Buffer::Iterator::WriteHtonU64(uint64_t data) [member function]

   296     cls.add_method('WriteHtonU64',

   297                    'void',

   298                    [param('uint64_t', 'data')])

   299     ## buffer.h: void ns3::Buffer::Iterator::Write(uint8_t const * buffer, uint32_t size) [member function]

   300     cls.add_method('Write',

   301                    'void',

   302                    [param('uint8_t const *', 'buffer'), param('uint32_t', 'size')])

   303     ## buffer.h: void ns3::Buffer::Iterator::Write(ns3::Buffer::Iterator start, ns3::Buffer::Iterator end) [member function]

   304     cls.add_method('Write',

   305                    'void',

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

   307     ## buffer.h: uint8_t ns3::Buffer::Iterator::ReadU8() [member function]

   308     cls.add_method('ReadU8',

   309                    'uint8_t',

   310                    [])

   311     ## buffer.h: uint16_t ns3::Buffer::Iterator::ReadU16() [member function]

   312     cls.add_method('ReadU16',

   313                    'uint16_t',

   314                    [])

   315     ## buffer.h: uint32_t ns3::Buffer::Iterator::ReadU32() [member function]

   316     cls.add_method('ReadU32',

   317                    'uint32_t',

   318                    [])

   319     ## buffer.h: uint64_t ns3::Buffer::Iterator::ReadU64() [member function]

   320     cls.add_method('ReadU64',

   321                    'uint64_t',

   322                    [])

   323     ## buffer.h: uint16_t ns3::Buffer::Iterator::ReadNtohU16() [member function]

   324     cls.add_method('ReadNtohU16',

   325                    'uint16_t',

   326                    [])

   327     ## buffer.h: uint32_t ns3::Buffer::Iterator::ReadNtohU32() [member function]

   328     cls.add_method('ReadNtohU32',

   329                    'uint32_t',

   330                    [])

   331     ## buffer.h: uint64_t ns3::Buffer::Iterator::ReadNtohU64() [member function]

   332     cls.add_method('ReadNtohU64',

   333                    'uint64_t',

   334                    [])

   335     ## buffer.h: uint16_t ns3::Buffer::Iterator::ReadLsbtohU16() [member function]

   336     cls.add_method('ReadLsbtohU16',

   337                    'uint16_t',

   338                    [])

   339     ## buffer.h: uint32_t ns3::Buffer::Iterator::ReadLsbtohU32() [member function]

   340     cls.add_method('ReadLsbtohU32',

   341                    'uint32_t',

   342                    [])

   343     ## buffer.h: uint64_t ns3::Buffer::Iterator::ReadLsbtohU64() [member function]

   344     cls.add_method('ReadLsbtohU64',

   345                    'uint64_t',

   346                    [])

   347     ## buffer.h: void ns3::Buffer::Iterator::Read(uint8_t * buffer, uint32_t size) [member function]

   348     cls.add_method('Read',

   349                    'void',

   350                    [param('uint8_t *', 'buffer'), param('uint32_t', 'size')])

   351     ## buffer.h: uint16_t ns3::Buffer::Iterator::CalculateIpChecksum(uint16_t size) [member function]

   352     cls.add_method('CalculateIpChecksum',

   353                    'uint16_t',

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

   355     ## buffer.h: uint16_t ns3::Buffer::Iterator::CalculateIpChecksum(uint16_t size, uint32_t initialChecksum) [member function]

   356     cls.add_method('CalculateIpChecksum',

   357                    'uint16_t',

   358                    [param('uint16_t', 'size'), param('uint32_t', 'initialChecksum')])

   359     ## buffer.h: uint32_t ns3::Buffer::Iterator::GetSize() const [member function]

   360     cls.add_method('GetSize',

   361                    'uint32_t',

   362                    [],

   363                    is_const=True)

   364     return

   366 def register_Ns3ByteTagIterator_methods(root_module, cls):

   367     ## packet.h: ns3::ByteTagIterator::ByteTagIterator(ns3::ByteTagIterator const & arg0) [copy constructor]

   368     cls.add_constructor([param('ns3::ByteTagIterator const &', 'arg0')])

   369     ## packet.h: bool ns3::ByteTagIterator::HasNext() const [member function]

   370     cls.add_method('HasNext',

   371                    'bool',

   372                    [],

   373                    is_const=True)

   374     ## packet.h: ns3::ByteTagIterator::Item ns3::ByteTagIterator::Next() [member function]

   375     cls.add_method('Next',

   376                    'ns3::ByteTagIterator::Item',

   377                    [])

   378     return

   380 def register_Ns3ByteTagIteratorItem_methods(root_module, cls):

   381     ## packet.h: ns3::ByteTagIterator::Item::Item(ns3::ByteTagIterator::Item const & arg0) [copy constructor]

   382     cls.add_constructor([param('ns3::ByteTagIterator::Item const &', 'arg0')])

   383     ## packet.h: ns3::TypeId ns3::ByteTagIterator::Item::GetTypeId() const [member function]

   384     cls.add_method('GetTypeId',

   385                    'ns3::TypeId',

   386                    [],

   387                    is_const=True)

   388     ## packet.h: uint32_t ns3::ByteTagIterator::Item::GetStart() const [member function]

   389     cls.add_method('GetStart',

   390                    'uint32_t',

   391                    [],

   392                    is_const=True)

   393     ## packet.h: uint32_t ns3::ByteTagIterator::Item::GetEnd() const [member function]

   394     cls.add_method('GetEnd',

   395                    'uint32_t',

   396                    [],

   397                    is_const=True)

   398     ## packet.h: void ns3::ByteTagIterator::Item::GetTag(ns3::Tag & tag) const [member function]

   399     cls.add_method('GetTag',

   400                    'void',

   401                    [param('ns3::Tag &', 'tag')],

   402                    is_const=True)

   403     return

   405 def register_Ns3ByteTagList_methods(root_module, cls):

   406     ## byte-tag-list.h: ns3::ByteTagList::ByteTagList() [constructor]

   407     cls.add_constructor([])

   408     ## byte-tag-list.h: ns3::ByteTagList::ByteTagList(ns3::ByteTagList const & o) [copy constructor]

   409     cls.add_constructor([param('ns3::ByteTagList const &', 'o')])

   410     ## byte-tag-list.h: ns3::TagBuffer ns3::ByteTagList::Add(ns3::TypeId tid, uint32_t bufferSize, int32_t start, int32_t end) [member function]

   411     cls.add_method('Add',

   412                    'ns3::TagBuffer',

   413                    [param('ns3::TypeId', 'tid'), param('uint32_t', 'bufferSize'), param('int32_t', 'start'), param('int32_t', 'end')])

   414     ## byte-tag-list.h: void ns3::ByteTagList::Add(ns3::ByteTagList const & o) [member function]

   415     cls.add_method('Add',

   416                    'void',

   417                    [param('ns3::ByteTagList const &', 'o')])

   418     ## byte-tag-list.h: void ns3::ByteTagList::RemoveAll() [member function]

   419     cls.add_method('RemoveAll',

   420                    'void',

   421                    [])

   422     ## byte-tag-list.h: ns3::ByteTagList::Iterator ns3::ByteTagList::Begin(int32_t offsetStart, int32_t offsetEnd) const [member function]

   423     cls.add_method('Begin',

   424                    'ns3::ByteTagList::Iterator',

   425                    [param('int32_t', 'offsetStart'), param('int32_t', 'offsetEnd')],

   426                    is_const=True)

   427     ## byte-tag-list.h: void ns3::ByteTagList::AddAtEnd(int32_t adjustment, int32_t appendOffset) [member function]

   428     cls.add_method('AddAtEnd',

   429                    'void',

   430                    [param('int32_t', 'adjustment'), param('int32_t', 'appendOffset')])

   431     ## byte-tag-list.h: void ns3::ByteTagList::AddAtStart(int32_t adjustment, int32_t prependOffset) [member function]

   432     cls.add_method('AddAtStart',

   433                    'void',

   434                    [param('int32_t', 'adjustment'), param('int32_t', 'prependOffset')])

   435     return

   437 def register_Ns3ByteTagListIterator_methods(root_module, cls):

   438     ## byte-tag-list.h: ns3::ByteTagList::Iterator::Iterator(ns3::ByteTagList::Iterator const & arg0) [copy constructor]

   439     cls.add_constructor([param('ns3::ByteTagList::Iterator const &', 'arg0')])

   440     ## byte-tag-list.h: bool ns3::ByteTagList::Iterator::HasNext() const [member function]

   441     cls.add_method('HasNext',

   442                    'bool',

   443                    [],

   444                    is_const=True)

   445     ## byte-tag-list.h: ns3::ByteTagList::Iterator::Item ns3::ByteTagList::Iterator::Next() [member function]

   446     cls.add_method('Next',

   447                    'ns3::ByteTagList::Iterator::Item',

   448                    [])

   449     ## byte-tag-list.h: uint32_t ns3::ByteTagList::Iterator::GetOffsetStart() const [member function]

   450     cls.add_method('GetOffsetStart',

   451                    'uint32_t',

   452                    [],

   453                    is_const=True)

   454     return

   456 def register_Ns3ByteTagListIteratorItem_methods(root_module, cls):

   457     ## byte-tag-list.h: ns3::ByteTagList::Iterator::Item::tid [variable]

   458     cls.add_instance_attribute('tid', 'ns3::TypeId', is_const=False)

   459     ## byte-tag-list.h: ns3::ByteTagList::Iterator::Item::size [variable]

   460     cls.add_instance_attribute('size', 'uint32_t', is_const=False)

   461     ## byte-tag-list.h: ns3::ByteTagList::Iterator::Item::start [variable]

   462     cls.add_instance_attribute('start', 'int32_t', is_const=False)

   463     ## byte-tag-list.h: ns3::ByteTagList::Iterator::Item::end [variable]

   464     cls.add_instance_attribute('end', 'int32_t', is_const=False)

   465     ## byte-tag-list.h: ns3::ByteTagList::Iterator::Item::buf [variable]

   466     cls.add_instance_attribute('buf', 'ns3::TagBuffer', is_const=False)

   467     ## byte-tag-list.h: ns3::ByteTagList::Iterator::Item::Item(ns3::ByteTagList::Iterator::Item const & arg0) [copy constructor]

   468     cls.add_constructor([param('ns3::ByteTagList::Iterator::Item const &', 'arg0')])

   469     ## byte-tag-list.h: ns3::ByteTagList::Iterator::Item::Item(ns3::TagBuffer buf) [constructor]

   470     cls.add_constructor([param('ns3::TagBuffer', 'buf')])

   471     return

   473 def register_Ns3DataRate_methods(root_module, cls):

   474     cls.add_output_stream_operator()

   475     cls.add_binary_comparison_operator('!=')

   476     cls.add_binary_comparison_operator('<')

   477     cls.add_binary_comparison_operator('<=')

   478     cls.add_binary_comparison_operator('==')

   479     cls.add_binary_comparison_operator('>')

   480     cls.add_binary_comparison_operator('>=')

   481     ## data-rate.h: ns3::DataRate::DataRate(ns3::DataRate const & arg0) [copy constructor]

   482     cls.add_constructor([param('ns3::DataRate const &', 'arg0')])

   483     ## data-rate.h: ns3::DataRate::DataRate() [constructor]

   484     cls.add_constructor([])

   485     ## data-rate.h: ns3::DataRate::DataRate(uint64_t bps) [constructor]

   486     cls.add_constructor([param('uint64_t', 'bps')])

   487     ## data-rate.h: ns3::DataRate::DataRate(std::string rate) [constructor]

   488     cls.add_constructor([param('std::string', 'rate')])

   489     ## data-rate.h: double ns3::DataRate::CalculateTxTime(uint32_t bytes) const [member function]

   490     cls.add_method('CalculateTxTime',

   491                    'double',

   492                    [param('uint32_t', 'bytes')],

   493                    is_const=True)

   494     ## data-rate.h: uint64_t ns3::DataRate::GetBitRate() const [member function]

   495     cls.add_method('GetBitRate',

   496                    'uint64_t',

   497                    [],

   498                    is_const=True)

   499     return

   501 def register_Ns3Packet_methods(root_module, cls):

   502     cls.add_output_stream_operator()

   503     ## packet.h: ns3::Packet::Packet() [constructor]

   504     cls.add_constructor([])

   505     ## packet.h: ns3::Packet::Packet(ns3::Packet const & o) [copy constructor]

   506     cls.add_constructor([param('ns3::Packet const &', 'o')])

   507     ## packet.h: ns3::Packet::Packet(uint32_t size) [constructor]

   508     cls.add_constructor([param('uint32_t', 'size')])

   509     ## packet.h: ns3::Packet::Packet(uint8_t const * buffer, uint32_t size) [constructor]

   510     cls.add_constructor([param('uint8_t const *', 'buffer'), param('uint32_t', 'size')])

   511     ## packet.h: void ns3::Packet::AddAtEnd(ns3::Ptr<ns3::Packet const> packet) [member function]

   512     cls.add_method('AddAtEnd',

   513                    'void',

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

   515     ## packet.h: void ns3::Packet::AddByteTag(ns3::Tag const & tag) const [member function]

   516     cls.add_method('AddByteTag',

   517                    'void',

   518                    [param('ns3::Tag const &', 'tag')],

   519                    is_const=True)

   520     ## packet.h: void ns3::Packet::AddHeader(ns3::Header const & header) [member function]

   521     cls.add_method('AddHeader',

   522                    'void',

   523                    [param('ns3::Header const &', 'header')])

   524     ## packet.h: void ns3::Packet::AddPacketTag(ns3::Tag const & tag) const [member function]

   525     cls.add_method('AddPacketTag',

   526                    'void',

   527                    [param('ns3::Tag const &', 'tag')],

   528                    is_const=True)

   529     ## packet.h: void ns3::Packet::AddPaddingAtEnd(uint32_t size) [member function]

   530     cls.add_method('AddPaddingAtEnd',

   531                    'void',

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

   533     ## packet.h: void ns3::Packet::AddTrailer(ns3::Trailer const & trailer) [member function]

   534     cls.add_method('AddTrailer',

   535                    'void',

   536                    [param('ns3::Trailer const &', 'trailer')])

   537     ## packet.h: ns3::PacketMetadata::ItemIterator ns3::Packet::BeginItem() const [member function]

   538     cls.add_method('BeginItem',

   539                    'ns3::PacketMetadata::ItemIterator',

   540                    [],

   541                    is_const=True)

   542     ## packet.h: ns3::Ptr<ns3::Packet> ns3::Packet::Copy() const [member function]

   543     cls.add_method('Copy',

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

   545                    [],

   546                    is_const=True)

   547     ## packet.h: uint32_t ns3::Packet::CopyData(uint8_t * buffer, uint32_t size) const [member function]

   548     cls.add_method('CopyData',

   549                    'uint32_t',

   550                    [param('uint8_t *', 'buffer'), param('uint32_t', 'size')],

   551                    is_const=True)

   552     ## packet.h: void ns3::Packet::CopyData(std::ostream * os, uint32_t size) const [member function]

   553     cls.add_method('CopyData',

   554                    'void',

   555                    [param('std::ostream *', 'os'), param('uint32_t', 'size')],

   556                    is_const=True)

   557     ## packet.h: ns3::Ptr<ns3::Packet> ns3::Packet::CreateFragment(uint32_t start, uint32_t length) const [member function]

   558     cls.add_method('CreateFragment',

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

   560                    [param('uint32_t', 'start'), param('uint32_t', 'length')],

   561                    is_const=True)

   562     ## packet.h: void ns3::Packet::Deserialize(ns3::Buffer buffer) [member function]

   563     cls.add_method('Deserialize',

   564                    'void',

   565                    [param('ns3::Buffer', 'buffer')])

   566     ## packet.h: static void ns3::Packet::EnableChecking() [member function]

   567     cls.add_method('EnableChecking',

   568                    'void',

   569                    [],

   570                    is_static=True)

   571     ## packet.h: static void ns3::Packet::EnablePrinting() [member function]

   572     cls.add_method('EnablePrinting',

   573                    'void',

   574                    [],

   575                    is_static=True)

   576     ## packet.h: bool ns3::Packet::FindFirstMatchingByteTag(ns3::Tag & tag) const [member function]

   577     cls.add_method('FindFirstMatchingByteTag',

   578                    'bool',

   579                    [param('ns3::Tag &', 'tag')],

   580                    is_const=True)

   581     ## packet.h: ns3::ByteTagIterator ns3::Packet::GetByteTagIterator() const [member function]

   582     cls.add_method('GetByteTagIterator',

   583                    'ns3::ByteTagIterator',

   584                    [],

   585                    is_const=True)

   586     ## packet.h: ns3::PacketTagIterator ns3::Packet::GetPacketTagIterator() const [member function]

   587     cls.add_method('GetPacketTagIterator',

   588                    'ns3::PacketTagIterator',

   589                    [],

   590                    is_const=True)

   591     ## packet.h: uint32_t ns3::Packet::GetSize() const [member function]

   592     cls.add_method('GetSize',

   593                    'uint32_t',

   594                    [],

   595                    is_const=True)

   596     ## packet.h: uint32_t ns3::Packet::GetUid() const [member function]

   597     cls.add_method('GetUid',

   598                    'uint32_t',

   599                    [],

   600                    is_const=True)

   601     ## packet.h: uint8_t const * ns3::Packet::PeekData() const [member function]

   602     cls.add_method('PeekData',

   603                    'uint8_t const *',

   604                    [],

   605                    is_const=True)

   606     ## packet.h: uint32_t ns3::Packet::PeekHeader(ns3::Header & header) const [member function]

   607     cls.add_method('PeekHeader',

   608                    'uint32_t',

   609                    [param('ns3::Header &', 'header')],

   610                    is_const=True)

   611     ## packet.h: bool ns3::Packet::PeekPacketTag(ns3::Tag & tag) const [member function]

   612     cls.add_method('PeekPacketTag',

   613                    'bool',

   614                    [param('ns3::Tag &', 'tag')],

   615                    is_const=True)

   616     ## packet.h: uint32_t ns3::Packet::PeekTrailer(ns3::Trailer & trailer) [member function]

   617     cls.add_method('PeekTrailer',

   618                    'uint32_t',

   619                    [param('ns3::Trailer &', 'trailer')])

   620     ## packet.h: void ns3::Packet::Print(std::ostream & os) const [member function]

   621     cls.add_method('Print',

   622                    'void',

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

   624                    is_const=True)

   625     ## packet.h: void ns3::Packet::PrintByteTags(std::ostream & os) const [member function]

   626     cls.add_method('PrintByteTags',

   627                    'void',

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

   629                    is_const=True)

   630     ## packet.h: void ns3::Packet::PrintPacketTags(std::ostream & os) const [member function]

   631     cls.add_method('PrintPacketTags',

   632                    'void',

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

   634                    is_const=True)

   635     ## packet.h: void ns3::Packet::RemoveAllByteTags() [member function]

   636     cls.add_method('RemoveAllByteTags',

   637                    'void',

   638                    [])

   639     ## packet.h: void ns3::Packet::RemoveAllPacketTags() [member function]

   640     cls.add_method('RemoveAllPacketTags',

   641                    'void',

   642                    [])

   643     ## packet.h: void ns3::Packet::RemoveAtEnd(uint32_t size) [member function]

   644     cls.add_method('RemoveAtEnd',

   645                    'void',

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

   647     ## packet.h: void ns3::Packet::RemoveAtStart(uint32_t size) [member function]

   648     cls.add_method('RemoveAtStart',

   649                    'void',

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

   651     ## packet.h: uint32_t ns3::Packet::RemoveHeader(ns3::Header & header) [member function]

   652     cls.add_method('RemoveHeader',

   653                    'uint32_t',

   654                    [param('ns3::Header &', 'header')])

   655     ## packet.h: bool ns3::Packet::RemovePacketTag(ns3::Tag & tag) [member function]

   656     cls.add_method('RemovePacketTag',

   657                    'bool',

   658                    [param('ns3::Tag &', 'tag')])

   659     ## packet.h: uint32_t ns3::Packet::RemoveTrailer(ns3::Trailer & trailer) [member function]

   660     cls.add_method('RemoveTrailer',

   661                    'uint32_t',

   662                    [param('ns3::Trailer &', 'trailer')])

   663     ## packet.h: ns3::Buffer ns3::Packet::Serialize() const [member function]

   664     cls.add_method('Serialize',

   665                    'ns3::Buffer',

   666                    [],

   667                    is_const=True)

   668     return

   670 def register_Ns3PacketMetadata_methods(root_module, cls):

   671     ## packet-metadata.h: static void ns3::PacketMetadata::Enable() [member function]

   672     cls.add_method('Enable',

   673                    'void',

   674                    [],

   675                    is_static=True)

   676     ## packet-metadata.h: static void ns3::PacketMetadata::EnableChecking() [member function]

   677     cls.add_method('EnableChecking',

   678                    'void',

   679                    [],

   680                    is_static=True)

   681     ## packet-metadata.h: ns3::PacketMetadata::PacketMetadata(uint32_t uid, uint32_t size) [constructor]

   682     cls.add_constructor([param('uint32_t', 'uid'), param('uint32_t', 'size')])

   683     ## packet-metadata.h: ns3::PacketMetadata::PacketMetadata(ns3::PacketMetadata const & o) [copy constructor]

   684     cls.add_constructor([param('ns3::PacketMetadata const &', 'o')])

   685     ## packet-metadata.h: void ns3::PacketMetadata::AddHeader(ns3::Header const & header, uint32_t size) [member function]

   686     cls.add_method('AddHeader',

   687                    'void',

   688                    [param('ns3::Header const &', 'header'), param('uint32_t', 'size')])

   689     ## packet-metadata.h: void ns3::PacketMetadata::RemoveHeader(ns3::Header const & header, uint32_t size) [member function]

   690     cls.add_method('RemoveHeader',

   691                    'void',

   692                    [param('ns3::Header const &', 'header'), param('uint32_t', 'size')])

   693     ## packet-metadata.h: void ns3::PacketMetadata::AddTrailer(ns3::Trailer const & trailer, uint32_t size) [member function]

   694     cls.add_method('AddTrailer',

   695                    'void',

   696                    [param('ns3::Trailer const &', 'trailer'), param('uint32_t', 'size')])

   697     ## packet-metadata.h: void ns3::PacketMetadata::RemoveTrailer(ns3::Trailer const & trailer, uint32_t size) [member function]

   698     cls.add_method('RemoveTrailer',

   699                    'void',

   700                    [param('ns3::Trailer const &', 'trailer'), param('uint32_t', 'size')])

   701     ## packet-metadata.h: ns3::PacketMetadata ns3::PacketMetadata::CreateFragment(uint32_t start, uint32_t end) const [member function]

   702     cls.add_method('CreateFragment',

   703                    'ns3::PacketMetadata',

   704                    [param('uint32_t', 'start'), param('uint32_t', 'end')],

   705                    is_const=True)

   706     ## packet-metadata.h: void ns3::PacketMetadata::AddAtEnd(ns3::PacketMetadata const & o) [member function]

   707     cls.add_method('AddAtEnd',

   708                    'void',

   709                    [param('ns3::PacketMetadata const &', 'o')])

   710     ## packet-metadata.h: void ns3::PacketMetadata::AddPaddingAtEnd(uint32_t end) [member function]

   711     cls.add_method('AddPaddingAtEnd',

   712                    'void',

   713                    [param('uint32_t', 'end')])

   714     ## packet-metadata.h: void ns3::PacketMetadata::RemoveAtStart(uint32_t start) [member function]

   715     cls.add_method('RemoveAtStart',

   716                    'void',

   717                    [param('uint32_t', 'start')])

   718     ## packet-metadata.h: void ns3::PacketMetadata::RemoveAtEnd(uint32_t end) [member function]

   719     cls.add_method('RemoveAtEnd',

   720                    'void',

   721                    [param('uint32_t', 'end')])

   722     ## packet-metadata.h: uint32_t ns3::PacketMetadata::GetUid() const [member function]

   723     cls.add_method('GetUid',

   724                    'uint32_t',

   725                    [],

   726                    is_const=True)

   727     ## packet-metadata.h: uint32_t ns3::PacketMetadata::GetSerializedSize() const [member function]

   728     cls.add_method('GetSerializedSize',

   729                    'uint32_t',

   730                    [],

   731                    is_const=True)

   732     ## packet-metadata.h: void ns3::PacketMetadata::Serialize(ns3::Buffer::Iterator i, uint32_t size) const [member function]

   733     cls.add_method('Serialize',

   734                    'void',

   735                    [param('ns3::Buffer::Iterator', 'i'), param('uint32_t', 'size')],

   736                    is_const=True)

   737     ## packet-metadata.h: uint32_t ns3::PacketMetadata::Deserialize(ns3::Buffer::Iterator i) [member function]

   738     cls.add_method('Deserialize',

   739                    'uint32_t',

   740                    [param('ns3::Buffer::Iterator', 'i')])

   741     ## packet-metadata.h: ns3::PacketMetadata::ItemIterator ns3::PacketMetadata::BeginItem(ns3::Buffer buffer) const [member function]

   742     cls.add_method('BeginItem',

   743                    'ns3::PacketMetadata::ItemIterator',

   744                    [param('ns3::Buffer', 'buffer')],

   745                    is_const=True)

   746     return

   748 def register_Ns3PacketMetadataItem_methods(root_module, cls):

   749     ## packet-metadata.h: ns3::PacketMetadata::Item::isFragment [variable]

   750     cls.add_instance_attribute('isFragment', 'bool', is_const=False)

   751     ## packet-metadata.h: ns3::PacketMetadata::Item::tid [variable]

   752     cls.add_instance_attribute('tid', 'ns3::TypeId', is_const=False)

   753     ## packet-metadata.h: ns3::PacketMetadata::Item::currentSize [variable]

   754     cls.add_instance_attribute('currentSize', 'uint32_t', is_const=False)

   755     ## packet-metadata.h: ns3::PacketMetadata::Item::currentTrimedFromStart [variable]

   756     cls.add_instance_attribute('currentTrimedFromStart', 'uint32_t', is_const=False)

   757     ## packet-metadata.h: ns3::PacketMetadata::Item::currentTrimedFromEnd [variable]

   758     cls.add_instance_attribute('currentTrimedFromEnd', 'uint32_t', is_const=False)

   759     ## packet-metadata.h: ns3::PacketMetadata::Item::current [variable]

   760     cls.add_instance_attribute('current', 'ns3::Buffer::Iterator', is_const=False)

   761     ## packet-metadata.h: ns3::PacketMetadata::Item::Item(ns3::PacketMetadata::Item const & arg0) [copy constructor]

   762     cls.add_constructor([param('ns3::PacketMetadata::Item const &', 'arg0')])

   763     ## packet-metadata.h: ns3::PacketMetadata::Item::Item() [constructor]

   764     cls.add_constructor([])

   765     return

   767 def register_Ns3PacketMetadataItemIterator_methods(root_module, cls):

   768     ## packet-metadata.h: ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata::ItemIterator const & arg0) [copy constructor]

   769     cls.add_constructor([param('ns3::PacketMetadata::ItemIterator const &', 'arg0')])

   770     ## packet-metadata.h: ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata const * metadata, ns3::Buffer buffer) [constructor]

   771     cls.add_constructor([param('ns3::PacketMetadata const *', 'metadata'), param('ns3::Buffer', 'buffer')])

   772     ## packet-metadata.h: bool ns3::PacketMetadata::ItemIterator::HasNext() const [member function]

   773     cls.add_method('HasNext',

   774                    'bool',

   775                    [],

   776                    is_const=True)

   777     ## packet-metadata.h: ns3::PacketMetadata::Item ns3::PacketMetadata::ItemIterator::Next() [member function]

   778     cls.add_method('Next',

   779                    'ns3::PacketMetadata::Item',

   780                    [])

   781     return

   783 def register_Ns3PacketTagIterator_methods(root_module, cls):

   784     ## packet.h: ns3::PacketTagIterator::PacketTagIterator(ns3::PacketTagIterator const & arg0) [copy constructor]

   785     cls.add_constructor([param('ns3::PacketTagIterator const &', 'arg0')])

   786     ## packet.h: bool ns3::PacketTagIterator::HasNext() const [member function]

   787     cls.add_method('HasNext',

   788                    'bool',

   789                    [],

   790                    is_const=True)

   791     ## packet.h: ns3::PacketTagIterator::Item ns3::PacketTagIterator::Next() [member function]

   792     cls.add_method('Next',

   793                    'ns3::PacketTagIterator::Item',

   794                    [])

   795     return

   797 def register_Ns3PacketTagIteratorItem_methods(root_module, cls):

   798     ## packet.h: ns3::PacketTagIterator::Item::Item(ns3::PacketTagIterator::Item const & arg0) [copy constructor]

   799     cls.add_constructor([param('ns3::PacketTagIterator::Item const &', 'arg0')])

   800     ## packet.h: ns3::TypeId ns3::PacketTagIterator::Item::GetTypeId() const [member function]

   801     cls.add_method('GetTypeId',

   802                    'ns3::TypeId',

   803                    [],

   804                    is_const=True)

   805     ## packet.h: void ns3::PacketTagIterator::Item::GetTag(ns3::Tag & tag) const [member function]

   806     cls.add_method('GetTag',

   807                    'void',

   808                    [param('ns3::Tag &', 'tag')],

   809                    is_const=True)

   810     return

   812 def register_Ns3PacketTagList_methods(root_module, cls):

   813     ## packet-tag-list.h: ns3::PacketTagList::PacketTagList() [constructor]

   814     cls.add_constructor([])

   815     ## packet-tag-list.h: ns3::PacketTagList::PacketTagList(ns3::PacketTagList const & o) [copy constructor]

   816     cls.add_constructor([param('ns3::PacketTagList const &', 'o')])

   817     ## packet-tag-list.h: void ns3::PacketTagList::Add(ns3::Tag const & tag) const [member function]

   818     cls.add_method('Add',

   819                    'void',

   820                    [param('ns3::Tag const &', 'tag')],

   821                    is_const=True)

   822     ## packet-tag-list.h: bool ns3::PacketTagList::Remove(ns3::Tag & tag) [member function]

   823     cls.add_method('Remove',

   824                    'bool',

   825                    [param('ns3::Tag &', 'tag')])

   826     ## packet-tag-list.h: bool ns3::PacketTagList::Peek(ns3::Tag & tag) const [member function]

   827     cls.add_method('Peek',

   828                    'bool',

   829                    [param('ns3::Tag &', 'tag')],

   830                    is_const=True)

   831     ## packet-tag-list.h: void ns3::PacketTagList::RemoveAll() [member function]

   832     cls.add_method('RemoveAll',

   833                    'void',

   834                    [])

   835     ## packet-tag-list.h: ns3::PacketTagList::TagData const * ns3::PacketTagList::Head() const [member function]

   836     cls.add_method('Head',

   837                    'ns3::PacketTagList::TagData const *',

   838                    [],

   839                    is_const=True)

   840     return

   842 def register_Ns3PacketTagListTagData_methods(root_module, cls):

   843     ## packet-tag-list.h: ns3::PacketTagList::TagData::data [variable]

   844     cls.add_instance_attribute('data', 'uint8_t [ 20 ]', is_const=False)

   845     ## packet-tag-list.h: ns3::PacketTagList::TagData::next [variable]

   846     cls.add_instance_attribute('next', 'ns3::PacketTagList::TagData *', is_const=False)

   847     ## packet-tag-list.h: ns3::PacketTagList::TagData::tid [variable]

   848     cls.add_instance_attribute('tid', 'ns3::TypeId', is_const=False)

   849     ## packet-tag-list.h: ns3::PacketTagList::TagData::count [variable]

   850     cls.add_instance_attribute('count', 'uint32_t', is_const=False)

   851     ## packet-tag-list.h: ns3::PacketTagList::TagData::TagData(ns3::PacketTagList::TagData const & arg0) [copy constructor]

   852     cls.add_constructor([param('ns3::PacketTagList::TagData const &', 'arg0')])

   853     ## packet-tag-list.h: ns3::PacketTagList::TagData::TagData() [constructor]

   854     cls.add_constructor([])

   855     return

   857 def register_Ns3Tag_methods(root_module, cls):

   858     ## tag.h: ns3::Tag::Tag(ns3::Tag const & arg0) [copy constructor]

   859     cls.add_constructor([param('ns3::Tag const &', 'arg0')])

   860     ## tag.h: ns3::Tag::Tag() [constructor]

   861     cls.add_constructor([])

   862     ## tag.h: static ns3::TypeId ns3::Tag::GetTypeId() [member function]

   863     cls.add_method('GetTypeId',

   864                    'ns3::TypeId',

   865                    [],

   866                    is_static=True)

   867     ## tag.h: uint32_t ns3::Tag::GetSerializedSize() const [member function]

   868     cls.add_method('GetSerializedSize',

   869                    'uint32_t',

   870                    [],

   871                    is_pure_virtual=True, is_const=True, is_virtual=True)

   872     ## tag.h: void ns3::Tag::Serialize(ns3::TagBuffer i) const [member function]

   873     cls.add_method('Serialize',

   874                    'void',

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

   876                    is_pure_virtual=True, is_const=True, is_virtual=True)

   877     ## tag.h: void ns3::Tag::Deserialize(ns3::TagBuffer i) [member function]

   878     cls.add_method('Deserialize',

   879                    'void',

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

   881                    is_pure_virtual=True, is_virtual=True)

   882     ## tag.h: void ns3::Tag::Print(std::ostream & os) const [member function]

   883     cls.add_method('Print',

   884                    'void',

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

   886                    is_pure_virtual=True, is_const=True, is_virtual=True)

   887     return

   889 def register_Ns3TagBuffer_methods(root_module, cls):

   890     ## tag-buffer.h: ns3::TagBuffer::TagBuffer(ns3::TagBuffer const & arg0) [copy constructor]

   891     cls.add_constructor([param('ns3::TagBuffer const &', 'arg0')])

   892     ## tag-buffer.h: ns3::TagBuffer::TagBuffer(uint8_t * start, uint8_t * end) [constructor]

   893     cls.add_constructor([param('uint8_t *', 'start'), param('uint8_t *', 'end')])

   894     ## tag-buffer.h: void ns3::TagBuffer::TrimAtEnd(uint32_t trim) [member function]

   895     cls.add_method('TrimAtEnd',

   896                    'void',

   897                    [param('uint32_t', 'trim')])

   898     ## tag-buffer.h: void ns3::TagBuffer::CopyFrom(ns3::TagBuffer o) [member function]

   899     cls.add_method('CopyFrom',

   900                    'void',

   901                    [param('ns3::TagBuffer', 'o')])

   902     ## tag-buffer.h: void ns3::TagBuffer::WriteU8(uint8_t v) [member function]

   903     cls.add_method('WriteU8',

   904                    'void',

   905                    [param('uint8_t', 'v')])

   906     ## tag-buffer.h: void ns3::TagBuffer::WriteU16(uint16_t data) [member function]

   907     cls.add_method('WriteU16',

   908                    'void',

   909                    [param('uint16_t', 'data')])

   910     ## tag-buffer.h: void ns3::TagBuffer::WriteU32(uint32_t data) [member function]

   911     cls.add_method('WriteU32',

   912                    'void',

   913                    [param('uint32_t', 'data')])

   914     ## tag-buffer.h: void ns3::TagBuffer::WriteU64(uint64_t v) [member function]

   915     cls.add_method('WriteU64',

   916                    'void',

   917                    [param('uint64_t', 'v')])

   918     ## tag-buffer.h: void ns3::TagBuffer::WriteDouble(double v) [member function]

   919     cls.add_method('WriteDouble',

   920                    'void',

   921                    [param('double', 'v')])

   922     ## tag-buffer.h: void ns3::TagBuffer::Write(uint8_t const * buffer, uint32_t size) [member function]

   923     cls.add_method('Write',

   924                    'void',

   925                    [param('uint8_t const *', 'buffer'), param('uint32_t', 'size')])

   926     ## tag-buffer.h: uint8_t ns3::TagBuffer::ReadU8() [member function]

   927     cls.add_method('ReadU8',

   928                    'uint8_t',

   929                    [])

   930     ## tag-buffer.h: uint16_t ns3::TagBuffer::ReadU16() [member function]

   931     cls.add_method('ReadU16',

   932                    'uint16_t',

   933                    [])

   934     ## tag-buffer.h: uint32_t ns3::TagBuffer::ReadU32() [member function]

   935     cls.add_method('ReadU32',

   936                    'uint32_t',

   937                    [])

   938     ## tag-buffer.h: uint64_t ns3::TagBuffer::ReadU64() [member function]

   939     cls.add_method('ReadU64',

   940                    'uint64_t',

   941                    [])

   942     ## tag-buffer.h: double ns3::TagBuffer::ReadDouble() [member function]

   943     cls.add_method('ReadDouble',

   944                    'double',

   945                    [])

   946     ## tag-buffer.h: void ns3::TagBuffer::Read(uint8_t * buffer, uint32_t size) [member function]

   947     cls.add_method('Read',

   948                    'void',

   949                    [param('uint8_t *', 'buffer'), param('uint32_t', 'size')])

   950     return

   952 def register_Ns3Chunk_methods(root_module, cls):

   953     ## chunk.h: ns3::Chunk::Chunk(ns3::Chunk const & arg0) [copy constructor]

   954     cls.add_constructor([param('ns3::Chunk const &', 'arg0')])

   955     ## chunk.h: ns3::Chunk::Chunk() [constructor]

   956     cls.add_constructor([])

   957     ## chunk.h: static ns3::TypeId ns3::Chunk::GetTypeId() [member function]

   958     cls.add_method('GetTypeId',

   959                    'ns3::TypeId',

   960                    [],

   961                    is_static=True)

   962     ## chunk.h: uint32_t ns3::Chunk::Deserialize(ns3::Buffer::Iterator start) [member function]

   963     cls.add_method('Deserialize',

   964                    'uint32_t',

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

   966                    is_pure_virtual=True, is_virtual=True)

   967     ## chunk.h: void ns3::Chunk::Print(std::ostream & os) const [member function]

   968     cls.add_method('Print',

   969                    'void',

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

   971                    is_pure_virtual=True, is_const=True, is_virtual=True)

   972     return

   974 def register_Ns3DataRateChecker_methods(root_module, cls):

   975     ## data-rate.h: ns3::DataRateChecker::DataRateChecker(ns3::DataRateChecker const & arg0) [copy constructor]

   976     cls.add_constructor([param('ns3::DataRateChecker const &', 'arg0')])

   977     ## data-rate.h: ns3::DataRateChecker::DataRateChecker() [constructor]

   978     cls.add_constructor([])

   979     return

   981 def register_Ns3DataRateValue_methods(root_module, cls):

   982     ## data-rate.h: ns3::DataRateValue::DataRateValue(ns3::DataRateValue const & arg0) [copy constructor]

   983     cls.add_constructor([param('ns3::DataRateValue const &', 'arg0')])

   984     ## data-rate.h: ns3::DataRateValue::DataRateValue() [constructor]

   985     cls.add_constructor([])

   986     ## data-rate.h: ns3::DataRateValue::DataRateValue(ns3::DataRate const & value) [constructor]

   987     cls.add_constructor([param('ns3::DataRate const &', 'value')])

   988     ## data-rate.h: void ns3::DataRateValue::Set(ns3::DataRate const & value) [member function]

   989     cls.add_method('Set',

   990                    'void',

   991                    [param('ns3::DataRate const &', 'value')])

   992     ## data-rate.h: ns3::DataRate ns3::DataRateValue::Get() const [member function]

   993     cls.add_method('Get',

   994                    'ns3::DataRate',

   995                    [],

   996                    is_const=True)

   997     ## data-rate.h: ns3::Ptr<ns3::AttributeValue> ns3::DataRateValue::Copy() const [member function]

   998     cls.add_method('Copy',

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

  1000                    [],

  1001                    is_const=True, is_virtual=True)

  1002     ## data-rate.h: std::string ns3::DataRateValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

  1003     cls.add_method('SerializeToString',

  1004                    'std::string',

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

  1006                    is_const=True, is_virtual=True)

  1007     ## data-rate.h: bool ns3::DataRateValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

  1008     cls.add_method('DeserializeFromString',

  1009                    'bool',

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

  1011                    is_virtual=True)

  1012     return

  1014 def register_Ns3Header_methods(root_module, cls):

  1015     cls.add_output_stream_operator()

  1016     ## header.h: ns3::Header::Header() [constructor]

  1017     cls.add_constructor([])

  1018     ## header.h: ns3::Header::Header(ns3::Header const & arg0) [copy constructor]

  1019     cls.add_constructor([param('ns3::Header const &', 'arg0')])

  1020     ## header.h: uint32_t ns3::Header::Deserialize(ns3::Buffer::Iterator start) [member function]

  1021     cls.add_method('Deserialize',

  1022                    'uint32_t',

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

  1024                    is_pure_virtual=True, is_virtual=True)

  1025     ## header.h: uint32_t ns3::Header::GetSerializedSize() const [member function]

  1026     cls.add_method('GetSerializedSize',

  1027                    'uint32_t',

  1028                    [],

  1029                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1030     ## header.h: static ns3::TypeId ns3::Header::GetTypeId() [member function]

  1031     cls.add_method('GetTypeId',

  1032                    'ns3::TypeId',

  1033                    [],

  1034                    is_static=True)

  1035     ## header.h: void ns3::Header::Print(std::ostream & os) const [member function]

  1036     cls.add_method('Print',

  1037                    'void',

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

  1039                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1040     ## header.h: void ns3::Header::Serialize(ns3::Buffer::Iterator start) const [member function]

  1041     cls.add_method('Serialize',

  1042                    'void',

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

  1044                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1045     return

  1047 def register_Ns3PcapWriter_methods(root_module, cls):

  1048     ## pcap-writer.h: ns3::PcapWriter::PcapWriter(ns3::PcapWriter const & arg0) [copy constructor]

  1049     cls.add_constructor([param('ns3::PcapWriter const &', 'arg0')])

  1050     ## pcap-writer.h: ns3::PcapWriter::PcapWriter() [constructor]

  1051     cls.add_constructor([])

  1052     ## pcap-writer.h: void ns3::PcapWriter::Open(std::string const & name) [member function]

  1053     cls.add_method('Open',

  1054                    'void',

  1055                    [param('std::string const &', 'name')])

  1056     ## pcap-writer.h: void ns3::PcapWriter::WriteEthernetHeader() [member function]

  1057     cls.add_method('WriteEthernetHeader',

  1058                    'void',

  1059                    [])

  1060     ## pcap-writer.h: void ns3::PcapWriter::WriteIpHeader() [member function]

  1061     cls.add_method('WriteIpHeader',

  1062                    'void',

  1063                    [])

  1064     ## pcap-writer.h: void ns3::PcapWriter::WriteWifiHeader() [member function]

  1065     cls.add_method('WriteWifiHeader',

  1066                    'void',

  1067                    [])

  1068     ## pcap-writer.h: void ns3::PcapWriter::WriteWifiRadiotapHeader() [member function]

  1069     cls.add_method('WriteWifiRadiotapHeader',

  1070                    'void',

  1071                    [])

  1072     ## pcap-writer.h: void ns3::PcapWriter::WriteWifiPrismHeader() [member function]

  1073     cls.add_method('WriteWifiPrismHeader',

  1074                    'void',

  1075                    [])

  1076     ## pcap-writer.h: void ns3::PcapWriter::WritePppHeader() [member function]

  1077     cls.add_method('WritePppHeader',

  1078                    'void',

  1079                    [])

  1080     ## pcap-writer.h: void ns3::PcapWriter::WritePacket(ns3::Ptr<ns3::Packet const> packet) [member function]

  1081     cls.add_method('WritePacket',

  1082                    'void',

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

  1084     ## pcap-writer.h: void ns3::PcapWriter::WriteWifiMonitorPacket(ns3::Ptr<ns3::Packet const> packet, uint16_t channelFreqMhz, uint32_t rate, bool isShortPreamble, bool isTx, double signalDbm, double noiseDbm) [member function]

  1085     cls.add_method('WriteWifiMonitorPacket',

  1086                    'void',

  1087                    [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('uint16_t', 'channelFreqMhz'), param('uint32_t', 'rate'), param('bool', 'isShortPreamble'), param('bool', 'isTx'), param('double', 'signalDbm'), param('double', 'noiseDbm')])

  1088     return

  1090 def register_Ns3Trailer_methods(root_module, cls):

  1091     cls.add_output_stream_operator()

  1092     ## trailer.h: ns3::Trailer::Trailer() [constructor]

  1093     cls.add_constructor([])

  1094     ## trailer.h: ns3::Trailer::Trailer(ns3::Trailer const & arg0) [copy constructor]

  1095     cls.add_constructor([param('ns3::Trailer const &', 'arg0')])

  1096     ## trailer.h: uint32_t ns3::Trailer::Deserialize(ns3::Buffer::Iterator end) [member function]

  1097     cls.add_method('Deserialize',

  1098                    'uint32_t',

  1099                    [param('ns3::Buffer::Iterator', 'end')],

  1100                    is_pure_virtual=True, is_virtual=True)

  1101     ## trailer.h: uint32_t ns3::Trailer::GetSerializedSize() const [member function]

  1102     cls.add_method('GetSerializedSize',

  1103                    'uint32_t',

  1104                    [],

  1105                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1106     ## trailer.h: static ns3::TypeId ns3::Trailer::GetTypeId() [member function]

  1107     cls.add_method('GetTypeId',

  1108                    'ns3::TypeId',

  1109                    [],

  1110                    is_static=True)

  1111     ## trailer.h: void ns3::Trailer::Print(std::ostream & os) const [member function]

  1112     cls.add_method('Print',

  1113                    'void',

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

  1115                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1116     ## trailer.h: void ns3::Trailer::Serialize(ns3::Buffer::Iterator start) const [member function]

  1117     cls.add_method('Serialize',

  1118                    'void',

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

  1120                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1121     return

  1123 def register_Ns3ErrorModel_methods(root_module, cls):

  1124     ## error-model.h: ns3::ErrorModel::ErrorModel(ns3::ErrorModel const & arg0) [copy constructor]

  1125     cls.add_constructor([param('ns3::ErrorModel const &', 'arg0')])

  1126     ## error-model.h: static ns3::TypeId ns3::ErrorModel::GetTypeId() [member function]

  1127     cls.add_method('GetTypeId',

  1128                    'ns3::TypeId',

  1129                    [],

  1130                    is_static=True)

  1131     ## error-model.h: ns3::ErrorModel::ErrorModel() [constructor]

  1132     cls.add_constructor([])

  1133     ## error-model.h: bool ns3::ErrorModel::IsCorrupt(ns3::Ptr<ns3::Packet> pkt) [member function]

  1134     cls.add_method('IsCorrupt',

  1135                    'bool',

  1136                    [param('ns3::Ptr< ns3::Packet >', 'pkt')])

  1137     ## error-model.h: void ns3::ErrorModel::Reset() [member function]

  1138     cls.add_method('Reset',

  1139                    'void',

  1140                    [])

  1141     ## error-model.h: void ns3::ErrorModel::Enable() [member function]

  1142     cls.add_method('Enable',

  1143                    'void',

  1144                    [])

  1145     ## error-model.h: void ns3::ErrorModel::Disable() [member function]

  1146     cls.add_method('Disable',

  1147                    'void',

  1148                    [])

  1149     ## error-model.h: bool ns3::ErrorModel::IsEnabled() const [member function]

  1150     cls.add_method('IsEnabled',

  1151                    'bool',

  1152                    [],

  1153                    is_const=True)

  1154     ## error-model.h: bool ns3::ErrorModel::DoCorrupt(ns3::Ptr<ns3::Packet> arg0) [member function]

  1155     cls.add_method('DoCorrupt',

  1156                    'bool',

  1157                    [param('ns3::Ptr< ns3::Packet >', 'arg0')],

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

  1159     ## error-model.h: void ns3::ErrorModel::DoReset() [member function]

  1160     cls.add_method('DoReset',

  1161                    'void',

  1162                    [],

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

  1164     return

  1166 def register_Ns3ListErrorModel_methods(root_module, cls):

  1167     ## error-model.h: ns3::ListErrorModel::ListErrorModel(ns3::ListErrorModel const & arg0) [copy constructor]

  1168     cls.add_constructor([param('ns3::ListErrorModel const &', 'arg0')])

  1169     ## error-model.h: static ns3::TypeId ns3::ListErrorModel::GetTypeId() [member function]

  1170     cls.add_method('GetTypeId',

  1171                    'ns3::TypeId',

  1172                    [],

  1173                    is_static=True)

  1174     ## error-model.h: ns3::ListErrorModel::ListErrorModel() [constructor]

  1175     cls.add_constructor([])

  1176     ## error-model.h: std::list<unsigned int, std::allocator<unsigned int> > ns3::ListErrorModel::GetList() const [member function]

  1177     cls.add_method('GetList',

  1178                    'std::list< unsigned int >',

  1179                    [],

  1180                    is_const=True)

  1181     ## error-model.h: void ns3::ListErrorModel::SetList(std::list<unsigned int, std::allocator<unsigned int> > const & packetlist) [member function]

  1182     cls.add_method('SetList',

  1183                    'void',

  1184                    [param('std::list< unsigned int > const &', 'packetlist')])

  1185     ## error-model.h: bool ns3::ListErrorModel::DoCorrupt(ns3::Ptr<ns3::Packet> p) [member function]

  1186     cls.add_method('DoCorrupt',

  1187                    'bool',

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

  1189                    visibility='private', is_virtual=True)

  1190     ## error-model.h: void ns3::ListErrorModel::DoReset() [member function]

  1191     cls.add_method('DoReset',

  1192                    'void',

  1193                    [],

  1194                    visibility='private', is_virtual=True)

  1195     return

  1197 def register_Ns3RateErrorModel_methods(root_module, cls):

  1198     ## error-model.h: ns3::RateErrorModel::RateErrorModel(ns3::RateErrorModel const & arg0) [copy constructor]

  1199     cls.add_constructor([param('ns3::RateErrorModel const &', 'arg0')])

  1200     ## error-model.h: static ns3::TypeId ns3::RateErrorModel::GetTypeId() [member function]

  1201     cls.add_method('GetTypeId',

  1202                    'ns3::TypeId',

  1203                    [],

  1204                    is_static=True)

  1205     ## error-model.h: ns3::RateErrorModel::RateErrorModel() [constructor]

  1206     cls.add_constructor([])

  1207     ## error-model.h: ns3::ErrorUnit ns3::RateErrorModel::GetUnit() const [member function]

  1208     cls.add_method('GetUnit',

  1209                    'ns3::ErrorUnit',

  1210                    [],

  1211                    is_const=True)

  1212     ## error-model.h: void ns3::RateErrorModel::SetUnit(ns3::ErrorUnit error_unit) [member function]

  1213     cls.add_method('SetUnit',

  1214                    'void',

  1215                    [param('ns3::ErrorUnit', 'error_unit')])

  1216     ## error-model.h: double ns3::RateErrorModel::GetRate() const [member function]

  1217     cls.add_method('GetRate',

  1218                    'double',

  1219                    [],

  1220                    is_const=True)

  1221     ## error-model.h: void ns3::RateErrorModel::SetRate(double rate) [member function]

  1222     cls.add_method('SetRate',

  1223                    'void',

  1224                    [param('double', 'rate')])

  1225     ## error-model.h: void ns3::RateErrorModel::SetRandomVariable(ns3::RandomVariable const & ranvar) [member function]

  1226     cls.add_method('SetRandomVariable',

  1227                    'void',

  1228                    [param('ns3::RandomVariable const &', 'ranvar')])

  1229     ## error-model.h: bool ns3::RateErrorModel::DoCorrupt(ns3::Ptr<ns3::Packet> p) [member function]

  1230     cls.add_method('DoCorrupt',

  1231                    'bool',

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

  1233                    visibility='private', is_virtual=True)

  1234     ## error-model.h: bool ns3::RateErrorModel::DoCorruptPkt(ns3::Ptr<ns3::Packet> p) [member function]

  1235     cls.add_method('DoCorruptPkt',

  1236                    'bool',

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

  1238                    visibility='private', is_virtual=True)

  1239     ## error-model.h: bool ns3::RateErrorModel::DoCorruptByte(ns3::Ptr<ns3::Packet> p) [member function]

  1240     cls.add_method('DoCorruptByte',

  1241                    'bool',

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

  1243                    visibility='private', is_virtual=True)

  1244     ## error-model.h: bool ns3::RateErrorModel::DoCorruptBit(ns3::Ptr<ns3::Packet> p) [member function]

  1245     cls.add_method('DoCorruptBit',

  1246                    'bool',

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

  1248                    visibility='private', is_virtual=True)

  1249     ## error-model.h: void ns3::RateErrorModel::DoReset() [member function]

  1250     cls.add_method('DoReset',

  1251                    'void',

  1252                    [],

  1253                    visibility='private', is_virtual=True)

  1254     return

  1256 def register_functions(root_module):

  1257     module = root_module

  1258     ## data-rate.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeDataRateChecker() [free function]

  1259     module.add_function('MakeDataRateChecker',

  1260                         'ns3::Ptr< ns3::AttributeChecker const >',

  1261                         [])

  1262     register_functions_ns3_Config(module.get_submodule('Config'), root_module)

  1263     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)

  1264     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)

  1265     register_functions_ns3_internal(module.get_submodule('internal'), root_module)

  1266     register_functions_ns3_olsr(module.get_submodule('olsr'), root_module)

  1267     return

  1269 def register_functions_ns3_Config(module, root_module):

  1270     return

  1272 def register_functions_ns3_TimeStepPrecision(module, root_module):

  1273     return

  1275 def register_functions_ns3_addressUtils(module, root_module):

  1276     return

  1278 def register_functions_ns3_internal(module, root_module):

  1279     return

  1281 def register_functions_ns3_olsr(module, root_module):

  1282     return

author	Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
	Sat, 04 Jul 2009 08:15:48 +0200
changeset 4654	2eaebe77d66b
parent 4505	e865dbc1d157
permissions	-rw-r--r--