ns-3.5: bindings/python/ns3_module_common.py@debf1a8a96d3

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

     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     ## data-rate.h: ns3::DataRate [class]

    13     module.add_class('DataRate')

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

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

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

    17     module.add_class('PacketMetadata')

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

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

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

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

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

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

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

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

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

    27     module.add_class('TagBuffer')

    28     ## packet.h: ns3::TagIterator [class]

    29     module.add_class('TagIterator')

    30     ## packet.h: ns3::TagIterator::Item [class]

    31     module.add_class('Item', outer_class=root_module['ns3::TagIterator'])

    32     ## tag-list.h: ns3::TagList [class]

    33     module.add_class('TagList')

    34     ## tag-list.h: ns3::TagList::Iterator [class]

    35     module.add_class('Iterator', outer_class=root_module['ns3::TagList'])

    36     ## tag-list.h: ns3::TagList::Iterator::Item [struct]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    57     ## Register a nested module for the namespace Config

    59     nested_module = module.add_cpp_namespace('Config')

    60     register_types_ns3_Config(nested_module)

    63     ## Register a nested module for the namespace TimeStepPrecision

    65     nested_module = module.add_cpp_namespace('TimeStepPrecision')

    66     register_types_ns3_TimeStepPrecision(nested_module)

    69     ## Register a nested module for the namespace internal

    71     nested_module = module.add_cpp_namespace('internal')

    72     register_types_ns3_internal(nested_module)

    75     ## Register a nested module for the namespace olsr

    77     nested_module = module.add_cpp_namespace('olsr')

    78     register_types_ns3_olsr(nested_module)

    81 def register_types_ns3_Config(module):

    82     root_module = module.get_root()

    85 def register_types_ns3_TimeStepPrecision(module):

    86     root_module = module.get_root()

    89 def register_types_ns3_internal(module):

    90     root_module = module.get_root()

    93 def register_types_ns3_olsr(module):

    94     root_module = module.get_root()

    97 def register_methods(root_module):

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

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

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

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

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

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

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

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

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

   107     register_Ns3TagIterator_methods(root_module, root_module['ns3::TagIterator'])

   108     register_Ns3TagIteratorItem_methods(root_module, root_module['ns3::TagIterator::Item'])

   109     register_Ns3TagList_methods(root_module, root_module['ns3::TagList'])

   110     register_Ns3TagListIterator_methods(root_module, root_module['ns3::TagList::Iterator'])

   111     register_Ns3TagListIteratorItem_methods(root_module, root_module['ns3::TagList::Iterator::Item'])

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

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

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

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

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

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

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

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

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

   121     return

   123 def register_Ns3Buffer_methods(root_module, cls):

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

   125     cls.add_method('GetSize',

   126                    'uint32_t',

   127                    [],

   128                    is_const=True)

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

   130     cls.add_method('PeekData',

   131                    'uint8_t const *',

   132                    [],

   133                    is_const=True)

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

   135     cls.add_method('AddAtStart',

   136                    'bool',

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

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

   139     cls.add_method('AddAtEnd',

   140                    'bool',

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

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

   143     cls.add_method('AddAtEnd',

   144                    'void',

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

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

   147     cls.add_method('RemoveAtStart',

   148                    'void',

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

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

   151     cls.add_method('RemoveAtEnd',

   152                    'void',

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

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

   155     cls.add_method('CreateFragment',

   156                    'ns3::Buffer',

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

   158                    is_const=True)

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

   160     cls.add_method('Begin',

   161                    'ns3::Buffer::Iterator',

   162                    [],

   163                    is_const=True)

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

   165     cls.add_method('End',

   166                    'ns3::Buffer::Iterator',

   167                    [],

   168                    is_const=True)

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

   170     cls.add_method('CreateFullCopy',

   171                    'ns3::Buffer',

   172                    [],

   173                    is_const=True)

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

   175     cls.add_method('GetCurrentStartOffset',

   176                    'int32_t',

   177                    [],

   178                    is_const=True)

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

   180     cls.add_method('GetCurrentEndOffset',

   181                    'int32_t',

   182                    [],

   183                    is_const=True)

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

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

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

   187     cls.add_constructor([])

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

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

   190     return

   192 def register_Ns3BufferIterator_methods(root_module, cls):

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

   194     cls.add_constructor([])

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

   196     cls.add_method('Next',

   197                    'void',

   198                    [])

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

   200     cls.add_method('Prev',

   201                    'void',

   202                    [])

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

   204     cls.add_method('Next',

   205                    'void',

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

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

   208     cls.add_method('Prev',

   209                    'void',

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

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

   212     cls.add_method('GetDistanceFrom',

   213                    'uint32_t',

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

   215                    is_const=True)

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

   217     cls.add_method('IsEnd',

   218                    'bool',

   219                    [],

   220                    is_const=True)

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

   222     cls.add_method('IsStart',

   223                    'bool',

   224                    [],

   225                    is_const=True)

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

   227     cls.add_method('WriteU8',

   228                    'void',

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

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

   231     cls.add_method('WriteU8',

   232                    'void',

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

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

   235     cls.add_method('WriteU16',

   236                    'void',

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

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

   239     cls.add_method('WriteU32',

   240                    'void',

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

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

   243     cls.add_method('WriteU64',

   244                    'void',

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

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

   247     cls.add_method('WriteHtolsbU16',

   248                    'void',

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

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

   251     cls.add_method('WriteHtolsbU32',

   252                    'void',

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

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

   255     cls.add_method('WriteHtolsbU64',

   256                    'void',

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

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

   259     cls.add_method('WriteHtonU16',

   260                    'void',

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

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

   263     cls.add_method('WriteHtonU32',

   264                    'void',

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

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

   267     cls.add_method('WriteHtonU64',

   268                    'void',

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

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

   271     cls.add_method('Write',

   272                    'void',

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

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

   275     cls.add_method('Write',

   276                    'void',

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

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

   279     cls.add_method('ReadU8',

   280                    'uint8_t',

   281                    [])

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

   283     cls.add_method('ReadU16',

   284                    'uint16_t',

   285                    [])

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

   287     cls.add_method('ReadU32',

   288                    'uint32_t',

   289                    [])

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

   291     cls.add_method('ReadU64',

   292                    'uint64_t',

   293                    [])

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

   295     cls.add_method('ReadNtohU16',

   296                    'uint16_t',

   297                    [])

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

   299     cls.add_method('ReadNtohU32',

   300                    'uint32_t',

   301                    [])

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

   303     cls.add_method('ReadNtohU64',

   304                    'uint64_t',

   305                    [])

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

   307     cls.add_method('ReadLsbtohU16',

   308                    'uint16_t',

   309                    [])

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

   311     cls.add_method('ReadLsbtohU32',

   312                    'uint32_t',

   313                    [])

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

   315     cls.add_method('ReadLsbtohU64',

   316                    'uint64_t',

   317                    [])

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

   319     cls.add_method('Read',

   320                    'void',

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

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

   323     cls.add_method('CalculateIpChecksum',

   324                    'uint16_t',

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

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

   327     cls.add_method('CalculateIpChecksum',

   328                    'uint16_t',

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

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

   331     cls.add_method('GetSize',

   332                    'uint32_t',

   333                    [],

   334                    is_const=True)

   335     cls.add_copy_constructor()

   336     return

   338 def register_Ns3DataRate_methods(root_module, cls):

   339     cls.add_output_stream_operator()

   340     cls.add_binary_comparison_operator('!=')

   341     cls.add_binary_comparison_operator('<')

   342     cls.add_binary_comparison_operator('<=')

   343     cls.add_binary_comparison_operator('==')

   344     cls.add_binary_comparison_operator('>')

   345     cls.add_binary_comparison_operator('>=')

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

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

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

   349     cls.add_constructor([])

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

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

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

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

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

   355     cls.add_method('CalculateTxTime',

   356                    'double',

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

   358                    is_const=True)

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

   360     cls.add_method('GetBitRate',

   361                    'uint64_t',

   362                    [],

   363                    is_const=True)

   364     return

   366 def register_Ns3Packet_methods(root_module, cls):

   367     cls.add_output_stream_operator()

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

   369     cls.add_constructor([])

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

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

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

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

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

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

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

   377     cls.add_method('AddAtEnd',

   378                    'void',

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

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

   381     cls.add_method('AddHeader',

   382                    'void',

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

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

   385     cls.add_method('AddPaddingAtEnd',

   386                    'void',

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

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

   389     cls.add_method('AddTag',

   390                    'void',

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

   392                    is_const=True)

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

   394     cls.add_method('AddTrailer',

   395                    'void',

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

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

   398     cls.add_method('BeginItem',

   399                    'ns3::PacketMetadata::ItemIterator',

   400                    [],

   401                    is_const=True)

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

   403     cls.add_method('Copy',

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

   405                    [],

   406                    is_const=True)

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

   408     cls.add_method('CopyData',

   409                    'uint32_t',

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

   411                    is_const=True)

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

   413     cls.add_method('CreateFragment',

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

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

   416                    is_const=True)

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

   418     cls.add_method('Deserialize',

   419                    'void',

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

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

   422     cls.add_method('EnableChecking',

   423                    'void',

   424                    [],

   425                    is_static=True)

   426     ## packet.h: static void ns3::Packet::EnableMetadata() [member function]

   427     cls.add_method('EnableMetadata',

   428                    'void',

   429                    [],

   430                    is_static=True, deprecated=True)

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

   432     cls.add_method('EnablePrinting',

   433                    'void',

   434                    [],

   435                    is_static=True)

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

   437     cls.add_method('FindFirstMatchingTag',

   438                    'bool',

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

   440                    is_const=True)

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

   442     cls.add_method('GetSize',

   443                    'uint32_t',

   444                    [],

   445                    is_const=True)

   446     ## packet.h: ns3::TagIterator ns3::Packet::GetTagIterator() const [member function]

   447     cls.add_method('GetTagIterator',

   448                    'ns3::TagIterator',

   449                    [],

   450                    is_const=True)

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

   452     cls.add_method('GetUid',

   453                    'uint32_t',

   454                    [],

   455                    is_const=True)

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

   457     cls.add_method('PeekData',

   458                    'uint8_t const *',

   459                    [],

   460                    is_const=True)

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

   462     cls.add_method('PeekHeader',

   463                    'uint32_t',

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

   465                    is_const=True)

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

   467     cls.add_method('PeekTrailer',

   468                    'uint32_t',

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

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

   471     cls.add_method('Print',

   472                    'void',

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

   474                    is_const=True)

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

   476     cls.add_method('PrintTags',

   477                    'void',

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

   479                    is_const=True)

   480     ## packet.h: void ns3::Packet::RemoveAllTags() [member function]

   481     cls.add_method('RemoveAllTags',

   482                    'void',

   483                    [])

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

   485     cls.add_method('RemoveAtEnd',

   486                    'void',

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

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

   489     cls.add_method('RemoveAtStart',

   490                    'void',

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

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

   493     cls.add_method('RemoveHeader',

   494                    'uint32_t',

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

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

   497     cls.add_method('RemoveTrailer',

   498                    'uint32_t',

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

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

   501     cls.add_method('Serialize',

   502                    'ns3::Buffer',

   503                    [],

   504                    is_const=True)

   505     return

   507 def register_Ns3PacketMetadata_methods(root_module, cls):

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

   509     cls.add_method('Enable',

   510                    'void',

   511                    [],

   512                    is_static=True)

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

   514     cls.add_method('EnableChecking',

   515                    'void',

   516                    [],

   517                    is_static=True)

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

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

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

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

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

   523     cls.add_method('AddHeader',

   524                    'void',

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

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

   527     cls.add_method('RemoveHeader',

   528                    'void',

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

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

   531     cls.add_method('AddTrailer',

   532                    'void',

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

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

   535     cls.add_method('RemoveTrailer',

   536                    'void',

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

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

   539     cls.add_method('CreateFragment',

   540                    'ns3::PacketMetadata',

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

   542                    is_const=True)

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

   544     cls.add_method('AddAtEnd',

   545                    'void',

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

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

   548     cls.add_method('AddPaddingAtEnd',

   549                    'void',

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

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

   552     cls.add_method('RemoveAtStart',

   553                    'void',

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

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

   556     cls.add_method('RemoveAtEnd',

   557                    'void',

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

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

   560     cls.add_method('GetUid',

   561                    'uint32_t',

   562                    [],

   563                    is_const=True)

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

   565     cls.add_method('GetSerializedSize',

   566                    'uint32_t',

   567                    [],

   568                    is_const=True)

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

   570     cls.add_method('Serialize',

   571                    'void',

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

   573                    is_const=True)

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

   575     cls.add_method('Deserialize',

   576                    'uint32_t',

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

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

   579     cls.add_method('BeginItem',

   580                    'ns3::PacketMetadata::ItemIterator',

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

   582                    is_const=True)

   583     return

   585 def register_Ns3PacketMetadataItem_methods(root_module, cls):

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

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

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

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

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

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

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

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

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

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

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

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

   598     cls.add_constructor([])

   599     cls.add_copy_constructor()

   600     return

   602 def register_Ns3PacketMetadataItemIterator_methods(root_module, cls):

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

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

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

   606     cls.add_method('HasNext',

   607                    'bool',

   608                    [],

   609                    is_const=True)

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

   611     cls.add_method('Next',

   612                    'ns3::PacketMetadata::Item',

   613                    [])

   614     cls.add_copy_constructor()

   615     return

   617 def register_Ns3Tag_methods(root_module, cls):

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

   619     cls.add_method('GetTypeId',

   620                    'ns3::TypeId',

   621                    [],

   622                    is_static=True)

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

   624     cls.add_method('GetSerializedSize',

   625                    'uint32_t',

   626                    [],

   627                    is_pure_virtual=True, is_const=True, is_virtual=True)

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

   629     cls.add_method('Serialize',

   630                    'void',

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

   632                    is_pure_virtual=True, is_const=True, is_virtual=True)

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

   634     cls.add_method('Deserialize',

   635                    'void',

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

   637                    is_pure_virtual=True, is_virtual=True)

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

   639     cls.add_method('Print',

   640                    'void',

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

   642                    is_pure_virtual=True, is_const=True, is_virtual=True)

   643     cls.add_constructor([])

   644     cls.add_copy_constructor()

   645     return

   647 def register_Ns3TagBuffer_methods(root_module, cls):

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

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

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

   651     cls.add_method('TrimAtEnd',

   652                    'void',

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

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

   655     cls.add_method('CopyFrom',

   656                    'void',

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

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

   659     cls.add_method('WriteU8',

   660                    'void',

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

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

   663     cls.add_method('WriteU16',

   664                    'void',

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

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

   667     cls.add_method('WriteU32',

   668                    'void',

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

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

   671     cls.add_method('WriteU64',

   672                    'void',

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

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

   675     cls.add_method('WriteDouble',

   676                    'void',

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

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

   679     cls.add_method('Write',

   680                    'void',

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

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

   683     cls.add_method('ReadU8',

   684                    'uint8_t',

   685                    [])

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

   687     cls.add_method('ReadU16',

   688                    'uint16_t',

   689                    [])

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

   691     cls.add_method('ReadU32',

   692                    'uint32_t',

   693                    [])

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

   695     cls.add_method('ReadU64',

   696                    'uint64_t',

   697                    [])

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

   699     cls.add_method('ReadDouble',

   700                    'double',

   701                    [])

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

   703     cls.add_method('Read',

   704                    'void',

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

   706     cls.add_copy_constructor()

   707     return

   709 def register_Ns3TagIterator_methods(root_module, cls):

   710     ## packet.h: bool ns3::TagIterator::HasNext() const [member function]

   711     cls.add_method('HasNext',

   712                    'bool',

   713                    [],

   714                    is_const=True)

   715     ## packet.h: ns3::TagIterator::Item ns3::TagIterator::Next() [member function]

   716     cls.add_method('Next',

   717                    'ns3::TagIterator::Item',

   718                    [])

   719     return

   721 def register_Ns3TagIteratorItem_methods(root_module, cls):

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

   723     cls.add_method('GetTypeId',

   724                    'ns3::TypeId',

   725                    [],

   726                    is_const=True)

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

   728     cls.add_method('GetStart',

   729                    'uint32_t',

   730                    [],

   731                    is_const=True)

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

   733     cls.add_method('GetEnd',

   734                    'uint32_t',

   735                    [],

   736                    is_const=True)

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

   738     cls.add_method('GetTag',

   739                    'void',

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

   741                    is_const=True)

   742     cls.add_copy_constructor()

   743     return

   745 def register_Ns3TagList_methods(root_module, cls):

   746     ## tag-list.h: ns3::TagList::TagList() [constructor]

   747     cls.add_constructor([])

   748     ## tag-list.h: ns3::TagList::TagList(ns3::TagList const & o) [copy constructor]

   749     cls.add_constructor([param('ns3::TagList const &', 'o')])

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

   751     cls.add_method('Add',

   752                    'ns3::TagBuffer',

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

   754     ## tag-list.h: void ns3::TagList::Add(ns3::TagList const & o) [member function]

   755     cls.add_method('Add',

   756                    'void',

   757                    [param('ns3::TagList const &', 'o')])

   758     ## tag-list.h: void ns3::TagList::RemoveAll() [member function]

   759     cls.add_method('RemoveAll',

   760                    'void',

   761                    [])

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

   763     cls.add_method('Begin',

   764                    'ns3::TagList::Iterator',

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

   766                    is_const=True)

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

   768     cls.add_method('AddAtEnd',

   769                    'void',

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

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

   772     cls.add_method('AddAtStart',

   773                    'void',

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

   775     return

   777 def register_Ns3TagListIterator_methods(root_module, cls):

   778     ## tag-list.h: bool ns3::TagList::Iterator::HasNext() const [member function]

   779     cls.add_method('HasNext',

   780                    'bool',

   781                    [],

   782                    is_const=True)

   783     ## tag-list.h: ns3::TagList::Iterator::Item ns3::TagList::Iterator::Next() [member function]

   784     cls.add_method('Next',

   785                    'ns3::TagList::Iterator::Item',

   786                    [])

   787     ## tag-list.h: uint32_t ns3::TagList::Iterator::GetOffsetStart() const [member function]

   788     cls.add_method('GetOffsetStart',

   789                    'uint32_t',

   790                    [],

   791                    is_const=True)

   792     cls.add_copy_constructor()

   793     return

   795 def register_Ns3TagListIteratorItem_methods(root_module, cls):

   796     ## tag-list.h: ns3::TagList::Iterator::Item::tid [variable]

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

   798     ## tag-list.h: ns3::TagList::Iterator::Item::size [variable]

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

   800     ## tag-list.h: ns3::TagList::Iterator::Item::start [variable]

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

   802     ## tag-list.h: ns3::TagList::Iterator::Item::end [variable]

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

   804     ## tag-list.h: ns3::TagList::Iterator::Item::buf [variable]

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

   806     ## tag-list.h: ns3::TagList::Iterator::Item::Item(ns3::TagBuffer buf) [constructor]

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

   808     cls.add_copy_constructor()

   809     return

   811 def register_Ns3Chunk_methods(root_module, cls):

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

   813     cls.add_constructor([])

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

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

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

   817     cls.add_method('GetTypeId',

   818                    'ns3::TypeId',

   819                    [],

   820                    is_static=True)

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

   822     cls.add_method('Deserialize',

   823                    'uint32_t',

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

   825                    is_pure_virtual=True, is_virtual=True)

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

   827     cls.add_method('Print',

   828                    'void',

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

   830                    is_pure_virtual=True, is_const=True, is_virtual=True)

   831     return

   833 def register_Ns3DataRateChecker_methods(root_module, cls):

   834     cls.add_constructor([])

   835     cls.add_copy_constructor()

   836     return

   838 def register_Ns3DataRateValue_methods(root_module, cls):

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

   840     cls.add_constructor([])

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

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

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

   844     cls.add_method('Set',

   845                    'void',

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

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

   848     cls.add_method('Get',

   849                    'ns3::DataRate',

   850                    [],

   851                    is_const=True)

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

   853     cls.add_method('Copy',

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

   855                    [],

   856                    is_const=True, is_virtual=True)

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

   858     cls.add_method('SerializeToString',

   859                    'std::string',

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

   861                    is_const=True, is_virtual=True)

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

   863     cls.add_method('DeserializeFromString',

   864                    'bool',

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

   866                    is_virtual=True)

   867     cls.add_copy_constructor()

   868     return

   870 def register_Ns3Header_methods(root_module, cls):

   871     cls.add_output_stream_operator()

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

   873     cls.add_constructor([])

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

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

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

   877     cls.add_method('Deserialize',

   878                    'uint32_t',

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

   880                    is_pure_virtual=True, is_virtual=True)

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

   882     cls.add_method('GetSerializedSize',

   883                    'uint32_t',

   884                    [],

   885                    is_pure_virtual=True, is_const=True, is_virtual=True)

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

   887     cls.add_method('GetTypeId',

   888                    'ns3::TypeId',

   889                    [],

   890                    is_static=True)

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

   892     cls.add_method('Print',

   893                    'void',

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

   895                    is_pure_virtual=True, is_const=True, is_virtual=True)

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

   897     cls.add_method('Serialize',

   898                    'void',

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

   900                    is_pure_virtual=True, is_const=True, is_virtual=True)

   901     return

   903 def register_Ns3PcapWriter_methods(root_module, cls):

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

   905     cls.add_constructor([])

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

   907     cls.add_method('Open',

   908                    'void',

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

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

   911     cls.add_method('WriteEthernetHeader',

   912                    'void',

   913                    [])

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

   915     cls.add_method('WriteIpHeader',

   916                    'void',

   917                    [])

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

   919     cls.add_method('WriteWifiHeader',

   920                    'void',

   921                    [])

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

   923     cls.add_method('WritePppHeader',

   924                    'void',

   925                    [])

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

   927     cls.add_method('WritePacket',

   928                    'void',

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

   930     cls.add_copy_constructor()

   931     return

   933 def register_Ns3Trailer_methods(root_module, cls):

   934     cls.add_output_stream_operator()

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

   936     cls.add_constructor([])

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

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

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

   940     cls.add_method('Deserialize',

   941                    'uint32_t',

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

   943                    is_pure_virtual=True, is_virtual=True)

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

   945     cls.add_method('GetSerializedSize',

   946                    'uint32_t',

   947                    [],

   948                    is_pure_virtual=True, is_const=True, is_virtual=True)

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

   950     cls.add_method('GetTypeId',

   951                    'ns3::TypeId',

   952                    [],

   953                    is_static=True)

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

   955     cls.add_method('Print',

   956                    'void',

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

   958                    is_pure_virtual=True, is_const=True, is_virtual=True)

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

   960     cls.add_method('Serialize',

   961                    'void',

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

   963                    is_pure_virtual=True, is_const=True, is_virtual=True)

   964     return

   966 def register_Ns3ErrorModel_methods(root_module, cls):

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

   968     cls.add_method('GetTypeId',

   969                    'ns3::TypeId',

   970                    [],

   971                    is_static=True)

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

   973     cls.add_constructor([])

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

   975     cls.add_method('IsCorrupt',

   976                    'bool',

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

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

   979     cls.add_method('Reset',

   980                    'void',

   981                    [])

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

   983     cls.add_method('Enable',

   984                    'void',

   985                    [])

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

   987     cls.add_method('Disable',

   988                    'void',

   989                    [])

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

   991     cls.add_method('IsEnabled',

   992                    'bool',

   993                    [],

   994                    is_const=True)

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

   996     cls.add_method('DoCorrupt',

   997                    'bool',

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

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

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

  1001     cls.add_method('DoReset',

  1002                    'void',

  1003                    [],

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

  1005     cls.add_copy_constructor()

  1006     return

  1008 def register_Ns3ListErrorModel_methods(root_module, cls):

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

  1010     cls.add_method('GetTypeId',

  1011                    'ns3::TypeId',

  1012                    [],

  1013                    is_static=True)

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

  1015     cls.add_constructor([])

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

  1017     cls.add_method('GetList',

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

  1019                    [],

  1020                    is_const=True)

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

  1022     cls.add_method('SetList',

  1023                    'void',

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

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

  1026     cls.add_method('DoCorrupt',

  1027                    'bool',

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

  1029                    visibility='private', is_virtual=True)

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

  1031     cls.add_method('DoReset',

  1032                    'void',

  1033                    [],

  1034                    visibility='private', is_virtual=True)

  1035     cls.add_copy_constructor()

  1036     return

  1038 def register_Ns3RateErrorModel_methods(root_module, cls):

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

  1040     cls.add_method('GetTypeId',

  1041                    'ns3::TypeId',

  1042                    [],

  1043                    is_static=True)

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

  1045     cls.add_constructor([])

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

  1047     cls.add_method('GetUnit',

  1048                    'ns3::ErrorUnit',

  1049                    [],

  1050                    is_const=True)

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

  1052     cls.add_method('SetUnit',

  1053                    'void',

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

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

  1056     cls.add_method('GetRate',

  1057                    'double',

  1058                    [],

  1059                    is_const=True)

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

  1061     cls.add_method('SetRate',

  1062                    'void',

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

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

  1065     cls.add_method('SetRandomVariable',

  1066                    'void',

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

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

  1069     cls.add_method('DoCorrupt',

  1070                    'bool',

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

  1072                    visibility='private', is_virtual=True)

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

  1074     cls.add_method('DoCorruptPkt',

  1075                    'bool',

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

  1077                    visibility='private', is_virtual=True)

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

  1079     cls.add_method('DoCorruptByte',

  1080                    'bool',

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

  1082                    visibility='private', is_virtual=True)

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

  1084     cls.add_method('DoCorruptBit',

  1085                    'bool',

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

  1087                    visibility='private', is_virtual=True)

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

  1089     cls.add_method('DoReset',

  1090                    'void',

  1091                    [],

  1092                    visibility='private', is_virtual=True)

  1093     cls.add_copy_constructor()

  1094     return

  1096 def register_functions(root_module):

  1097     module = root_module

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

  1099     module.add_function('MakeDataRateChecker',

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

  1101                         [])

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

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

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

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

  1106     return

  1108 def register_functions_ns3_Config(module, root_module):

  1109     return

  1111 def register_functions_ns3_TimeStepPrecision(module, root_module):

  1112     return

  1114 def register_functions_ns3_internal(module, root_module):

  1115     return

  1117 def register_functions_ns3_olsr(module, root_module):

  1118     return

author	Raj Bhattacharjea <raj.b@gatech.edu>
	Tue, 13 Jan 2009 17:15:44 -0500
changeset 4218	debf1a8a96d3
parent 3972	a84f2ab246e6
child 4241	c35796bc0b4b
permissions	-rw-r--r--