ns-3.5: bindings/python/ns3_module_internet

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

     3 def register_types(module):

     4     root_module = module.get_root()

     6     ## icmpv4.h: ns3::Icmpv4DestinationUnreachable [class]

     7     module.add_class('Icmpv4DestinationUnreachable', parent=root_module['ns3::Header'])

     8     ## icmpv4.h: ns3::Icmpv4DestinationUnreachable [enumeration]

     9     module.add_enum('', ['NET_UNREACHABLE', 'HOST_UNREACHABLE', 'PROTOCOL_UNREACHABLE', 'PORT_UNREACHABLE', 'FRAG_NEEDED', 'SOURCE_ROUTE_FAILED'], outer_class=root_module['ns3::Icmpv4DestinationUnreachable'])

    10     ## icmpv4.h: ns3::Icmpv4Echo [class]

    11     module.add_class('Icmpv4Echo', parent=root_module['ns3::Header'])

    12     ## icmpv4.h: ns3::Icmpv4Header [class]

    13     module.add_class('Icmpv4Header', parent=root_module['ns3::Header'])

    14     ## icmpv4.h: ns3::Icmpv4Header [enumeration]

    15     module.add_enum('', ['ECHO_REPLY', 'DEST_UNREACH', 'ECHO', 'TIME_EXCEEDED'], outer_class=root_module['ns3::Icmpv4Header'])

    16     ## icmpv4.h: ns3::Icmpv4TimeExceeded [class]

    17     module.add_class('Icmpv4TimeExceeded', parent=root_module['ns3::Header'])

    18     ## icmpv4.h: ns3::Icmpv4TimeExceeded [enumeration]

    19     module.add_enum('', ['TIME_TO_LIVE', 'FRAGMENT_REASSEMBLY'], outer_class=root_module['ns3::Icmpv4TimeExceeded'])

    20     ## tcp-header.h: ns3::TcpHeader [class]

    21     module.add_class('TcpHeader', parent=root_module['ns3::Header'])

    22     ## tcp-header.h: ns3::TcpHeader::Flags_t [enumeration]

    23     module.add_enum('Flags_t', ['NONE', 'FIN', 'SYN', 'RST', 'PSH', 'ACK', 'URG'], outer_class=root_module['ns3::TcpHeader'])

    24     ## udp-header.h: ns3::UdpHeader [class]

    25     module.add_class('UdpHeader', parent=root_module['ns3::Header'])

    27     ## Register a nested module for the namespace Config

    29     nested_module = module.add_cpp_namespace('Config')

    30     register_types_ns3_Config(nested_module)

    33     ## Register a nested module for the namespace TimeStepPrecision

    35     nested_module = module.add_cpp_namespace('TimeStepPrecision')

    36     register_types_ns3_TimeStepPrecision(nested_module)

    39     ## Register a nested module for the namespace addressUtils

    41     nested_module = module.add_cpp_namespace('addressUtils')

    42     register_types_ns3_addressUtils(nested_module)

    45     ## Register a nested module for the namespace internal

    47     nested_module = module.add_cpp_namespace('internal')

    48     register_types_ns3_internal(nested_module)

    51     ## Register a nested module for the namespace olsr

    53     nested_module = module.add_cpp_namespace('olsr')

    54     register_types_ns3_olsr(nested_module)

    57 def register_types_ns3_Config(module):

    58     root_module = module.get_root()

    61 def register_types_ns3_TimeStepPrecision(module):

    62     root_module = module.get_root()

    65 def register_types_ns3_addressUtils(module):

    66     root_module = module.get_root()

    69 def register_types_ns3_internal(module):

    70     root_module = module.get_root()

    73 def register_types_ns3_olsr(module):

    74     root_module = module.get_root()

    77 def register_methods(root_module):

    78     register_Ns3Icmpv4DestinationUnreachable_methods(root_module, root_module['ns3::Icmpv4DestinationUnreachable'])

    79     register_Ns3Icmpv4Echo_methods(root_module, root_module['ns3::Icmpv4Echo'])

    80     register_Ns3Icmpv4Header_methods(root_module, root_module['ns3::Icmpv4Header'])

    81     register_Ns3Icmpv4TimeExceeded_methods(root_module, root_module['ns3::Icmpv4TimeExceeded'])

    82     register_Ns3TcpHeader_methods(root_module, root_module['ns3::TcpHeader'])

    83     register_Ns3UdpHeader_methods(root_module, root_module['ns3::UdpHeader'])

    84     return

    86 def register_Ns3Icmpv4DestinationUnreachable_methods(root_module, cls):

    87     ## icmpv4.h: ns3::Icmpv4DestinationUnreachable::Icmpv4DestinationUnreachable(ns3::Icmpv4DestinationUnreachable const & arg0) [copy constructor]

    88     cls.add_constructor([param('ns3::Icmpv4DestinationUnreachable const &', 'arg0')])

    89     ## icmpv4.h: static ns3::TypeId ns3::Icmpv4DestinationUnreachable::GetTypeId() [member function]

    90     cls.add_method('GetTypeId',

    91                    'ns3::TypeId',

    92                    [],

    93                    is_static=True)

    94     ## icmpv4.h: ns3::Icmpv4DestinationUnreachable::Icmpv4DestinationUnreachable() [constructor]

    95     cls.add_constructor([])

    96     ## icmpv4.h: void ns3::Icmpv4DestinationUnreachable::SetNextHopMtu(uint16_t mtu) [member function]

    97     cls.add_method('SetNextHopMtu',

    98                    'void',

    99                    [param('uint16_t', 'mtu')])

   100     ## icmpv4.h: uint16_t ns3::Icmpv4DestinationUnreachable::GetNextHopMtu() const [member function]

   101     cls.add_method('GetNextHopMtu',

   102                    'uint16_t',

   103                    [],

   104                    is_const=True)

   105     ## icmpv4.h: void ns3::Icmpv4DestinationUnreachable::SetData(ns3::Ptr<ns3::Packet const> data) [member function]

   106     cls.add_method('SetData',

   107                    'void',

   108                    [param('ns3::Ptr< ns3::Packet const >', 'data')])

   109     ## icmpv4.h: void ns3::Icmpv4DestinationUnreachable::SetHeader(ns3::Ipv4Header header) [member function]

   110     cls.add_method('SetHeader',

   111                    'void',

   112                    [param('ns3::Ipv4Header', 'header')])

   113     ## icmpv4.h: void ns3::Icmpv4DestinationUnreachable::GetData(uint8_t * payload) const [member function]

   114     cls.add_method('GetData',

   115                    'void',

   116                    [param('uint8_t *', 'payload')],

   117                    is_const=True)

   118     ## icmpv4.h: ns3::Ipv4Header ns3::Icmpv4DestinationUnreachable::GetHeader() const [member function]

   119     cls.add_method('GetHeader',

   120                    'ns3::Ipv4Header',

   121                    [],

   122                    is_const=True)

   123     ## icmpv4.h: ns3::TypeId ns3::Icmpv4DestinationUnreachable::GetInstanceTypeId() const [member function]

   124     cls.add_method('GetInstanceTypeId',

   125                    'ns3::TypeId',

   126                    [],

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

   128     ## icmpv4.h: uint32_t ns3::Icmpv4DestinationUnreachable::GetSerializedSize() const [member function]

   129     cls.add_method('GetSerializedSize',

   130                    'uint32_t',

   131                    [],

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

   133     ## icmpv4.h: void ns3::Icmpv4DestinationUnreachable::Serialize(ns3::Buffer::Iterator start) const [member function]

   134     cls.add_method('Serialize',

   135                    'void',

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

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

   138     ## icmpv4.h: uint32_t ns3::Icmpv4DestinationUnreachable::Deserialize(ns3::Buffer::Iterator start) [member function]

   139     cls.add_method('Deserialize',

   140                    'uint32_t',

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

   142                    visibility='private', is_virtual=True)

   143     ## icmpv4.h: void ns3::Icmpv4DestinationUnreachable::Print(std::ostream & os) const [member function]

   144     cls.add_method('Print',

   145                    'void',

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

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

   148     return

   150 def register_Ns3Icmpv4Echo_methods(root_module, cls):

   151     ## icmpv4.h: ns3::Icmpv4Echo::Icmpv4Echo(ns3::Icmpv4Echo const & arg0) [copy constructor]

   152     cls.add_constructor([param('ns3::Icmpv4Echo const &', 'arg0')])

   153     ## icmpv4.h: void ns3::Icmpv4Echo::SetIdentifier(uint16_t id) [member function]

   154     cls.add_method('SetIdentifier',

   155                    'void',

   156                    [param('uint16_t', 'id')])

   157     ## icmpv4.h: void ns3::Icmpv4Echo::SetSequenceNumber(uint16_t seq) [member function]

   158     cls.add_method('SetSequenceNumber',

   159                    'void',

   160                    [param('uint16_t', 'seq')])

   161     ## icmpv4.h: void ns3::Icmpv4Echo::SetData(ns3::Ptr<ns3::Packet const> data) [member function]

   162     cls.add_method('SetData',

   163                    'void',

   164                    [param('ns3::Ptr< ns3::Packet const >', 'data')])

   165     ## icmpv4.h: uint16_t ns3::Icmpv4Echo::GetIdentifier() const [member function]

   166     cls.add_method('GetIdentifier',

   167                    'uint16_t',

   168                    [],

   169                    is_const=True)

   170     ## icmpv4.h: uint16_t ns3::Icmpv4Echo::GetSequenceNumber() const [member function]

   171     cls.add_method('GetSequenceNumber',

   172                    'uint16_t',

   173                    [],

   174                    is_const=True)

   175     ## icmpv4.h: uint32_t ns3::Icmpv4Echo::GetDataSize() const [member function]

   176     cls.add_method('GetDataSize',

   177                    'uint32_t',

   178                    [],

   179                    is_const=True)

   180     ## icmpv4.h: uint32_t ns3::Icmpv4Echo::GetData(uint8_t * payload) const [member function]

   181     cls.add_method('GetData',

   182                    'uint32_t',

   183                    [param('uint8_t *', 'payload')],

   184                    is_const=True)

   185     ## icmpv4.h: static ns3::TypeId ns3::Icmpv4Echo::GetTypeId() [member function]

   186     cls.add_method('GetTypeId',

   187                    'ns3::TypeId',

   188                    [],

   189                    is_static=True)

   190     ## icmpv4.h: ns3::Icmpv4Echo::Icmpv4Echo() [constructor]

   191     cls.add_constructor([])

   192     ## icmpv4.h: ns3::TypeId ns3::Icmpv4Echo::GetInstanceTypeId() const [member function]

   193     cls.add_method('GetInstanceTypeId',

   194                    'ns3::TypeId',

   195                    [],

   196                    is_const=True, is_virtual=True)

   197     ## icmpv4.h: uint32_t ns3::Icmpv4Echo::GetSerializedSize() const [member function]

   198     cls.add_method('GetSerializedSize',

   199                    'uint32_t',

   200                    [],

   201                    is_const=True, is_virtual=True)

   202     ## icmpv4.h: void ns3::Icmpv4Echo::Serialize(ns3::Buffer::Iterator start) const [member function]

   203     cls.add_method('Serialize',

   204                    'void',

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

   206                    is_const=True, is_virtual=True)

   207     ## icmpv4.h: uint32_t ns3::Icmpv4Echo::Deserialize(ns3::Buffer::Iterator start) [member function]

   208     cls.add_method('Deserialize',

   209                    'uint32_t',

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

   211                    is_virtual=True)

   212     ## icmpv4.h: void ns3::Icmpv4Echo::Print(std::ostream & os) const [member function]

   213     cls.add_method('Print',

   214                    'void',

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

   216                    is_const=True, is_virtual=True)

   217     return

   219 def register_Ns3Icmpv4Header_methods(root_module, cls):

   220     ## icmpv4.h: ns3::Icmpv4Header::Icmpv4Header(ns3::Icmpv4Header const & arg0) [copy constructor]

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

   222     ## icmpv4.h: void ns3::Icmpv4Header::EnableChecksum() [member function]

   223     cls.add_method('EnableChecksum',

   224                    'void',

   225                    [])

   226     ## icmpv4.h: void ns3::Icmpv4Header::SetType(uint8_t type) [member function]

   227     cls.add_method('SetType',

   228                    'void',

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

   230     ## icmpv4.h: void ns3::Icmpv4Header::SetCode(uint8_t code) [member function]

   231     cls.add_method('SetCode',

   232                    'void',

   233                    [param('uint8_t', 'code')])

   234     ## icmpv4.h: uint8_t ns3::Icmpv4Header::GetType() const [member function]

   235     cls.add_method('GetType',

   236                    'uint8_t',

   237                    [],

   238                    is_const=True)

   239     ## icmpv4.h: uint8_t ns3::Icmpv4Header::GetCode() const [member function]

   240     cls.add_method('GetCode',

   241                    'uint8_t',

   242                    [],

   243                    is_const=True)

   244     ## icmpv4.h: static ns3::TypeId ns3::Icmpv4Header::GetTypeId() [member function]

   245     cls.add_method('GetTypeId',

   246                    'ns3::TypeId',

   247                    [],

   248                    is_static=True)

   249     ## icmpv4.h: ns3::Icmpv4Header::Icmpv4Header() [constructor]

   250     cls.add_constructor([])

   251     ## icmpv4.h: ns3::TypeId ns3::Icmpv4Header::GetInstanceTypeId() const [member function]

   252     cls.add_method('GetInstanceTypeId',

   253                    'ns3::TypeId',

   254                    [],

   255                    is_const=True, is_virtual=True)

   256     ## icmpv4.h: uint32_t ns3::Icmpv4Header::GetSerializedSize() const [member function]

   257     cls.add_method('GetSerializedSize',

   258                    'uint32_t',

   259                    [],

   260                    is_const=True, is_virtual=True)

   261     ## icmpv4.h: void ns3::Icmpv4Header::Serialize(ns3::Buffer::Iterator start) const [member function]

   262     cls.add_method('Serialize',

   263                    'void',

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

   265                    is_const=True, is_virtual=True)

   266     ## icmpv4.h: uint32_t ns3::Icmpv4Header::Deserialize(ns3::Buffer::Iterator start) [member function]

   267     cls.add_method('Deserialize',

   268                    'uint32_t',

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

   270                    is_virtual=True)

   271     ## icmpv4.h: void ns3::Icmpv4Header::Print(std::ostream & os) const [member function]

   272     cls.add_method('Print',

   273                    'void',

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

   275                    is_const=True, is_virtual=True)

   276     return

   278 def register_Ns3Icmpv4TimeExceeded_methods(root_module, cls):

   279     ## icmpv4.h: ns3::Icmpv4TimeExceeded::Icmpv4TimeExceeded(ns3::Icmpv4TimeExceeded const & arg0) [copy constructor]

   280     cls.add_constructor([param('ns3::Icmpv4TimeExceeded const &', 'arg0')])

   281     ## icmpv4.h: void ns3::Icmpv4TimeExceeded::SetData(ns3::Ptr<ns3::Packet const> data) [member function]

   282     cls.add_method('SetData',

   283                    'void',

   284                    [param('ns3::Ptr< ns3::Packet const >', 'data')])

   285     ## icmpv4.h: void ns3::Icmpv4TimeExceeded::SetHeader(ns3::Ipv4Header header) [member function]

   286     cls.add_method('SetHeader',

   287                    'void',

   288                    [param('ns3::Ipv4Header', 'header')])

   289     ## icmpv4.h: void ns3::Icmpv4TimeExceeded::GetData(uint8_t * payload) const [member function]

   290     cls.add_method('GetData',

   291                    'void',

   292                    [param('uint8_t *', 'payload')],

   293                    is_const=True)

   294     ## icmpv4.h: ns3::Ipv4Header ns3::Icmpv4TimeExceeded::GetHeader() const [member function]

   295     cls.add_method('GetHeader',

   296                    'ns3::Ipv4Header',

   297                    [],

   298                    is_const=True)

   299     ## icmpv4.h: static ns3::TypeId ns3::Icmpv4TimeExceeded::GetTypeId() [member function]

   300     cls.add_method('GetTypeId',

   301                    'ns3::TypeId',

   302                    [],

   303                    is_static=True)

   304     ## icmpv4.h: ns3::Icmpv4TimeExceeded::Icmpv4TimeExceeded() [constructor]

   305     cls.add_constructor([])

   306     ## icmpv4.h: ns3::TypeId ns3::Icmpv4TimeExceeded::GetInstanceTypeId() const [member function]

   307     cls.add_method('GetInstanceTypeId',

   308                    'ns3::TypeId',

   309                    [],

   310                    is_const=True, is_virtual=True)

   311     ## icmpv4.h: uint32_t ns3::Icmpv4TimeExceeded::GetSerializedSize() const [member function]

   312     cls.add_method('GetSerializedSize',

   313                    'uint32_t',

   314                    [],

   315                    is_const=True, is_virtual=True)

   316     ## icmpv4.h: void ns3::Icmpv4TimeExceeded::Serialize(ns3::Buffer::Iterator start) const [member function]

   317     cls.add_method('Serialize',

   318                    'void',

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

   320                    is_const=True, is_virtual=True)

   321     ## icmpv4.h: uint32_t ns3::Icmpv4TimeExceeded::Deserialize(ns3::Buffer::Iterator start) [member function]

   322     cls.add_method('Deserialize',

   323                    'uint32_t',

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

   325                    is_virtual=True)

   326     ## icmpv4.h: void ns3::Icmpv4TimeExceeded::Print(std::ostream & os) const [member function]

   327     cls.add_method('Print',

   328                    'void',

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

   330                    is_const=True, is_virtual=True)

   331     return

   333 def register_Ns3TcpHeader_methods(root_module, cls):

   334     ## tcp-header.h: ns3::TcpHeader::TcpHeader(ns3::TcpHeader const & arg0) [copy constructor]

   335     cls.add_constructor([param('ns3::TcpHeader const &', 'arg0')])

   336     ## tcp-header.h: ns3::TcpHeader::TcpHeader() [constructor]

   337     cls.add_constructor([])

   338     ## tcp-header.h: void ns3::TcpHeader::EnableChecksums() [member function]

   339     cls.add_method('EnableChecksums',

   340                    'void',

   341                    [])

   342     ## tcp-header.h: void ns3::TcpHeader::SetSourcePort(uint16_t port) [member function]

   343     cls.add_method('SetSourcePort',

   344                    'void',

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

   346     ## tcp-header.h: void ns3::TcpHeader::SetDestinationPort(uint16_t port) [member function]

   347     cls.add_method('SetDestinationPort',

   348                    'void',

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

   350     ## tcp-header.h: void ns3::TcpHeader::SetSequenceNumber(SequenceNumber sequenceNumber) [member function]

   351     cls.add_method('SetSequenceNumber',

   352                    'void',

   353                    [param('SequenceNumber', 'sequenceNumber')])

   354     ## tcp-header.h: void ns3::TcpHeader::SetAckNumber(SequenceNumber ackNumber) [member function]

   355     cls.add_method('SetAckNumber',

   356                    'void',

   357                    [param('SequenceNumber', 'ackNumber')])

   358     ## tcp-header.h: void ns3::TcpHeader::SetLength(uint8_t length) [member function]

   359     cls.add_method('SetLength',

   360                    'void',

   361                    [param('uint8_t', 'length')])

   362     ## tcp-header.h: void ns3::TcpHeader::SetFlags(uint8_t flags) [member function]

   363     cls.add_method('SetFlags',

   364                    'void',

   365                    [param('uint8_t', 'flags')])

   366     ## tcp-header.h: void ns3::TcpHeader::SetWindowSize(uint16_t windowSize) [member function]

   367     cls.add_method('SetWindowSize',

   368                    'void',

   369                    [param('uint16_t', 'windowSize')])

   370     ## tcp-header.h: void ns3::TcpHeader::SetUrgentPointer(uint16_t urgentPointer) [member function]

   371     cls.add_method('SetUrgentPointer',

   372                    'void',

   373                    [param('uint16_t', 'urgentPointer')])

   374     ## tcp-header.h: uint16_t ns3::TcpHeader::GetSourcePort() const [member function]

   375     cls.add_method('GetSourcePort',

   376                    'uint16_t',

   377                    [],

   378                    is_const=True)

   379     ## tcp-header.h: uint16_t ns3::TcpHeader::GetDestinationPort() const [member function]

   380     cls.add_method('GetDestinationPort',

   381                    'uint16_t',

   382                    [],

   383                    is_const=True)

   384     ## tcp-header.h: SequenceNumber ns3::TcpHeader::GetSequenceNumber() const [member function]

   385     cls.add_method('GetSequenceNumber',

   386                    'SequenceNumber',

   387                    [],

   388                    is_const=True)

   389     ## tcp-header.h: SequenceNumber ns3::TcpHeader::GetAckNumber() const [member function]

   390     cls.add_method('GetAckNumber',

   391                    'SequenceNumber',

   392                    [],

   393                    is_const=True)

   394     ## tcp-header.h: uint8_t ns3::TcpHeader::GetLength() const [member function]

   395     cls.add_method('GetLength',

   396                    'uint8_t',

   397                    [],

   398                    is_const=True)

   399     ## tcp-header.h: uint8_t ns3::TcpHeader::GetFlags() const [member function]

   400     cls.add_method('GetFlags',

   401                    'uint8_t',

   402                    [],

   403                    is_const=True)

   404     ## tcp-header.h: uint16_t ns3::TcpHeader::GetWindowSize() const [member function]

   405     cls.add_method('GetWindowSize',

   406                    'uint16_t',

   407                    [],

   408                    is_const=True)

   409     ## tcp-header.h: uint16_t ns3::TcpHeader::GetUrgentPointer() const [member function]

   410     cls.add_method('GetUrgentPointer',

   411                    'uint16_t',

   412                    [],

   413                    is_const=True)

   414     ## tcp-header.h: void ns3::TcpHeader::InitializeChecksum(ns3::Ipv4Address source, ns3::Ipv4Address destination, uint8_t protocol) [member function]

   415     cls.add_method('InitializeChecksum',

   416                    'void',

   417                    [param('ns3::Ipv4Address', 'source'), param('ns3::Ipv4Address', 'destination'), param('uint8_t', 'protocol')])

   418     ## tcp-header.h: static ns3::TypeId ns3::TcpHeader::GetTypeId() [member function]

   419     cls.add_method('GetTypeId',

   420                    'ns3::TypeId',

   421                    [],

   422                    is_static=True)

   423     ## tcp-header.h: ns3::TypeId ns3::TcpHeader::GetInstanceTypeId() const [member function]

   424     cls.add_method('GetInstanceTypeId',

   425                    'ns3::TypeId',

   426                    [],

   427                    is_const=True, is_virtual=True)

   428     ## tcp-header.h: void ns3::TcpHeader::Print(std::ostream & os) const [member function]

   429     cls.add_method('Print',

   430                    'void',

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

   432                    is_const=True, is_virtual=True)

   433     ## tcp-header.h: uint32_t ns3::TcpHeader::GetSerializedSize() const [member function]

   434     cls.add_method('GetSerializedSize',

   435                    'uint32_t',

   436                    [],

   437                    is_const=True, is_virtual=True)

   438     ## tcp-header.h: void ns3::TcpHeader::Serialize(ns3::Buffer::Iterator start) const [member function]

   439     cls.add_method('Serialize',

   440                    'void',

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

   442                    is_const=True, is_virtual=True)

   443     ## tcp-header.h: uint32_t ns3::TcpHeader::Deserialize(ns3::Buffer::Iterator start) [member function]

   444     cls.add_method('Deserialize',

   445                    'uint32_t',

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

   447                    is_virtual=True)

   448     ## tcp-header.h: bool ns3::TcpHeader::IsChecksumOk() const [member function]

   449     cls.add_method('IsChecksumOk',

   450                    'bool',

   451                    [],

   452                    is_const=True)

   453     return

   455 def register_Ns3UdpHeader_methods(root_module, cls):

   456     ## udp-header.h: ns3::UdpHeader::UdpHeader(ns3::UdpHeader const & arg0) [copy constructor]

   457     cls.add_constructor([param('ns3::UdpHeader const &', 'arg0')])

   458     ## udp-header.h: ns3::UdpHeader::UdpHeader() [constructor]

   459     cls.add_constructor([])

   460     ## udp-header.h: void ns3::UdpHeader::EnableChecksums() [member function]

   461     cls.add_method('EnableChecksums',

   462                    'void',

   463                    [])

   464     ## udp-header.h: void ns3::UdpHeader::SetDestinationPort(uint16_t port) [member function]

   465     cls.add_method('SetDestinationPort',

   466                    'void',

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

   468     ## udp-header.h: void ns3::UdpHeader::SetSourcePort(uint16_t port) [member function]

   469     cls.add_method('SetSourcePort',

   470                    'void',

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

   472     ## udp-header.h: uint16_t ns3::UdpHeader::GetSourcePort() const [member function]

   473     cls.add_method('GetSourcePort',

   474                    'uint16_t',

   475                    [],

   476                    is_const=True)

   477     ## udp-header.h: uint16_t ns3::UdpHeader::GetDestinationPort() const [member function]

   478     cls.add_method('GetDestinationPort',

   479                    'uint16_t',

   480                    [],

   481                    is_const=True)

   482     ## udp-header.h: void ns3::UdpHeader::InitializeChecksum(ns3::Ipv4Address source, ns3::Ipv4Address destination, uint8_t protocol) [member function]

   483     cls.add_method('InitializeChecksum',

   484                    'void',

   485                    [param('ns3::Ipv4Address', 'source'), param('ns3::Ipv4Address', 'destination'), param('uint8_t', 'protocol')])

   486     ## udp-header.h: static ns3::TypeId ns3::UdpHeader::GetTypeId() [member function]

   487     cls.add_method('GetTypeId',

   488                    'ns3::TypeId',

   489                    [],

   490                    is_static=True)

   491     ## udp-header.h: ns3::TypeId ns3::UdpHeader::GetInstanceTypeId() const [member function]

   492     cls.add_method('GetInstanceTypeId',

   493                    'ns3::TypeId',

   494                    [],

   495                    is_const=True, is_virtual=True)

   496     ## udp-header.h: void ns3::UdpHeader::Print(std::ostream & os) const [member function]

   497     cls.add_method('Print',

   498                    'void',

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

   500                    is_const=True, is_virtual=True)

   501     ## udp-header.h: uint32_t ns3::UdpHeader::GetSerializedSize() const [member function]

   502     cls.add_method('GetSerializedSize',

   503                    'uint32_t',

   504                    [],

   505                    is_const=True, is_virtual=True)

   506     ## udp-header.h: void ns3::UdpHeader::Serialize(ns3::Buffer::Iterator start) const [member function]

   507     cls.add_method('Serialize',

   508                    'void',

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

   510                    is_const=True, is_virtual=True)

   511     ## udp-header.h: uint32_t ns3::UdpHeader::Deserialize(ns3::Buffer::Iterator start) [member function]

   512     cls.add_method('Deserialize',

   513                    'uint32_t',

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

   515                    is_virtual=True)

   516     ## udp-header.h: bool ns3::UdpHeader::IsChecksumOk() const [member function]

   517     cls.add_method('IsChecksumOk',

   518                    'bool',

   519                    [],

   520                    is_const=True)

   521     return

   523 def register_functions(root_module):

   524     module = root_module

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

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

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

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

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

   530     return

   532 def register_functions_ns3_Config(module, root_module):

   533     return

   535 def register_functions_ns3_TimeStepPrecision(module, root_module):

   536     return

   538 def register_functions_ns3_addressUtils(module, root_module):

   539     return

   541 def register_functions_ns3_internal(module, root_module):

   542     return

   544 def register_functions_ns3_olsr(module, root_module):

   545     return

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