ns-3-dev: 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     ## icmpv6-header.h: ns3::Icmpv6Header [class]

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

    22     ## icmpv6-header.h: ns3::Icmpv6Header::Type_e [enumeration]

    23     module.add_enum('Type_e', ['ICMPV6_ERROR_DESTINATION_UNREACHABLE', 'ICMPV6_ERROR_PACKET_TOO_BIG', 'ICMPV6_ERROR_TIME_EXCEEDED', 'ICMPV6_ERROR_PARAMETER_ERROR', 'ICMPV6_ECHO_REQUEST', 'ICMPV6_ECHO_REPLY', 'ICMPV6_SUBSCRIBE_REQUEST', 'ICMPV6_SUBSCRIBE_REPORT', 'ICMPV6_SUBSCRIVE_END', 'ICMPV6_ND_ROUTER_SOLICITATION', 'ICMPV6_ND_ROUTER_ADVERTISEMENT', 'ICMPV6_ND_NEIGHBOR_SOLICITATION', 'ICMPV6_ND_NEIGHBOR_ADVERTISEMENT', 'ICMPV6_ND_REDIRECTION', 'ICMPV6_ROUTER_RENUMBER', 'ICMPV6_INFORMATION_REQUEST', 'ICMPV6_INFORMATION_RESPONSE', 'ICMPV6_INVERSE_ND_SOLICITATION', 'ICMPV6_INVERSE_ND_ADVERSTISEMENT', 'ICMPV6_MLDV2_SUBSCRIBE_REPORT', 'ICMPV6_MOBILITY_HA_DISCOVER_REQUEST', 'ICMPV6_MOBILITY_HA_DISCOVER_RESPONSE', 'ICMPV6_MOBILITY_MOBILE_PREFIX_SOLICITATION', 'ICMPV6_SECURE_ND_CERTIFICATE_PATH_SOLICITATION', 'ICMPV6_SECURE_ND_CERTIFICATE_PATH_ADVERTISEMENT', 'ICMPV6_EXPERIMENTAL_MOBILITY'], outer_class=root_module['ns3::Icmpv6Header'])

    24     ## icmpv6-header.h: ns3::Icmpv6Header::OptionType_e [enumeration]

    25     module.add_enum('OptionType_e', ['ICMPV6_OPT_LINK_LAYER_SOURCE', 'ICMPV6_OPT_LINK_LAYER_TARGET', 'ICMPV6_OPT_PREFIX', 'ICMPV6_OPT_REDIRECTED', 'ICMPV6_OPT_MTU'], outer_class=root_module['ns3::Icmpv6Header'])

    26     ## icmpv6-header.h: ns3::Icmpv6Header::ErrorDestinationUnreachable_e [enumeration]

    27     module.add_enum('ErrorDestinationUnreachable_e', ['ICMPV6_NO_ROUTE', 'ICMPV6_ADM_PROHIBITED', 'ICMPV6_NOT_NEIGHBOUR', 'ICMPV6_ADDR_UNREACHABLE', 'ICMPV6_PORT_UNREACHABLE'], outer_class=root_module['ns3::Icmpv6Header'])

    28     ## icmpv6-header.h: ns3::Icmpv6Header::ErrorTimeExceeded_e [enumeration]

    29     module.add_enum('ErrorTimeExceeded_e', ['ICMPV6_HOPLIMIT', 'ICMPV6_FRAGTIME'], outer_class=root_module['ns3::Icmpv6Header'])

    30     ## icmpv6-header.h: ns3::Icmpv6Header::ErrorParameterError_e [enumeration]

    31     module.add_enum('ErrorParameterError_e', ['ICMPV6_MALFORMED_HEADER', 'ICMPV6_UNKNOWN_NEXT_HEADER', 'ICMPV6_UNKNOWN_OPTION'], outer_class=root_module['ns3::Icmpv6Header'])

    32     ## icmpv6-header.h: ns3::Icmpv6NA [class]

    33     module.add_class('Icmpv6NA', parent=root_module['ns3::Icmpv6Header'])

    34     ## icmpv6-header.h: ns3::Icmpv6NS [class]

    35     module.add_class('Icmpv6NS', parent=root_module['ns3::Icmpv6Header'])

    36     ## icmpv6-header.h: ns3::Icmpv6OptionHeader [class]

    37     module.add_class('Icmpv6OptionHeader', parent=root_module['ns3::Header'])

    38     ## icmpv6-header.h: ns3::Icmpv6OptionLinkLayerAddress [class]

    39     module.add_class('Icmpv6OptionLinkLayerAddress', parent=root_module['ns3::Icmpv6OptionHeader'])

    40     ## icmpv6-header.h: ns3::Icmpv6OptionMtu [class]

    41     module.add_class('Icmpv6OptionMtu', parent=root_module['ns3::Icmpv6OptionHeader'])

    42     ## icmpv6-header.h: ns3::Icmpv6OptionPrefixInformation [class]

    43     module.add_class('Icmpv6OptionPrefixInformation', parent=root_module['ns3::Icmpv6OptionHeader'])

    44     ## icmpv6-header.h: ns3::Icmpv6OptionRedirected [class]

    45     module.add_class('Icmpv6OptionRedirected', parent=root_module['ns3::Icmpv6OptionHeader'])

    46     ## icmpv6-header.h: ns3::Icmpv6ParameterError [class]

    47     module.add_class('Icmpv6ParameterError', parent=root_module['ns3::Icmpv6Header'])

    48     ## icmpv6-header.h: ns3::Icmpv6RA [class]

    49     module.add_class('Icmpv6RA', parent=root_module['ns3::Icmpv6Header'])

    50     ## icmpv6-header.h: ns3::Icmpv6RS [class]

    51     module.add_class('Icmpv6RS', parent=root_module['ns3::Icmpv6Header'])

    52     ## icmpv6-header.h: ns3::Icmpv6Redirection [class]

    53     module.add_class('Icmpv6Redirection', parent=root_module['ns3::Icmpv6Header'])

    54     ## icmpv6-header.h: ns3::Icmpv6TimeExceeded [class]

    55     module.add_class('Icmpv6TimeExceeded', parent=root_module['ns3::Icmpv6Header'])

    56     ## icmpv6-header.h: ns3::Icmpv6TooBig [class]

    57     module.add_class('Icmpv6TooBig', parent=root_module['ns3::Icmpv6Header'])

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

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

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

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

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

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

    64     ## arp-cache.h: ns3::ArpCache [class]

    65     module.add_class('ArpCache', parent=root_module['ns3::Object'])

    66     ## arp-cache.h: ns3::ArpCache::Entry [class]

    67     module.add_class('Entry', outer_class=root_module['ns3::ArpCache'])

    68     ## arp-l3-protocol.h: ns3::ArpL3Protocol [class]

    69     module.add_class('ArpL3Protocol', parent=root_module['ns3::Object'])

    70     ## icmpv6-header.h: ns3::Icmpv6DestinationUnreachable [class]

    71     module.add_class('Icmpv6DestinationUnreachable', parent=root_module['ns3::Icmpv6Header'])

    72     ## icmpv6-header.h: ns3::Icmpv6Echo [class]

    73     module.add_class('Icmpv6Echo', parent=root_module['ns3::Icmpv6Header'])

    74     ## ipv4-l3-protocol.h: ns3::Ipv4L3Protocol [class]

    75     module.add_class('Ipv4L3Protocol', parent=root_module['ns3::Ipv4'])

    76     ## ipv4-l4-protocol.h: ns3::Ipv4L4Protocol [class]

    77     module.add_class('Ipv4L4Protocol', parent=root_module['ns3::Object'])

    78     ## ipv4-l4-protocol.h: ns3::Ipv4L4Protocol::RxStatus [enumeration]

    79     module.add_enum('RxStatus', ['RX_OK', 'RX_CSUM_FAILED', 'RX_ENDPOINT_UNREACH'], outer_class=root_module['ns3::Ipv4L4Protocol'])

    80     ## tcp-l4-protocol.h: ns3::TcpL4Protocol [class]

    81     module.add_class('TcpL4Protocol', parent=root_module['ns3::Ipv4L4Protocol'])

    82     ## udp-l4-protocol.h: ns3::UdpL4Protocol [class]

    83     module.add_class('UdpL4Protocol', parent=root_module['ns3::Ipv4L4Protocol'])

    84     ## icmpv4-l4-protocol.h: ns3::Icmpv4L4Protocol [class]

    85     module.add_class('Icmpv4L4Protocol', parent=root_module['ns3::Ipv4L4Protocol'])

    87     ## Register a nested module for the namespace Config

    89     nested_module = module.add_cpp_namespace('Config')

    90     register_types_ns3_Config(nested_module)

    93     ## Register a nested module for the namespace TimeStepPrecision

    95     nested_module = module.add_cpp_namespace('TimeStepPrecision')

    96     register_types_ns3_TimeStepPrecision(nested_module)

    99     ## Register a nested module for the namespace addressUtils

   101     nested_module = module.add_cpp_namespace('addressUtils')

   102     register_types_ns3_addressUtils(nested_module)

   105     ## Register a nested module for the namespace internal

   107     nested_module = module.add_cpp_namespace('internal')

   108     register_types_ns3_internal(nested_module)

   111     ## Register a nested module for the namespace olsr

   113     nested_module = module.add_cpp_namespace('olsr')

   114     register_types_ns3_olsr(nested_module)

   117 def register_types_ns3_Config(module):

   118     root_module = module.get_root()

   121 def register_types_ns3_TimeStepPrecision(module):

   122     root_module = module.get_root()

   125 def register_types_ns3_addressUtils(module):

   126     root_module = module.get_root()

   129 def register_types_ns3_internal(module):

   130     root_module = module.get_root()

   133 def register_types_ns3_olsr(module):

   134     root_module = module.get_root()

   137 def register_methods(root_module):

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

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

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

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

   142     register_Ns3Icmpv6Header_methods(root_module, root_module['ns3::Icmpv6Header'])

   143     register_Ns3Icmpv6NA_methods(root_module, root_module['ns3::Icmpv6NA'])

   144     register_Ns3Icmpv6NS_methods(root_module, root_module['ns3::Icmpv6NS'])

   145     register_Ns3Icmpv6OptionHeader_methods(root_module, root_module['ns3::Icmpv6OptionHeader'])

   146     register_Ns3Icmpv6OptionLinkLayerAddress_methods(root_module, root_module['ns3::Icmpv6OptionLinkLayerAddress'])

   147     register_Ns3Icmpv6OptionMtu_methods(root_module, root_module['ns3::Icmpv6OptionMtu'])

   148     register_Ns3Icmpv6OptionPrefixInformation_methods(root_module, root_module['ns3::Icmpv6OptionPrefixInformation'])

   149     register_Ns3Icmpv6OptionRedirected_methods(root_module, root_module['ns3::Icmpv6OptionRedirected'])

   150     register_Ns3Icmpv6ParameterError_methods(root_module, root_module['ns3::Icmpv6ParameterError'])

   151     register_Ns3Icmpv6RA_methods(root_module, root_module['ns3::Icmpv6RA'])

   152     register_Ns3Icmpv6RS_methods(root_module, root_module['ns3::Icmpv6RS'])

   153     register_Ns3Icmpv6Redirection_methods(root_module, root_module['ns3::Icmpv6Redirection'])

   154     register_Ns3Icmpv6TimeExceeded_methods(root_module, root_module['ns3::Icmpv6TimeExceeded'])

   155     register_Ns3Icmpv6TooBig_methods(root_module, root_module['ns3::Icmpv6TooBig'])

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

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

   158     register_Ns3ArpCache_methods(root_module, root_module['ns3::ArpCache'])

   159     register_Ns3ArpCacheEntry_methods(root_module, root_module['ns3::ArpCache::Entry'])

   160     register_Ns3ArpL3Protocol_methods(root_module, root_module['ns3::ArpL3Protocol'])

   161     register_Ns3Icmpv6DestinationUnreachable_methods(root_module, root_module['ns3::Icmpv6DestinationUnreachable'])

   162     register_Ns3Icmpv6Echo_methods(root_module, root_module['ns3::Icmpv6Echo'])

   163     register_Ns3Ipv4L3Protocol_methods(root_module, root_module['ns3::Ipv4L3Protocol'])

   164     register_Ns3Ipv4L4Protocol_methods(root_module, root_module['ns3::Ipv4L4Protocol'])

   165     register_Ns3TcpL4Protocol_methods(root_module, root_module['ns3::TcpL4Protocol'])

   166     register_Ns3UdpL4Protocol_methods(root_module, root_module['ns3::UdpL4Protocol'])

   167     register_Ns3Icmpv4L4Protocol_methods(root_module, root_module['ns3::Icmpv4L4Protocol'])

   168     return

   170 def register_Ns3Icmpv4DestinationUnreachable_methods(root_module, cls):

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

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

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

   174     cls.add_constructor([])

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

   176     cls.add_method('GetData',

   177                    'void',

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

   179                    is_const=True)

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

   181     cls.add_method('GetHeader',

   182                    'ns3::Ipv4Header',

   183                    [],

   184                    is_const=True)

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

   186     cls.add_method('GetNextHopMtu',

   187                    'uint16_t',

   188                    [],

   189                    is_const=True)

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

   191     cls.add_method('GetTypeId',

   192                    'ns3::TypeId',

   193                    [],

   194                    is_static=True)

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

   196     cls.add_method('SetData',

   197                    'void',

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

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

   200     cls.add_method('SetHeader',

   201                    'void',

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

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

   204     cls.add_method('SetNextHopMtu',

   205                    'void',

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

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

   208     cls.add_method('Deserialize',

   209                    'uint32_t',

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

   211                    visibility='private', is_virtual=True)

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

   213     cls.add_method('GetInstanceTypeId',

   214                    'ns3::TypeId',

   215                    [],

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

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

   218     cls.add_method('GetSerializedSize',

   219                    'uint32_t',

   220                    [],

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

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

   223     cls.add_method('Print',

   224                    'void',

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

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

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

   228     cls.add_method('Serialize',

   229                    'void',

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

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

   232     return

   234 def register_Ns3Icmpv4Echo_methods(root_module, cls):

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

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

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

   238     cls.add_constructor([])

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

   240     cls.add_method('Deserialize',

   241                    'uint32_t',

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

   243                    is_virtual=True)

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

   245     cls.add_method('GetData',

   246                    'uint32_t',

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

   248                    is_const=True)

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

   250     cls.add_method('GetDataSize',

   251                    'uint32_t',

   252                    [],

   253                    is_const=True)

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

   255     cls.add_method('GetIdentifier',

   256                    'uint16_t',

   257                    [],

   258                    is_const=True)

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

   260     cls.add_method('GetInstanceTypeId',

   261                    'ns3::TypeId',

   262                    [],

   263                    is_const=True, is_virtual=True)

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

   265     cls.add_method('GetSequenceNumber',

   266                    'uint16_t',

   267                    [],

   268                    is_const=True)

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

   270     cls.add_method('GetSerializedSize',

   271                    'uint32_t',

   272                    [],

   273                    is_const=True, is_virtual=True)

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

   275     cls.add_method('GetTypeId',

   276                    'ns3::TypeId',

   277                    [],

   278                    is_static=True)

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

   280     cls.add_method('Print',

   281                    'void',

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

   283                    is_const=True, is_virtual=True)

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

   285     cls.add_method('Serialize',

   286                    'void',

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

   288                    is_const=True, is_virtual=True)

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

   290     cls.add_method('SetData',

   291                    'void',

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

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

   294     cls.add_method('SetIdentifier',

   295                    'void',

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

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

   298     cls.add_method('SetSequenceNumber',

   299                    'void',

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

   301     return

   303 def register_Ns3Icmpv4Header_methods(root_module, cls):

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

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

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

   307     cls.add_constructor([])

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

   309     cls.add_method('Deserialize',

   310                    'uint32_t',

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

   312                    is_virtual=True)

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

   314     cls.add_method('EnableChecksum',

   315                    'void',

   316                    [])

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

   318     cls.add_method('GetCode',

   319                    'uint8_t',

   320                    [],

   321                    is_const=True)

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

   323     cls.add_method('GetInstanceTypeId',

   324                    'ns3::TypeId',

   325                    [],

   326                    is_const=True, is_virtual=True)

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

   328     cls.add_method('GetSerializedSize',

   329                    'uint32_t',

   330                    [],

   331                    is_const=True, is_virtual=True)

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

   333     cls.add_method('GetType',

   334                    'uint8_t',

   335                    [],

   336                    is_const=True)

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

   338     cls.add_method('GetTypeId',

   339                    'ns3::TypeId',

   340                    [],

   341                    is_static=True)

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

   343     cls.add_method('Print',

   344                    'void',

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

   346                    is_const=True, is_virtual=True)

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

   348     cls.add_method('Serialize',

   349                    'void',

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

   351                    is_const=True, is_virtual=True)

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

   353     cls.add_method('SetCode',

   354                    'void',

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

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

   357     cls.add_method('SetType',

   358                    'void',

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

   360     return

   362 def register_Ns3Icmpv4TimeExceeded_methods(root_module, cls):

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

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

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

   366     cls.add_constructor([])

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

   368     cls.add_method('Deserialize',

   369                    'uint32_t',

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

   371                    is_virtual=True)

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

   373     cls.add_method('GetData',

   374                    'void',

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

   376                    is_const=True)

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

   378     cls.add_method('GetHeader',

   379                    'ns3::Ipv4Header',

   380                    [],

   381                    is_const=True)

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

   383     cls.add_method('GetInstanceTypeId',

   384                    'ns3::TypeId',

   385                    [],

   386                    is_const=True, is_virtual=True)

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

   388     cls.add_method('GetSerializedSize',

   389                    'uint32_t',

   390                    [],

   391                    is_const=True, is_virtual=True)

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

   393     cls.add_method('GetTypeId',

   394                    'ns3::TypeId',

   395                    [],

   396                    is_static=True)

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

   398     cls.add_method('Print',

   399                    'void',

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

   401                    is_const=True, is_virtual=True)

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

   403     cls.add_method('Serialize',

   404                    'void',

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

   406                    is_const=True, is_virtual=True)

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

   408     cls.add_method('SetData',

   409                    'void',

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

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

   412     cls.add_method('SetHeader',

   413                    'void',

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

   415     return

   417 def register_Ns3Icmpv6Header_methods(root_module, cls):

   418     ## icmpv6-header.h: ns3::Icmpv6Header::Icmpv6Header(ns3::Icmpv6Header const & arg0) [copy constructor]

   419     cls.add_constructor([param('ns3::Icmpv6Header const &', 'arg0')])

   420     ## icmpv6-header.h: ns3::Icmpv6Header::Icmpv6Header() [constructor]

   421     cls.add_constructor([])

   422     ## icmpv6-header.h: void ns3::Icmpv6Header::CalculatePseudoHeaderChecksum(ns3::Ipv6Address src, ns3::Ipv6Address dst, uint16_t length, uint8_t protocol) [member function]

   423     cls.add_method('CalculatePseudoHeaderChecksum',

   424                    'void',

   425                    [param('ns3::Ipv6Address', 'src'), param('ns3::Ipv6Address', 'dst'), param('uint16_t', 'length'), param('uint8_t', 'protocol')])

   426     ## icmpv6-header.h: uint32_t ns3::Icmpv6Header::Deserialize(ns3::Buffer::Iterator start) [member function]

   427     cls.add_method('Deserialize',

   428                    'uint32_t',

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

   430                    is_virtual=True)

   431     ## icmpv6-header.h: uint16_t ns3::Icmpv6Header::GetChecksum() const [member function]

   432     cls.add_method('GetChecksum',

   433                    'uint16_t',

   434                    [],

   435                    is_const=True)

   436     ## icmpv6-header.h: uint8_t ns3::Icmpv6Header::GetCode() const [member function]

   437     cls.add_method('GetCode',

   438                    'uint8_t',

   439                    [],

   440                    is_const=True)

   441     ## icmpv6-header.h: ns3::TypeId ns3::Icmpv6Header::GetInstanceTypeId() const [member function]

   442     cls.add_method('GetInstanceTypeId',

   443                    'ns3::TypeId',

   444                    [],

   445                    is_const=True, is_virtual=True)

   446     ## icmpv6-header.h: uint32_t ns3::Icmpv6Header::GetSerializedSize() const [member function]

   447     cls.add_method('GetSerializedSize',

   448                    'uint32_t',

   449                    [],

   450                    is_const=True, is_virtual=True)

   451     ## icmpv6-header.h: uint8_t ns3::Icmpv6Header::GetType() const [member function]

   452     cls.add_method('GetType',

   453                    'uint8_t',

   454                    [],

   455                    is_const=True)

   456     ## icmpv6-header.h: static ns3::TypeId ns3::Icmpv6Header::GetTypeId() [member function]

   457     cls.add_method('GetTypeId',

   458                    'ns3::TypeId',

   459                    [],

   460                    is_static=True)

   461     ## icmpv6-header.h: void ns3::Icmpv6Header::Print(std::ostream & os) const [member function]

   462     cls.add_method('Print',

   463                    'void',

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

   465                    is_const=True, is_virtual=True)

   466     ## icmpv6-header.h: void ns3::Icmpv6Header::Serialize(ns3::Buffer::Iterator start) const [member function]

   467     cls.add_method('Serialize',

   468                    'void',

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

   470                    is_const=True, is_virtual=True)

   471     ## icmpv6-header.h: void ns3::Icmpv6Header::SetChecksum(uint16_t checksum) [member function]

   472     cls.add_method('SetChecksum',

   473                    'void',

   474                    [param('uint16_t', 'checksum')])

   475     ## icmpv6-header.h: void ns3::Icmpv6Header::SetCode(uint8_t code) [member function]

   476     cls.add_method('SetCode',

   477                    'void',

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

   479     ## icmpv6-header.h: void ns3::Icmpv6Header::SetType(uint8_t type) [member function]

   480     cls.add_method('SetType',

   481                    'void',

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

   483     return

   485 def register_Ns3Icmpv6NA_methods(root_module, cls):

   486     ## icmpv6-header.h: ns3::Icmpv6NA::Icmpv6NA(ns3::Icmpv6NA const & arg0) [copy constructor]

   487     cls.add_constructor([param('ns3::Icmpv6NA const &', 'arg0')])

   488     ## icmpv6-header.h: ns3::Icmpv6NA::Icmpv6NA() [constructor]

   489     cls.add_constructor([])

   490     ## icmpv6-header.h: uint32_t ns3::Icmpv6NA::Deserialize(ns3::Buffer::Iterator start) [member function]

   491     cls.add_method('Deserialize',

   492                    'uint32_t',

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

   494                    is_virtual=True)

   495     ## icmpv6-header.h: bool ns3::Icmpv6NA::GetFlagO() const [member function]

   496     cls.add_method('GetFlagO',

   497                    'bool',

   498                    [],

   499                    is_const=True)

   500     ## icmpv6-header.h: bool ns3::Icmpv6NA::GetFlagR() const [member function]

   501     cls.add_method('GetFlagR',

   502                    'bool',

   503                    [],

   504                    is_const=True)

   505     ## icmpv6-header.h: bool ns3::Icmpv6NA::GetFlagS() const [member function]

   506     cls.add_method('GetFlagS',

   507                    'bool',

   508                    [],

   509                    is_const=True)

   510     ## icmpv6-header.h: ns3::TypeId ns3::Icmpv6NA::GetInstanceTypeId() const [member function]

   511     cls.add_method('GetInstanceTypeId',

   512                    'ns3::TypeId',

   513                    [],

   514                    is_const=True, is_virtual=True)

   515     ## icmpv6-header.h: ns3::Ipv6Address ns3::Icmpv6NA::GetIpv6Target() const [member function]

   516     cls.add_method('GetIpv6Target',

   517                    'ns3::Ipv6Address',

   518                    [],

   519                    is_const=True)

   520     ## icmpv6-header.h: uint32_t ns3::Icmpv6NA::GetReserved() const [member function]

   521     cls.add_method('GetReserved',

   522                    'uint32_t',

   523                    [],

   524                    is_const=True)

   525     ## icmpv6-header.h: uint32_t ns3::Icmpv6NA::GetSerializedSize() const [member function]

   526     cls.add_method('GetSerializedSize',

   527                    'uint32_t',

   528                    [],

   529                    is_const=True, is_virtual=True)

   530     ## icmpv6-header.h: static ns3::TypeId ns3::Icmpv6NA::GetTypeId() [member function]

   531     cls.add_method('GetTypeId',

   532                    'ns3::TypeId',

   533                    [],

   534                    is_static=True)

   535     ## icmpv6-header.h: void ns3::Icmpv6NA::Print(std::ostream & os) const [member function]

   536     cls.add_method('Print',

   537                    'void',

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

   539                    is_const=True, is_virtual=True)

   540     ## icmpv6-header.h: void ns3::Icmpv6NA::Serialize(ns3::Buffer::Iterator start) const [member function]

   541     cls.add_method('Serialize',

   542                    'void',

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

   544                    is_const=True, is_virtual=True)

   545     ## icmpv6-header.h: void ns3::Icmpv6NA::SetFlagO(bool o) [member function]

   546     cls.add_method('SetFlagO',

   547                    'void',

   548                    [param('bool', 'o')])

   549     ## icmpv6-header.h: void ns3::Icmpv6NA::SetFlagR(bool r) [member function]

   550     cls.add_method('SetFlagR',

   551                    'void',

   552                    [param('bool', 'r')])

   553     ## icmpv6-header.h: void ns3::Icmpv6NA::SetFlagS(bool s) [member function]

   554     cls.add_method('SetFlagS',

   555                    'void',

   556                    [param('bool', 's')])

   557     ## icmpv6-header.h: void ns3::Icmpv6NA::SetIpv6Target(ns3::Ipv6Address target) [member function]

   558     cls.add_method('SetIpv6Target',

   559                    'void',

   560                    [param('ns3::Ipv6Address', 'target')])

   561     ## icmpv6-header.h: void ns3::Icmpv6NA::SetReserved(uint32_t reserved) [member function]

   562     cls.add_method('SetReserved',

   563                    'void',

   564                    [param('uint32_t', 'reserved')])

   565     return

   567 def register_Ns3Icmpv6NS_methods(root_module, cls):

   568     ## icmpv6-header.h: ns3::Icmpv6NS::Icmpv6NS(ns3::Icmpv6NS const & arg0) [copy constructor]

   569     cls.add_constructor([param('ns3::Icmpv6NS const &', 'arg0')])

   570     ## icmpv6-header.h: ns3::Icmpv6NS::Icmpv6NS(ns3::Ipv6Address target) [constructor]

   571     cls.add_constructor([param('ns3::Ipv6Address', 'target')])

   572     ## icmpv6-header.h: ns3::Icmpv6NS::Icmpv6NS() [constructor]

   573     cls.add_constructor([])

   574     ## icmpv6-header.h: uint32_t ns3::Icmpv6NS::Deserialize(ns3::Buffer::Iterator start) [member function]

   575     cls.add_method('Deserialize',

   576                    'uint32_t',

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

   578                    is_virtual=True)

   579     ## icmpv6-header.h: ns3::TypeId ns3::Icmpv6NS::GetInstanceTypeId() const [member function]

   580     cls.add_method('GetInstanceTypeId',

   581                    'ns3::TypeId',

   582                    [],

   583                    is_const=True, is_virtual=True)

   584     ## icmpv6-header.h: ns3::Ipv6Address ns3::Icmpv6NS::GetIpv6Target() const [member function]

   585     cls.add_method('GetIpv6Target',

   586                    'ns3::Ipv6Address',

   587                    [],

   588                    is_const=True)

   589     ## icmpv6-header.h: uint32_t ns3::Icmpv6NS::GetReserved() const [member function]

   590     cls.add_method('GetReserved',

   591                    'uint32_t',

   592                    [],

   593                    is_const=True)

   594     ## icmpv6-header.h: uint32_t ns3::Icmpv6NS::GetSerializedSize() const [member function]

   595     cls.add_method('GetSerializedSize',

   596                    'uint32_t',

   597                    [],

   598                    is_const=True, is_virtual=True)

   599     ## icmpv6-header.h: static ns3::TypeId ns3::Icmpv6NS::GetTypeId() [member function]

   600     cls.add_method('GetTypeId',

   601                    'ns3::TypeId',

   602                    [],

   603                    is_static=True)

   604     ## icmpv6-header.h: void ns3::Icmpv6NS::Print(std::ostream & os) const [member function]

   605     cls.add_method('Print',

   606                    'void',

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

   608                    is_const=True, is_virtual=True)

   609     ## icmpv6-header.h: void ns3::Icmpv6NS::Serialize(ns3::Buffer::Iterator start) const [member function]

   610     cls.add_method('Serialize',

   611                    'void',

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

   613                    is_const=True, is_virtual=True)

   614     ## icmpv6-header.h: void ns3::Icmpv6NS::SetIpv6Target(ns3::Ipv6Address target) [member function]

   615     cls.add_method('SetIpv6Target',

   616                    'void',

   617                    [param('ns3::Ipv6Address', 'target')])

   618     ## icmpv6-header.h: void ns3::Icmpv6NS::SetReserved(uint32_t reserved) [member function]

   619     cls.add_method('SetReserved',

   620                    'void',

   621                    [param('uint32_t', 'reserved')])

   622     return

   624 def register_Ns3Icmpv6OptionHeader_methods(root_module, cls):

   625     ## icmpv6-header.h: ns3::Icmpv6OptionHeader::Icmpv6OptionHeader(ns3::Icmpv6OptionHeader const & arg0) [copy constructor]

   626     cls.add_constructor([param('ns3::Icmpv6OptionHeader const &', 'arg0')])

   627     ## icmpv6-header.h: ns3::Icmpv6OptionHeader::Icmpv6OptionHeader() [constructor]

   628     cls.add_constructor([])

   629     ## icmpv6-header.h: uint32_t ns3::Icmpv6OptionHeader::Deserialize(ns3::Buffer::Iterator start) [member function]

   630     cls.add_method('Deserialize',

   631                    'uint32_t',

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

   633                    is_virtual=True)

   634     ## icmpv6-header.h: ns3::TypeId ns3::Icmpv6OptionHeader::GetInstanceTypeId() const [member function]

   635     cls.add_method('GetInstanceTypeId',

   636                    'ns3::TypeId',

   637                    [],

   638                    is_const=True, is_virtual=True)

   639     ## icmpv6-header.h: uint8_t ns3::Icmpv6OptionHeader::GetLength() const [member function]

   640     cls.add_method('GetLength',

   641                    'uint8_t',

   642                    [],

   643                    is_const=True)

   644     ## icmpv6-header.h: uint32_t ns3::Icmpv6OptionHeader::GetSerializedSize() const [member function]

   645     cls.add_method('GetSerializedSize',

   646                    'uint32_t',

   647                    [],

   648                    is_const=True, is_virtual=True)

   649     ## icmpv6-header.h: uint8_t ns3::Icmpv6OptionHeader::GetType() const [member function]

   650     cls.add_method('GetType',

   651                    'uint8_t',

   652                    [],

   653                    is_const=True)

   654     ## icmpv6-header.h: static ns3::TypeId ns3::Icmpv6OptionHeader::GetTypeId() [member function]

   655     cls.add_method('GetTypeId',

   656                    'ns3::TypeId',

   657                    [],

   658                    is_static=True)

   659     ## icmpv6-header.h: void ns3::Icmpv6OptionHeader::Print(std::ostream & os) const [member function]

   660     cls.add_method('Print',

   661                    'void',

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

   663                    is_const=True, is_virtual=True)

   664     ## icmpv6-header.h: void ns3::Icmpv6OptionHeader::Serialize(ns3::Buffer::Iterator start) const [member function]

   665     cls.add_method('Serialize',

   666                    'void',

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

   668                    is_const=True, is_virtual=True)

   669     ## icmpv6-header.h: void ns3::Icmpv6OptionHeader::SetLength(uint8_t len) [member function]

   670     cls.add_method('SetLength',

   671                    'void',

   672                    [param('uint8_t', 'len')])

   673     ## icmpv6-header.h: void ns3::Icmpv6OptionHeader::SetType(uint8_t type) [member function]

   674     cls.add_method('SetType',

   675                    'void',

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

   677     return

   679 def register_Ns3Icmpv6OptionLinkLayerAddress_methods(root_module, cls):

   680     ## icmpv6-header.h: ns3::Icmpv6OptionLinkLayerAddress::Icmpv6OptionLinkLayerAddress(ns3::Icmpv6OptionLinkLayerAddress const & arg0) [copy constructor]

   681     cls.add_constructor([param('ns3::Icmpv6OptionLinkLayerAddress const &', 'arg0')])

   682     ## icmpv6-header.h: ns3::Icmpv6OptionLinkLayerAddress::Icmpv6OptionLinkLayerAddress(bool source) [constructor]

   683     cls.add_constructor([param('bool', 'source')])

   684     ## icmpv6-header.h: ns3::Icmpv6OptionLinkLayerAddress::Icmpv6OptionLinkLayerAddress(bool source, ns3::Address addr) [constructor]

   685     cls.add_constructor([param('bool', 'source'), param('ns3::Address', 'addr')])

   686     ## icmpv6-header.h: ns3::Icmpv6OptionLinkLayerAddress::Icmpv6OptionLinkLayerAddress() [constructor]

   687     cls.add_constructor([])

   688     ## icmpv6-header.h: uint32_t ns3::Icmpv6OptionLinkLayerAddress::Deserialize(ns3::Buffer::Iterator start) [member function]

   689     cls.add_method('Deserialize',

   690                    'uint32_t',

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

   692                    is_virtual=True)

   693     ## icmpv6-header.h: ns3::Address ns3::Icmpv6OptionLinkLayerAddress::GetAddress() const [member function]

   694     cls.add_method('GetAddress',

   695                    'ns3::Address',

   696                    [],

   697                    is_const=True)

   698     ## icmpv6-header.h: ns3::TypeId ns3::Icmpv6OptionLinkLayerAddress::GetInstanceTypeId() const [member function]

   699     cls.add_method('GetInstanceTypeId',

   700                    'ns3::TypeId',

   701                    [],

   702                    is_const=True, is_virtual=True)

   703     ## icmpv6-header.h: uint32_t ns3::Icmpv6OptionLinkLayerAddress::GetSerializedSize() const [member function]

   704     cls.add_method('GetSerializedSize',

   705                    'uint32_t',

   706                    [],

   707                    is_const=True, is_virtual=True)

   708     ## icmpv6-header.h: static ns3::TypeId ns3::Icmpv6OptionLinkLayerAddress::GetTypeId() [member function]

   709     cls.add_method('GetTypeId',

   710                    'ns3::TypeId',

   711                    [],

   712                    is_static=True)

   713     ## icmpv6-header.h: void ns3::Icmpv6OptionLinkLayerAddress::Print(std::ostream & os) const [member function]

   714     cls.add_method('Print',

   715                    'void',

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

   717                    is_const=True, is_virtual=True)

   718     ## icmpv6-header.h: void ns3::Icmpv6OptionLinkLayerAddress::Serialize(ns3::Buffer::Iterator start) const [member function]

   719     cls.add_method('Serialize',

   720                    'void',

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

   722                    is_const=True, is_virtual=True)

   723     ## icmpv6-header.h: void ns3::Icmpv6OptionLinkLayerAddress::SetAddress(ns3::Address addr) [member function]

   724     cls.add_method('SetAddress',

   725                    'void',

   726                    [param('ns3::Address', 'addr')])

   727     return

   729 def register_Ns3Icmpv6OptionMtu_methods(root_module, cls):

   730     ## icmpv6-header.h: ns3::Icmpv6OptionMtu::Icmpv6OptionMtu(ns3::Icmpv6OptionMtu const & arg0) [copy constructor]

   731     cls.add_constructor([param('ns3::Icmpv6OptionMtu const &', 'arg0')])

   732     ## icmpv6-header.h: ns3::Icmpv6OptionMtu::Icmpv6OptionMtu() [constructor]

   733     cls.add_constructor([])

   734     ## icmpv6-header.h: ns3::Icmpv6OptionMtu::Icmpv6OptionMtu(uint32_t mtu) [constructor]

   735     cls.add_constructor([param('uint32_t', 'mtu')])

   736     ## icmpv6-header.h: uint32_t ns3::Icmpv6OptionMtu::Deserialize(ns3::Buffer::Iterator start) [member function]

   737     cls.add_method('Deserialize',

   738                    'uint32_t',

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

   740                    is_virtual=True)

   741     ## icmpv6-header.h: ns3::TypeId ns3::Icmpv6OptionMtu::GetInstanceTypeId() const [member function]

   742     cls.add_method('GetInstanceTypeId',

   743                    'ns3::TypeId',

   744                    [],

   745                    is_const=True, is_virtual=True)

   746     ## icmpv6-header.h: uint32_t ns3::Icmpv6OptionMtu::GetMtu() const [member function]

   747     cls.add_method('GetMtu',

   748                    'uint32_t',

   749                    [],

   750                    is_const=True)

   751     ## icmpv6-header.h: uint16_t ns3::Icmpv6OptionMtu::GetReserved() const [member function]

   752     cls.add_method('GetReserved',

   753                    'uint16_t',

   754                    [],

   755                    is_const=True)

   756     ## icmpv6-header.h: uint32_t ns3::Icmpv6OptionMtu::GetSerializedSize() const [member function]

   757     cls.add_method('GetSerializedSize',

   758                    'uint32_t',

   759                    [],

   760                    is_const=True, is_virtual=True)

   761     ## icmpv6-header.h: static ns3::TypeId ns3::Icmpv6OptionMtu::GetTypeId() [member function]

   762     cls.add_method('GetTypeId',

   763                    'ns3::TypeId',

   764                    [],

   765                    is_static=True)

   766     ## icmpv6-header.h: void ns3::Icmpv6OptionMtu::Print(std::ostream & os) const [member function]

   767     cls.add_method('Print',

   768                    'void',

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

   770                    is_const=True, is_virtual=True)

   771     ## icmpv6-header.h: void ns3::Icmpv6OptionMtu::Serialize(ns3::Buffer::Iterator start) const [member function]

   772     cls.add_method('Serialize',

   773                    'void',

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

   775                    is_const=True, is_virtual=True)

   776     ## icmpv6-header.h: void ns3::Icmpv6OptionMtu::SetMtu(uint32_t mtu) [member function]

   777     cls.add_method('SetMtu',

   778                    'void',

   779                    [param('uint32_t', 'mtu')])

   780     ## icmpv6-header.h: void ns3::Icmpv6OptionMtu::SetReserved(uint16_t reserved) [member function]

   781     cls.add_method('SetReserved',

   782                    'void',

   783                    [param('uint16_t', 'reserved')])

   784     return

   786 def register_Ns3Icmpv6OptionPrefixInformation_methods(root_module, cls):

   787     ## icmpv6-header.h: ns3::Icmpv6OptionPrefixInformation::Icmpv6OptionPrefixInformation(ns3::Icmpv6OptionPrefixInformation const & arg0) [copy constructor]

   788     cls.add_constructor([param('ns3::Icmpv6OptionPrefixInformation const &', 'arg0')])

   789     ## icmpv6-header.h: ns3::Icmpv6OptionPrefixInformation::Icmpv6OptionPrefixInformation() [constructor]

   790     cls.add_constructor([])

   791     ## icmpv6-header.h: ns3::Icmpv6OptionPrefixInformation::Icmpv6OptionPrefixInformation(ns3::Ipv6Address network, uint8_t prefixlen) [constructor]

   792     cls.add_constructor([param('ns3::Ipv6Address', 'network'), param('uint8_t', 'prefixlen')])

   793     ## icmpv6-header.h: uint32_t ns3::Icmpv6OptionPrefixInformation::Deserialize(ns3::Buffer::Iterator start) [member function]

   794     cls.add_method('Deserialize',

   795                    'uint32_t',

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

   797                    is_virtual=True)

   798     ## icmpv6-header.h: uint8_t ns3::Icmpv6OptionPrefixInformation::GetFlags() const [member function]

   799     cls.add_method('GetFlags',

   800                    'uint8_t',

   801                    [],

   802                    is_const=True)

   803     ## icmpv6-header.h: ns3::TypeId ns3::Icmpv6OptionPrefixInformation::GetInstanceTypeId() const [member function]

   804     cls.add_method('GetInstanceTypeId',

   805                    'ns3::TypeId',

   806                    [],

   807                    is_const=True, is_virtual=True)

   808     ## icmpv6-header.h: uint32_t ns3::Icmpv6OptionPrefixInformation::GetPreferredTime() const [member function]

   809     cls.add_method('GetPreferredTime',

   810                    'uint32_t',

   811                    [],

   812                    is_const=True)

   813     ## icmpv6-header.h: ns3::Ipv6Address ns3::Icmpv6OptionPrefixInformation::GetPrefix() const [member function]

   814     cls.add_method('GetPrefix',

   815                    'ns3::Ipv6Address',

   816                    [],

   817                    is_const=True)

   818     ## icmpv6-header.h: uint8_t ns3::Icmpv6OptionPrefixInformation::GetPrefixLength() const [member function]

   819     cls.add_method('GetPrefixLength',

   820                    'uint8_t',

   821                    [],

   822                    is_const=True)

   823     ## icmpv6-header.h: uint32_t ns3::Icmpv6OptionPrefixInformation::GetReserved() const [member function]

   824     cls.add_method('GetReserved',

   825                    'uint32_t',

   826                    [],

   827                    is_const=True)

   828     ## icmpv6-header.h: uint32_t ns3::Icmpv6OptionPrefixInformation::GetSerializedSize() const [member function]

   829     cls.add_method('GetSerializedSize',

   830                    'uint32_t',

   831                    [],

   832                    is_const=True, is_virtual=True)

   833     ## icmpv6-header.h: static ns3::TypeId ns3::Icmpv6OptionPrefixInformation::GetTypeId() [member function]

   834     cls.add_method('GetTypeId',

   835                    'ns3::TypeId',

   836                    [],

   837                    is_static=True)

   838     ## icmpv6-header.h: uint32_t ns3::Icmpv6OptionPrefixInformation::GetValidTime() const [member function]

   839     cls.add_method('GetValidTime',

   840                    'uint32_t',

   841                    [],

   842                    is_const=True)

   843     ## icmpv6-header.h: void ns3::Icmpv6OptionPrefixInformation::Print(std::ostream & os) const [member function]

   844     cls.add_method('Print',

   845                    'void',

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

   847                    is_const=True, is_virtual=True)

   848     ## icmpv6-header.h: void ns3::Icmpv6OptionPrefixInformation::Serialize(ns3::Buffer::Iterator start) const [member function]

   849     cls.add_method('Serialize',

   850                    'void',

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

   852                    is_const=True, is_virtual=True)

   853     ## icmpv6-header.h: void ns3::Icmpv6OptionPrefixInformation::SetFlags(uint8_t flags) [member function]

   854     cls.add_method('SetFlags',

   855                    'void',

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

   857     ## icmpv6-header.h: void ns3::Icmpv6OptionPrefixInformation::SetPreferredTime(uint32_t preferredTime) [member function]

   858     cls.add_method('SetPreferredTime',

   859                    'void',

   860                    [param('uint32_t', 'preferredTime')])

   861     ## icmpv6-header.h: void ns3::Icmpv6OptionPrefixInformation::SetPrefix(ns3::Ipv6Address prefix) [member function]

   862     cls.add_method('SetPrefix',

   863                    'void',

   864                    [param('ns3::Ipv6Address', 'prefix')])

   865     ## icmpv6-header.h: void ns3::Icmpv6OptionPrefixInformation::SetPrefixLength(uint8_t prefixLength) [member function]

   866     cls.add_method('SetPrefixLength',

   867                    'void',

   868                    [param('uint8_t', 'prefixLength')])

   869     ## icmpv6-header.h: void ns3::Icmpv6OptionPrefixInformation::SetReserved(uint32_t reserved) [member function]

   870     cls.add_method('SetReserved',

   871                    'void',

   872                    [param('uint32_t', 'reserved')])

   873     ## icmpv6-header.h: void ns3::Icmpv6OptionPrefixInformation::SetValidTime(uint32_t validTime) [member function]

   874     cls.add_method('SetValidTime',

   875                    'void',

   876                    [param('uint32_t', 'validTime')])

   877     return

   879 def register_Ns3Icmpv6OptionRedirected_methods(root_module, cls):

   880     ## icmpv6-header.h: ns3::Icmpv6OptionRedirected::Icmpv6OptionRedirected(ns3::Icmpv6OptionRedirected const & arg0) [copy constructor]

   881     cls.add_constructor([param('ns3::Icmpv6OptionRedirected const &', 'arg0')])

   882     ## icmpv6-header.h: ns3::Icmpv6OptionRedirected::Icmpv6OptionRedirected() [constructor]

   883     cls.add_constructor([])

   884     ## icmpv6-header.h: uint32_t ns3::Icmpv6OptionRedirected::Deserialize(ns3::Buffer::Iterator start) [member function]

   885     cls.add_method('Deserialize',

   886                    'uint32_t',

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

   888                    is_virtual=True)

   889     ## icmpv6-header.h: ns3::TypeId ns3::Icmpv6OptionRedirected::GetInstanceTypeId() const [member function]

   890     cls.add_method('GetInstanceTypeId',

   891                    'ns3::TypeId',

   892                    [],

   893                    is_const=True, is_virtual=True)

   894     ## icmpv6-header.h: ns3::Ptr<ns3::Packet> ns3::Icmpv6OptionRedirected::GetPacket() const [member function]

   895     cls.add_method('GetPacket',

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

   897                    [],

   898                    is_const=True)

   899     ## icmpv6-header.h: uint32_t ns3::Icmpv6OptionRedirected::GetSerializedSize() const [member function]

   900     cls.add_method('GetSerializedSize',

   901                    'uint32_t',

   902                    [],

   903                    is_const=True, is_virtual=True)

   904     ## icmpv6-header.h: static ns3::TypeId ns3::Icmpv6OptionRedirected::GetTypeId() [member function]

   905     cls.add_method('GetTypeId',

   906                    'ns3::TypeId',

   907                    [],

   908                    is_static=True)

   909     ## icmpv6-header.h: void ns3::Icmpv6OptionRedirected::Print(std::ostream & os) const [member function]

   910     cls.add_method('Print',

   911                    'void',

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

   913                    is_const=True, is_virtual=True)

   914     ## icmpv6-header.h: void ns3::Icmpv6OptionRedirected::Serialize(ns3::Buffer::Iterator start) const [member function]

   915     cls.add_method('Serialize',

   916                    'void',

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

   918                    is_const=True, is_virtual=True)

   919     ## icmpv6-header.h: void ns3::Icmpv6OptionRedirected::SetPacket(ns3::Ptr<ns3::Packet> packet) [member function]

   920     cls.add_method('SetPacket',

   921                    'void',

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

   923     return

   925 def register_Ns3Icmpv6ParameterError_methods(root_module, cls):

   926     ## icmpv6-header.h: ns3::Icmpv6ParameterError::Icmpv6ParameterError(ns3::Icmpv6ParameterError const & arg0) [copy constructor]

   927     cls.add_constructor([param('ns3::Icmpv6ParameterError const &', 'arg0')])

   928     ## icmpv6-header.h: ns3::Icmpv6ParameterError::Icmpv6ParameterError() [constructor]

   929     cls.add_constructor([])

   930     ## icmpv6-header.h: uint32_t ns3::Icmpv6ParameterError::Deserialize(ns3::Buffer::Iterator start) [member function]

   931     cls.add_method('Deserialize',

   932                    'uint32_t',

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

   934                    is_virtual=True)

   935     ## icmpv6-header.h: ns3::TypeId ns3::Icmpv6ParameterError::GetInstanceTypeId() const [member function]

   936     cls.add_method('GetInstanceTypeId',

   937                    'ns3::TypeId',

   938                    [],

   939                    is_const=True, is_virtual=True)

   940     ## icmpv6-header.h: ns3::Ptr<ns3::Packet> ns3::Icmpv6ParameterError::GetPacket() const [member function]

   941     cls.add_method('GetPacket',

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

   943                    [],

   944                    is_const=True)

   945     ## icmpv6-header.h: uint32_t ns3::Icmpv6ParameterError::GetPtr() const [member function]

   946     cls.add_method('GetPtr',

   947                    'uint32_t',

   948                    [],

   949                    is_const=True)

   950     ## icmpv6-header.h: uint32_t ns3::Icmpv6ParameterError::GetSerializedSize() const [member function]

   951     cls.add_method('GetSerializedSize',

   952                    'uint32_t',

   953                    [],

   954                    is_const=True, is_virtual=True)

   955     ## icmpv6-header.h: static ns3::TypeId ns3::Icmpv6ParameterError::GetTypeId() [member function]

   956     cls.add_method('GetTypeId',

   957                    'ns3::TypeId',

   958                    [],

   959                    is_static=True)

   960     ## icmpv6-header.h: void ns3::Icmpv6ParameterError::Print(std::ostream & os) [member function]

   961     cls.add_method('Print',

   962                    'void',

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

   964                    is_virtual=True)

   965     ## icmpv6-header.h: void ns3::Icmpv6ParameterError::Serialize(ns3::Buffer::Iterator start) const [member function]

   966     cls.add_method('Serialize',

   967                    'void',

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

   969                    is_const=True, is_virtual=True)

   970     ## icmpv6-header.h: void ns3::Icmpv6ParameterError::SetPacket(ns3::Ptr<ns3::Packet> p) [member function]

   971     cls.add_method('SetPacket',

   972                    'void',

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

   974     ## icmpv6-header.h: void ns3::Icmpv6ParameterError::SetPtr(uint32_t ptr) [member function]

   975     cls.add_method('SetPtr',

   976                    'void',

   977                    [param('uint32_t', 'ptr')])

   978     return

   980 def register_Ns3Icmpv6RA_methods(root_module, cls):

   981     ## icmpv6-header.h: ns3::Icmpv6RA::Icmpv6RA(ns3::Icmpv6RA const & arg0) [copy constructor]

   982     cls.add_constructor([param('ns3::Icmpv6RA const &', 'arg0')])

   983     ## icmpv6-header.h: ns3::Icmpv6RA::Icmpv6RA() [constructor]

   984     cls.add_constructor([])

   985     ## icmpv6-header.h: uint32_t ns3::Icmpv6RA::Deserialize(ns3::Buffer::Iterator start) [member function]

   986     cls.add_method('Deserialize',

   987                    'uint32_t',

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

   989                    is_virtual=True)

   990     ## icmpv6-header.h: uint8_t ns3::Icmpv6RA::GetCurHopLimit() const [member function]

   991     cls.add_method('GetCurHopLimit',

   992                    'uint8_t',

   993                    [],

   994                    is_const=True)

   995     ## icmpv6-header.h: bool ns3::Icmpv6RA::GetFlagH() const [member function]

   996     cls.add_method('GetFlagH',

   997                    'bool',

   998                    [],

   999                    is_const=True)

  1000     ## icmpv6-header.h: bool ns3::Icmpv6RA::GetFlagM() const [member function]

  1001     cls.add_method('GetFlagM',

  1002                    'bool',

  1003                    [],

  1004                    is_const=True)

  1005     ## icmpv6-header.h: bool ns3::Icmpv6RA::GetFlagO() const [member function]

  1006     cls.add_method('GetFlagO',

  1007                    'bool',

  1008                    [],

  1009                    is_const=True)

  1010     ## icmpv6-header.h: uint8_t ns3::Icmpv6RA::GetFlags() const [member function]

  1011     cls.add_method('GetFlags',

  1012                    'uint8_t',

  1013                    [],

  1014                    is_const=True)

  1015     ## icmpv6-header.h: ns3::TypeId ns3::Icmpv6RA::GetInstanceTypeId() const [member function]

  1016     cls.add_method('GetInstanceTypeId',

  1017                    'ns3::TypeId',

  1018                    [],

  1019                    is_const=True, is_virtual=True)

  1020     ## icmpv6-header.h: uint16_t ns3::Icmpv6RA::GetLifeTime() const [member function]

  1021     cls.add_method('GetLifeTime',

  1022                    'uint16_t',

  1023                    [],

  1024                    is_const=True)

  1025     ## icmpv6-header.h: uint32_t ns3::Icmpv6RA::GetReachableTime() const [member function]

  1026     cls.add_method('GetReachableTime',

  1027                    'uint32_t',

  1028                    [],

  1029                    is_const=True)

  1030     ## icmpv6-header.h: uint32_t ns3::Icmpv6RA::GetRetransmissionTime() const [member function]

  1031     cls.add_method('GetRetransmissionTime',

  1032                    'uint32_t',

  1033                    [],

  1034                    is_const=True)

  1035     ## icmpv6-header.h: uint32_t ns3::Icmpv6RA::GetSerializedSize() const [member function]

  1036     cls.add_method('GetSerializedSize',

  1037                    'uint32_t',

  1038                    [],

  1039                    is_const=True, is_virtual=True)

  1040     ## icmpv6-header.h: static ns3::TypeId ns3::Icmpv6RA::GetTypeId() [member function]

  1041     cls.add_method('GetTypeId',

  1042                    'ns3::TypeId',

  1043                    [],

  1044                    is_static=True)

  1045     ## icmpv6-header.h: void ns3::Icmpv6RA::Print(std::ostream & os) const [member function]

  1046     cls.add_method('Print',

  1047                    'void',

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

  1049                    is_const=True, is_virtual=True)

  1050     ## icmpv6-header.h: void ns3::Icmpv6RA::Serialize(ns3::Buffer::Iterator start) const [member function]

  1051     cls.add_method('Serialize',

  1052                    'void',

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

  1054                    is_const=True, is_virtual=True)

  1055     ## icmpv6-header.h: void ns3::Icmpv6RA::SetCurHopLimit(uint8_t m) [member function]

  1056     cls.add_method('SetCurHopLimit',

  1057                    'void',

  1058                    [param('uint8_t', 'm')])

  1059     ## icmpv6-header.h: void ns3::Icmpv6RA::SetFlagH(bool h) [member function]

  1060     cls.add_method('SetFlagH',

  1061                    'void',

  1062                    [param('bool', 'h')])

  1063     ## icmpv6-header.h: void ns3::Icmpv6RA::SetFlagM(bool m) [member function]

  1064     cls.add_method('SetFlagM',

  1065                    'void',

  1066                    [param('bool', 'm')])

  1067     ## icmpv6-header.h: void ns3::Icmpv6RA::SetFlagO(bool o) [member function]

  1068     cls.add_method('SetFlagO',

  1069                    'void',

  1070                    [param('bool', 'o')])

  1071     ## icmpv6-header.h: void ns3::Icmpv6RA::SetFlags(uint8_t f) [member function]

  1072     cls.add_method('SetFlags',

  1073                    'void',

  1074                    [param('uint8_t', 'f')])

  1075     ## icmpv6-header.h: void ns3::Icmpv6RA::SetLifeTime(uint16_t l) [member function]

  1076     cls.add_method('SetLifeTime',

  1077                    'void',

  1078                    [param('uint16_t', 'l')])

  1079     ## icmpv6-header.h: void ns3::Icmpv6RA::SetReachableTime(uint32_t r) [member function]

  1080     cls.add_method('SetReachableTime',

  1081                    'void',

  1082                    [param('uint32_t', 'r')])

  1083     ## icmpv6-header.h: void ns3::Icmpv6RA::SetRetransmissionTime(uint32_t r) [member function]

  1084     cls.add_method('SetRetransmissionTime',

  1085                    'void',

  1086                    [param('uint32_t', 'r')])

  1087     return

  1089 def register_Ns3Icmpv6RS_methods(root_module, cls):

  1090     ## icmpv6-header.h: ns3::Icmpv6RS::Icmpv6RS(ns3::Icmpv6RS const & arg0) [copy constructor]

  1091     cls.add_constructor([param('ns3::Icmpv6RS const &', 'arg0')])

  1092     ## icmpv6-header.h: ns3::Icmpv6RS::Icmpv6RS() [constructor]

  1093     cls.add_constructor([])

  1094     ## icmpv6-header.h: uint32_t ns3::Icmpv6RS::Deserialize(ns3::Buffer::Iterator start) [member function]

  1095     cls.add_method('Deserialize',

  1096                    'uint32_t',

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

  1098                    is_virtual=True)

  1099     ## icmpv6-header.h: ns3::TypeId ns3::Icmpv6RS::GetInstanceTypeId() const [member function]

  1100     cls.add_method('GetInstanceTypeId',

  1101                    'ns3::TypeId',

  1102                    [],

  1103                    is_const=True, is_virtual=True)

  1104     ## icmpv6-header.h: uint32_t ns3::Icmpv6RS::GetReserved() const [member function]

  1105     cls.add_method('GetReserved',

  1106                    'uint32_t',

  1107                    [],

  1108                    is_const=True)

  1109     ## icmpv6-header.h: uint32_t ns3::Icmpv6RS::GetSerializedSize() const [member function]

  1110     cls.add_method('GetSerializedSize',

  1111                    'uint32_t',

  1112                    [],

  1113                    is_const=True, is_virtual=True)

  1114     ## icmpv6-header.h: static ns3::TypeId ns3::Icmpv6RS::GetTypeId() [member function]

  1115     cls.add_method('GetTypeId',

  1116                    'ns3::TypeId',

  1117                    [],

  1118                    is_static=True)

  1119     ## icmpv6-header.h: void ns3::Icmpv6RS::Print(std::ostream & os) [member function]

  1120     cls.add_method('Print',

  1121                    'void',

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

  1123                    is_virtual=True)

  1124     ## icmpv6-header.h: void ns3::Icmpv6RS::Serialize(ns3::Buffer::Iterator start) const [member function]

  1125     cls.add_method('Serialize',

  1126                    'void',

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

  1128                    is_const=True, is_virtual=True)

  1129     ## icmpv6-header.h: void ns3::Icmpv6RS::SetReserved(uint32_t reserved) [member function]

  1130     cls.add_method('SetReserved',

  1131                    'void',

  1132                    [param('uint32_t', 'reserved')])

  1133     return

  1135 def register_Ns3Icmpv6Redirection_methods(root_module, cls):

  1136     ## icmpv6-header.h: ns3::Icmpv6Redirection::Icmpv6Redirection(ns3::Icmpv6Redirection const & arg0) [copy constructor]

  1137     cls.add_constructor([param('ns3::Icmpv6Redirection const &', 'arg0')])

  1138     ## icmpv6-header.h: ns3::Icmpv6Redirection::Icmpv6Redirection() [constructor]

  1139     cls.add_constructor([])

  1140     ## icmpv6-header.h: uint32_t ns3::Icmpv6Redirection::Deserialize(ns3::Buffer::Iterator start) [member function]

  1141     cls.add_method('Deserialize',

  1142                    'uint32_t',

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

  1144                    is_virtual=True)

  1145     ## icmpv6-header.h: ns3::Ipv6Address ns3::Icmpv6Redirection::GetDestination() const [member function]

  1146     cls.add_method('GetDestination',

  1147                    'ns3::Ipv6Address',

  1148                    [],

  1149                    is_const=True)

  1150     ## icmpv6-header.h: ns3::TypeId ns3::Icmpv6Redirection::GetInstanceTypeId() const [member function]

  1151     cls.add_method('GetInstanceTypeId',

  1152                    'ns3::TypeId',

  1153                    [],

  1154                    is_const=True, is_virtual=True)

  1155     ## icmpv6-header.h: uint32_t ns3::Icmpv6Redirection::GetReserved() const [member function]

  1156     cls.add_method('GetReserved',

  1157                    'uint32_t',

  1158                    [],

  1159                    is_const=True)

  1160     ## icmpv6-header.h: uint32_t ns3::Icmpv6Redirection::GetSerializedSize() const [member function]

  1161     cls.add_method('GetSerializedSize',

  1162                    'uint32_t',

  1163                    [],

  1164                    is_const=True, is_virtual=True)

  1165     ## icmpv6-header.h: ns3::Ipv6Address ns3::Icmpv6Redirection::GetTarget() const [member function]

  1166     cls.add_method('GetTarget',

  1167                    'ns3::Ipv6Address',

  1168                    [],

  1169                    is_const=True)

  1170     ## icmpv6-header.h: static ns3::TypeId ns3::Icmpv6Redirection::GetTypeId() [member function]

  1171     cls.add_method('GetTypeId',

  1172                    'ns3::TypeId',

  1173                    [],

  1174                    is_static=True)

  1175     ## icmpv6-header.h: void ns3::Icmpv6Redirection::Print(std::ostream & os) [member function]

  1176     cls.add_method('Print',

  1177                    'void',

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

  1179                    is_virtual=True)

  1180     ## icmpv6-header.h: void ns3::Icmpv6Redirection::Serialize(ns3::Buffer::Iterator start) const [member function]

  1181     cls.add_method('Serialize',

  1182                    'void',

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

  1184                    is_const=True, is_virtual=True)

  1185     ## icmpv6-header.h: void ns3::Icmpv6Redirection::SetDestination(ns3::Ipv6Address destination) [member function]

  1186     cls.add_method('SetDestination',

  1187                    'void',

  1188                    [param('ns3::Ipv6Address', 'destination')])

  1189     ## icmpv6-header.h: void ns3::Icmpv6Redirection::SetReserved(uint32_t reserved) [member function]

  1190     cls.add_method('SetReserved',

  1191                    'void',

  1192                    [param('uint32_t', 'reserved')])

  1193     ## icmpv6-header.h: void ns3::Icmpv6Redirection::SetTarget(ns3::Ipv6Address target) [member function]

  1194     cls.add_method('SetTarget',

  1195                    'void',

  1196                    [param('ns3::Ipv6Address', 'target')])

  1197     return

  1199 def register_Ns3Icmpv6TimeExceeded_methods(root_module, cls):

  1200     ## icmpv6-header.h: ns3::Icmpv6TimeExceeded::Icmpv6TimeExceeded(ns3::Icmpv6TimeExceeded const & arg0) [copy constructor]

  1201     cls.add_constructor([param('ns3::Icmpv6TimeExceeded const &', 'arg0')])

  1202     ## icmpv6-header.h: ns3::Icmpv6TimeExceeded::Icmpv6TimeExceeded() [constructor]

  1203     cls.add_constructor([])

  1204     ## icmpv6-header.h: uint32_t ns3::Icmpv6TimeExceeded::Deserialize(ns3::Buffer::Iterator start) [member function]

  1205     cls.add_method('Deserialize',

  1206                    'uint32_t',

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

  1208                    is_virtual=True)

  1209     ## icmpv6-header.h: ns3::TypeId ns3::Icmpv6TimeExceeded::GetInstanceTypeId() const [member function]

  1210     cls.add_method('GetInstanceTypeId',

  1211                    'ns3::TypeId',

  1212                    [],

  1213                    is_const=True, is_virtual=True)

  1214     ## icmpv6-header.h: ns3::Ptr<ns3::Packet> ns3::Icmpv6TimeExceeded::GetPacket() const [member function]

  1215     cls.add_method('GetPacket',

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

  1217                    [],

  1218                    is_const=True)

  1219     ## icmpv6-header.h: uint32_t ns3::Icmpv6TimeExceeded::GetSerializedSize() const [member function]

  1220     cls.add_method('GetSerializedSize',

  1221                    'uint32_t',

  1222                    [],

  1223                    is_const=True, is_virtual=True)

  1224     ## icmpv6-header.h: static ns3::TypeId ns3::Icmpv6TimeExceeded::GetTypeId() [member function]

  1225     cls.add_method('GetTypeId',

  1226                    'ns3::TypeId',

  1227                    [],

  1228                    is_static=True)

  1229     ## icmpv6-header.h: void ns3::Icmpv6TimeExceeded::Print(std::ostream & os) [member function]

  1230     cls.add_method('Print',

  1231                    'void',

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

  1233                    is_virtual=True)

  1234     ## icmpv6-header.h: void ns3::Icmpv6TimeExceeded::Serialize(ns3::Buffer::Iterator start) const [member function]

  1235     cls.add_method('Serialize',

  1236                    'void',

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

  1238                    is_const=True, is_virtual=True)

  1239     ## icmpv6-header.h: void ns3::Icmpv6TimeExceeded::SetPacket(ns3::Ptr<ns3::Packet> p) [member function]

  1240     cls.add_method('SetPacket',

  1241                    'void',

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

  1243     return

  1245 def register_Ns3Icmpv6TooBig_methods(root_module, cls):

  1246     ## icmpv6-header.h: ns3::Icmpv6TooBig::Icmpv6TooBig(ns3::Icmpv6TooBig const & arg0) [copy constructor]

  1247     cls.add_constructor([param('ns3::Icmpv6TooBig const &', 'arg0')])

  1248     ## icmpv6-header.h: ns3::Icmpv6TooBig::Icmpv6TooBig() [constructor]

  1249     cls.add_constructor([])

  1250     ## icmpv6-header.h: uint32_t ns3::Icmpv6TooBig::Deserialize(ns3::Buffer::Iterator start) [member function]

  1251     cls.add_method('Deserialize',

  1252                    'uint32_t',

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

  1254                    is_virtual=True)

  1255     ## icmpv6-header.h: ns3::TypeId ns3::Icmpv6TooBig::GetInstanceTypeId() const [member function]

  1256     cls.add_method('GetInstanceTypeId',

  1257                    'ns3::TypeId',

  1258                    [],

  1259                    is_const=True, is_virtual=True)

  1260     ## icmpv6-header.h: uint32_t ns3::Icmpv6TooBig::GetMtu() const [member function]

  1261     cls.add_method('GetMtu',

  1262                    'uint32_t',

  1263                    [],

  1264                    is_const=True)

  1265     ## icmpv6-header.h: ns3::Ptr<ns3::Packet> ns3::Icmpv6TooBig::GetPacket() const [member function]

  1266     cls.add_method('GetPacket',

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

  1268                    [],

  1269                    is_const=True)

  1270     ## icmpv6-header.h: uint32_t ns3::Icmpv6TooBig::GetSerializedSize() const [member function]

  1271     cls.add_method('GetSerializedSize',

  1272                    'uint32_t',

  1273                    [],

  1274                    is_const=True, is_virtual=True)

  1275     ## icmpv6-header.h: static ns3::TypeId ns3::Icmpv6TooBig::GetTypeId() [member function]

  1276     cls.add_method('GetTypeId',

  1277                    'ns3::TypeId',

  1278                    [],

  1279                    is_static=True)

  1280     ## icmpv6-header.h: void ns3::Icmpv6TooBig::Print(std::ostream & os) [member function]

  1281     cls.add_method('Print',

  1282                    'void',

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

  1284                    is_virtual=True)

  1285     ## icmpv6-header.h: void ns3::Icmpv6TooBig::Serialize(ns3::Buffer::Iterator start) const [member function]

  1286     cls.add_method('Serialize',

  1287                    'void',

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

  1289                    is_const=True, is_virtual=True)

  1290     ## icmpv6-header.h: void ns3::Icmpv6TooBig::SetMtu(uint32_t mtu) [member function]

  1291     cls.add_method('SetMtu',

  1292                    'void',

  1293                    [param('uint32_t', 'mtu')])

  1294     ## icmpv6-header.h: void ns3::Icmpv6TooBig::SetPacket(ns3::Ptr<ns3::Packet> p) [member function]

  1295     cls.add_method('SetPacket',

  1296                    'void',

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

  1298     return

  1300 def register_Ns3TcpHeader_methods(root_module, cls):

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

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

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

  1304     cls.add_constructor([])

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

  1306     cls.add_method('Deserialize',

  1307                    'uint32_t',

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

  1309                    is_virtual=True)

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

  1311     cls.add_method('EnableChecksums',

  1312                    'void',

  1313                    [])

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

  1315     cls.add_method('GetAckNumber',

  1316                    'SequenceNumber',

  1317                    [],

  1318                    is_const=True)

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

  1320     cls.add_method('GetDestinationPort',

  1321                    'uint16_t',

  1322                    [],

  1323                    is_const=True)

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

  1325     cls.add_method('GetFlags',

  1326                    'uint8_t',

  1327                    [],

  1328                    is_const=True)

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

  1330     cls.add_method('GetInstanceTypeId',

  1331                    'ns3::TypeId',

  1332                    [],

  1333                    is_const=True, is_virtual=True)

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

  1335     cls.add_method('GetLength',

  1336                    'uint8_t',

  1337                    [],

  1338                    is_const=True)

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

  1340     cls.add_method('GetSequenceNumber',

  1341                    'SequenceNumber',

  1342                    [],

  1343                    is_const=True)

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

  1345     cls.add_method('GetSerializedSize',

  1346                    'uint32_t',

  1347                    [],

  1348                    is_const=True, is_virtual=True)

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

  1350     cls.add_method('GetSourcePort',

  1351                    'uint16_t',

  1352                    [],

  1353                    is_const=True)

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

  1355     cls.add_method('GetTypeId',

  1356                    'ns3::TypeId',

  1357                    [],

  1358                    is_static=True)

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

  1360     cls.add_method('GetUrgentPointer',

  1361                    'uint16_t',

  1362                    [],

  1363                    is_const=True)

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

  1365     cls.add_method('GetWindowSize',

  1366                    'uint16_t',

  1367                    [],

  1368                    is_const=True)

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

  1370     cls.add_method('InitializeChecksum',

  1371                    'void',

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

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

  1374     cls.add_method('IsChecksumOk',

  1375                    'bool',

  1376                    [],

  1377                    is_const=True)

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

  1379     cls.add_method('Print',

  1380                    'void',

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

  1382                    is_const=True, is_virtual=True)

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

  1384     cls.add_method('Serialize',

  1385                    'void',

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

  1387                    is_const=True, is_virtual=True)

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

  1389     cls.add_method('SetAckNumber',

  1390                    'void',

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

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

  1393     cls.add_method('SetDestinationPort',

  1394                    'void',

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

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

  1397     cls.add_method('SetFlags',

  1398                    'void',

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

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

  1401     cls.add_method('SetLength',

  1402                    'void',

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

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

  1405     cls.add_method('SetSequenceNumber',

  1406                    'void',

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

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

  1409     cls.add_method('SetSourcePort',

  1410                    'void',

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

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

  1413     cls.add_method('SetUrgentPointer',

  1414                    'void',

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

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

  1417     cls.add_method('SetWindowSize',

  1418                    'void',

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

  1420     return

  1422 def register_Ns3UdpHeader_methods(root_module, cls):

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

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

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

  1426     cls.add_constructor([])

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

  1428     cls.add_method('Deserialize',

  1429                    'uint32_t',

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

  1431                    is_virtual=True)

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

  1433     cls.add_method('EnableChecksums',

  1434                    'void',

  1435                    [])

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

  1437     cls.add_method('GetDestinationPort',

  1438                    'uint16_t',

  1439                    [],

  1440                    is_const=True)

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

  1442     cls.add_method('GetInstanceTypeId',

  1443                    'ns3::TypeId',

  1444                    [],

  1445                    is_const=True, is_virtual=True)

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

  1447     cls.add_method('GetSerializedSize',

  1448                    'uint32_t',

  1449                    [],

  1450                    is_const=True, is_virtual=True)

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

  1452     cls.add_method('GetSourcePort',

  1453                    'uint16_t',

  1454                    [],

  1455                    is_const=True)

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

  1457     cls.add_method('GetTypeId',

  1458                    'ns3::TypeId',

  1459                    [],

  1460                    is_static=True)

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

  1462     cls.add_method('InitializeChecksum',

  1463                    'void',

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

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

  1466     cls.add_method('IsChecksumOk',

  1467                    'bool',

  1468                    [],

  1469                    is_const=True)

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

  1471     cls.add_method('Print',

  1472                    'void',

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

  1474                    is_const=True, is_virtual=True)

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

  1476     cls.add_method('Serialize',

  1477                    'void',

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

  1479                    is_const=True, is_virtual=True)

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

  1481     cls.add_method('SetDestinationPort',

  1482                    'void',

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

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

  1485     cls.add_method('SetSourcePort',

  1486                    'void',

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

  1488     return

  1490 def register_Ns3ArpCache_methods(root_module, cls):

  1491     ## arp-cache.h: ns3::ArpCache::ArpCache() [constructor]

  1492     cls.add_constructor([])

  1493     ## arp-cache.h: ns3::ArpCache::Entry * ns3::ArpCache::Add(ns3::Ipv4Address to) [member function]

  1494     cls.add_method('Add',

  1495                    'ns3::ArpCache::Entry *',

  1496                    [param('ns3::Ipv4Address', 'to')])

  1497     ## arp-cache.h: void ns3::ArpCache::Flush() [member function]

  1498     cls.add_method('Flush',

  1499                    'void',

  1500                    [])

  1501     ## arp-cache.h: ns3::Time ns3::ArpCache::GetAliveTimeout() const [member function]

  1502     cls.add_method('GetAliveTimeout',

  1503                    'ns3::Time',

  1504                    [],

  1505                    is_const=True)

  1506     ## arp-cache.h: ns3::Time ns3::ArpCache::GetDeadTimeout() const [member function]

  1507     cls.add_method('GetDeadTimeout',

  1508                    'ns3::Time',

  1509                    [],

  1510                    is_const=True)

  1511     ## arp-cache.h: ns3::Ptr<ns3::NetDevice> ns3::ArpCache::GetDevice() const [member function]

  1512     cls.add_method('GetDevice',

  1513                    'ns3::Ptr< ns3::NetDevice >',

  1514                    [],

  1515                    is_const=True)

  1516     ## arp-cache.h: ns3::Ptr<ns3::Ipv4Interface> ns3::ArpCache::GetInterface() const [member function]

  1517     cls.add_method('GetInterface',

  1518                    'ns3::Ptr< ns3::Ipv4Interface >',

  1519                    [],

  1520                    is_const=True)

  1521     ## arp-cache.h: static ns3::TypeId ns3::ArpCache::GetTypeId() [member function]

  1522     cls.add_method('GetTypeId',

  1523                    'ns3::TypeId',

  1524                    [],

  1525                    is_static=True)

  1526     ## arp-cache.h: ns3::Time ns3::ArpCache::GetWaitReplyTimeout() const [member function]

  1527     cls.add_method('GetWaitReplyTimeout',

  1528                    'ns3::Time',

  1529                    [],

  1530                    is_const=True)

  1531     ## arp-cache.h: ns3::ArpCache::Entry * ns3::ArpCache::Lookup(ns3::Ipv4Address destination) [member function]

  1532     cls.add_method('Lookup',

  1533                    'ns3::ArpCache::Entry *',

  1534                    [param('ns3::Ipv4Address', 'destination')])

  1535     ## arp-cache.h: void ns3::ArpCache::SetAliveTimeout(ns3::Time aliveTimeout) [member function]

  1536     cls.add_method('SetAliveTimeout',

  1537                    'void',

  1538                    [param('ns3::Time', 'aliveTimeout')])

  1539     ## arp-cache.h: void ns3::ArpCache::SetArpRequestCallback(ns3::Callback<void, ns3::Ptr<ns3::ArpCache const>, ns3::Ipv4Address, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> arpRequestCallback) [member function]

  1540     cls.add_method('SetArpRequestCallback',

  1541                    'void',

  1542                    [param('ns3::Callback< void, ns3::Ptr< ns3::ArpCache const >, ns3::Ipv4Address, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'arpRequestCallback')])

  1543     ## arp-cache.h: void ns3::ArpCache::SetDeadTimeout(ns3::Time deadTimeout) [member function]

  1544     cls.add_method('SetDeadTimeout',

  1545                    'void',

  1546                    [param('ns3::Time', 'deadTimeout')])

  1547     ## arp-cache.h: void ns3::ArpCache::SetDevice(ns3::Ptr<ns3::NetDevice> device, ns3::Ptr<ns3::Ipv4Interface> interface) [member function]

  1548     cls.add_method('SetDevice',

  1549                    'void',

  1550                    [param('ns3::Ptr< ns3::NetDevice >', 'device'), param('ns3::Ptr< ns3::Ipv4Interface >', 'interface')])

  1551     ## arp-cache.h: void ns3::ArpCache::SetWaitReplyTimeout(ns3::Time waitReplyTimeout) [member function]

  1552     cls.add_method('SetWaitReplyTimeout',

  1553                    'void',

  1554                    [param('ns3::Time', 'waitReplyTimeout')])

  1555     ## arp-cache.h: void ns3::ArpCache::StartWaitReplyTimer() [member function]

  1556     cls.add_method('StartWaitReplyTimer',

  1557                    'void',

  1558                    [])

  1559     ## arp-cache.h: void ns3::ArpCache::DoDispose() [member function]

  1560     cls.add_method('DoDispose',

  1561                    'void',

  1562                    [],

  1563                    visibility='private', is_virtual=True)

  1564     return

  1566 def register_Ns3ArpCacheEntry_methods(root_module, cls):

  1567     ## arp-cache.h: ns3::ArpCache::Entry::Entry(ns3::ArpCache::Entry const & arg0) [copy constructor]

  1568     cls.add_constructor([param('ns3::ArpCache::Entry const &', 'arg0')])

  1569     ## arp-cache.h: ns3::ArpCache::Entry::Entry(ns3::ArpCache * arp) [constructor]

  1570     cls.add_constructor([param('ns3::ArpCache *', 'arp')])

  1571     ## arp-cache.h: void ns3::ArpCache::Entry::ClearRetries() [member function]

  1572     cls.add_method('ClearRetries',

  1573                    'void',

  1574                    [])

  1575     ## arp-cache.h: ns3::Ptr<ns3::Packet> ns3::ArpCache::Entry::DequeuePending() [member function]

  1576     cls.add_method('DequeuePending',

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

  1578                    [])

  1579     ## arp-cache.h: ns3::Ipv4Address ns3::ArpCache::Entry::GetIpv4Address() const [member function]

  1580     cls.add_method('GetIpv4Address',

  1581                    'ns3::Ipv4Address',

  1582                    [],

  1583                    is_const=True)

  1584     ## arp-cache.h: ns3::Address ns3::ArpCache::Entry::GetMacAddress() const [member function]

  1585     cls.add_method('GetMacAddress',

  1586                    'ns3::Address',

  1587                    [],

  1588                    is_const=True)

  1589     ## arp-cache.h: uint32_t ns3::ArpCache::Entry::GetRetries() const [member function]

  1590     cls.add_method('GetRetries',

  1591                    'uint32_t',

  1592                    [],

  1593                    is_const=True)

  1594     ## arp-cache.h: void ns3::ArpCache::Entry::IncrementRetries() [member function]

  1595     cls.add_method('IncrementRetries',

  1596                    'void',

  1597                    [])

  1598     ## arp-cache.h: bool ns3::ArpCache::Entry::IsAlive() [member function]

  1599     cls.add_method('IsAlive',

  1600                    'bool',

  1601                    [])

  1602     ## arp-cache.h: bool ns3::ArpCache::Entry::IsDead() [member function]

  1603     cls.add_method('IsDead',

  1604                    'bool',

  1605                    [])

  1606     ## arp-cache.h: bool ns3::ArpCache::Entry::IsExpired() const [member function]

  1607     cls.add_method('IsExpired',

  1608                    'bool',

  1609                    [],

  1610                    is_const=True)

  1611     ## arp-cache.h: bool ns3::ArpCache::Entry::IsWaitReply() [member function]

  1612     cls.add_method('IsWaitReply',

  1613                    'bool',

  1614                    [])

  1615     ## arp-cache.h: void ns3::ArpCache::Entry::MarkAlive(ns3::Address macAddress) [member function]

  1616     cls.add_method('MarkAlive',

  1617                    'void',

  1618                    [param('ns3::Address', 'macAddress')])

  1619     ## arp-cache.h: void ns3::ArpCache::Entry::MarkDead() [member function]

  1620     cls.add_method('MarkDead',

  1621                    'void',

  1622                    [])

  1623     ## arp-cache.h: void ns3::ArpCache::Entry::MarkWaitReply(ns3::Ptr<ns3::Packet> waiting) [member function]

  1624     cls.add_method('MarkWaitReply',

  1625                    'void',

  1626                    [param('ns3::Ptr< ns3::Packet >', 'waiting')])

  1627     ## arp-cache.h: void ns3::ArpCache::Entry::SetIpv4Address(ns3::Ipv4Address destination) [member function]

  1628     cls.add_method('SetIpv4Address',

  1629                    'void',

  1630                    [param('ns3::Ipv4Address', 'destination')])

  1631     ## arp-cache.h: bool ns3::ArpCache::Entry::UpdateWaitReply(ns3::Ptr<ns3::Packet> waiting) [member function]

  1632     cls.add_method('UpdateWaitReply',

  1633                    'bool',

  1634                    [param('ns3::Ptr< ns3::Packet >', 'waiting')])

  1635     return

  1637 def register_Ns3ArpL3Protocol_methods(root_module, cls):

  1638     ## arp-l3-protocol.h: ns3::ArpL3Protocol::PROT_NUMBER [variable]

  1639     cls.add_static_attribute('PROT_NUMBER', 'uint16_t const', is_const=True)

  1640     ## arp-l3-protocol.h: static ns3::TypeId ns3::ArpL3Protocol::GetTypeId() [member function]

  1641     cls.add_method('GetTypeId',

  1642                    'ns3::TypeId',

  1643                    [],

  1644                    is_static=True)

  1645     ## arp-l3-protocol.h: ns3::ArpL3Protocol::ArpL3Protocol() [constructor]

  1646     cls.add_constructor([])

  1647     ## arp-l3-protocol.h: void ns3::ArpL3Protocol::SetNode(ns3::Ptr<ns3::Node> node) [member function]

  1648     cls.add_method('SetNode',

  1649                    'void',

  1650                    [param('ns3::Ptr< ns3::Node >', 'node')])

  1651     ## arp-l3-protocol.h: ns3::Ptr<ns3::ArpCache> ns3::ArpL3Protocol::CreateCache(ns3::Ptr<ns3::NetDevice> device, ns3::Ptr<ns3::Ipv4Interface> interface) [member function]

  1652     cls.add_method('CreateCache',

  1653                    'ns3::Ptr< ns3::ArpCache >',

  1654                    [param('ns3::Ptr< ns3::NetDevice >', 'device'), param('ns3::Ptr< ns3::Ipv4Interface >', 'interface')])

  1655     ## arp-l3-protocol.h: void ns3::ArpL3Protocol::Receive(ns3::Ptr<ns3::NetDevice> device, ns3::Ptr<ns3::Packet const> p, uint16_t protocol, ns3::Address const & from, ns3::Address const & to, ns3::NetDevice::PacketType packetType) [member function]

  1656     cls.add_method('Receive',

  1657                    'void',

  1658                    [param('ns3::Ptr< ns3::NetDevice >', 'device'), param('ns3::Ptr< ns3::Packet const >', 'p'), param('uint16_t', 'protocol'), param('ns3::Address const &', 'from'), param('ns3::Address const &', 'to'), param('ns3::NetDevice::PacketType', 'packetType')])

  1659     ## arp-l3-protocol.h: bool ns3::ArpL3Protocol::Lookup(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Address destination, ns3::Ptr<ns3::NetDevice> device, ns3::Ptr<ns3::ArpCache> cache, ns3::Address * hardwareDestination) [member function]

  1660     cls.add_method('Lookup',

  1661                    'bool',

  1662                    [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Address', 'destination'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('ns3::Ptr< ns3::ArpCache >', 'cache'), param('ns3::Address *', 'hardwareDestination')])

  1663     ## arp-l3-protocol.h: void ns3::ArpL3Protocol::DoDispose() [member function]

  1664     cls.add_method('DoDispose',

  1665                    'void',

  1666                    [],

  1667                    visibility='protected', is_virtual=True)

  1668     ## arp-l3-protocol.h: void ns3::ArpL3Protocol::NotifyNewAggregate() [member function]

  1669     cls.add_method('NotifyNewAggregate',

  1670                    'void',

  1671                    [],

  1672                    visibility='protected', is_virtual=True)

  1673     return

  1675 def register_Ns3Icmpv6DestinationUnreachable_methods(root_module, cls):

  1676     ## icmpv6-header.h: ns3::Icmpv6DestinationUnreachable::Icmpv6DestinationUnreachable(ns3::Icmpv6DestinationUnreachable const & arg0) [copy constructor]

  1677     cls.add_constructor([param('ns3::Icmpv6DestinationUnreachable const &', 'arg0')])

  1678     ## icmpv6-header.h: ns3::Icmpv6DestinationUnreachable::Icmpv6DestinationUnreachable() [constructor]

  1679     cls.add_constructor([])

  1680     ## icmpv6-header.h: uint32_t ns3::Icmpv6DestinationUnreachable::Deserialize(ns3::Buffer::Iterator start) [member function]

  1681     cls.add_method('Deserialize',

  1682                    'uint32_t',

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

  1684                    is_virtual=True)

  1685     ## icmpv6-header.h: ns3::TypeId ns3::Icmpv6DestinationUnreachable::GetInstanceTypeId() const [member function]

  1686     cls.add_method('GetInstanceTypeId',

  1687                    'ns3::TypeId',

  1688                    [],

  1689                    is_const=True, is_virtual=True)

  1690     ## icmpv6-header.h: ns3::Ptr<ns3::Packet> ns3::Icmpv6DestinationUnreachable::GetPacket() const [member function]

  1691     cls.add_method('GetPacket',

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

  1693                    [],

  1694                    is_const=True)

  1695     ## icmpv6-header.h: uint32_t ns3::Icmpv6DestinationUnreachable::GetSerializedSize() const [member function]

  1696     cls.add_method('GetSerializedSize',

  1697                    'uint32_t',

  1698                    [],

  1699                    is_const=True, is_virtual=True)

  1700     ## icmpv6-header.h: static ns3::TypeId ns3::Icmpv6DestinationUnreachable::GetTypeId() [member function]

  1701     cls.add_method('GetTypeId',

  1702                    'ns3::TypeId',

  1703                    [],

  1704                    is_static=True)

  1705     ## icmpv6-header.h: void ns3::Icmpv6DestinationUnreachable::Print(std::ostream & os) [member function]

  1706     cls.add_method('Print',

  1707                    'void',

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

  1709                    is_virtual=True)

  1710     ## icmpv6-header.h: void ns3::Icmpv6DestinationUnreachable::Serialize(ns3::Buffer::Iterator start) const [member function]

  1711     cls.add_method('Serialize',

  1712                    'void',

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

  1714                    is_const=True, is_virtual=True)

  1715     ## icmpv6-header.h: void ns3::Icmpv6DestinationUnreachable::SetPacket(ns3::Ptr<ns3::Packet> p) [member function]

  1716     cls.add_method('SetPacket',

  1717                    'void',

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

  1719     return

  1721 def register_Ns3Icmpv6Echo_methods(root_module, cls):

  1722     ## icmpv6-header.h: ns3::Icmpv6Echo::Icmpv6Echo(ns3::Icmpv6Echo const & arg0) [copy constructor]

  1723     cls.add_constructor([param('ns3::Icmpv6Echo const &', 'arg0')])

  1724     ## icmpv6-header.h: ns3::Icmpv6Echo::Icmpv6Echo() [constructor]

  1725     cls.add_constructor([])

  1726     ## icmpv6-header.h: ns3::Icmpv6Echo::Icmpv6Echo(bool request) [constructor]

  1727     cls.add_constructor([param('bool', 'request')])

  1728     ## icmpv6-header.h: uint32_t ns3::Icmpv6Echo::Deserialize(ns3::Buffer::Iterator start) [member function]

  1729     cls.add_method('Deserialize',

  1730                    'uint32_t',

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

  1732                    is_virtual=True)

  1733     ## icmpv6-header.h: uint16_t ns3::Icmpv6Echo::GetId() const [member function]

  1734     cls.add_method('GetId',

  1735                    'uint16_t',

  1736                    [],

  1737                    is_const=True)

  1738     ## icmpv6-header.h: ns3::TypeId ns3::Icmpv6Echo::GetInstanceTypeId() const [member function]

  1739     cls.add_method('GetInstanceTypeId',

  1740                    'ns3::TypeId',

  1741                    [],

  1742                    is_const=True, is_virtual=True)

  1743     ## icmpv6-header.h: uint16_t ns3::Icmpv6Echo::GetSeq() const [member function]

  1744     cls.add_method('GetSeq',

  1745                    'uint16_t',

  1746                    [],

  1747                    is_const=True)

  1748     ## icmpv6-header.h: uint32_t ns3::Icmpv6Echo::GetSerializedSize() const [member function]

  1749     cls.add_method('GetSerializedSize',

  1750                    'uint32_t',

  1751                    [],

  1752                    is_const=True, is_virtual=True)

  1753     ## icmpv6-header.h: static ns3::TypeId ns3::Icmpv6Echo::GetTypeId() [member function]

  1754     cls.add_method('GetTypeId',

  1755                    'ns3::TypeId',

  1756                    [],

  1757                    is_static=True)

  1758     ## icmpv6-header.h: void ns3::Icmpv6Echo::Print(std::ostream & os) const [member function]

  1759     cls.add_method('Print',

  1760                    'void',

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

  1762                    is_const=True, is_virtual=True)

  1763     ## icmpv6-header.h: void ns3::Icmpv6Echo::Serialize(ns3::Buffer::Iterator start) const [member function]

  1764     cls.add_method('Serialize',

  1765                    'void',

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

  1767                    is_const=True, is_virtual=True)

  1768     ## icmpv6-header.h: void ns3::Icmpv6Echo::SetId(uint16_t id) [member function]

  1769     cls.add_method('SetId',

  1770                    'void',

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

  1772     ## icmpv6-header.h: void ns3::Icmpv6Echo::SetSeq(uint16_t seq) [member function]

  1773     cls.add_method('SetSeq',

  1774                    'void',

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

  1776     return

  1778 def register_Ns3Ipv4L3Protocol_methods(root_module, cls):

  1779     ## ipv4-l3-protocol.h: ns3::Ipv4L3Protocol::PROT_NUMBER [variable]

  1780     cls.add_static_attribute('PROT_NUMBER', 'uint16_t const', is_const=True)

  1781     ## ipv4-l3-protocol.h: static ns3::TypeId ns3::Ipv4L3Protocol::GetTypeId() [member function]

  1782     cls.add_method('GetTypeId',

  1783                    'ns3::TypeId',

  1784                    [],

  1785                    is_static=True)

  1786     ## ipv4-l3-protocol.h: ns3::Ipv4L3Protocol::Ipv4L3Protocol() [constructor]

  1787     cls.add_constructor([])

  1788     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::SetNode(ns3::Ptr<ns3::Node> node) [member function]

  1789     cls.add_method('SetNode',

  1790                    'void',

  1791                    [param('ns3::Ptr< ns3::Node >', 'node')])

  1792     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::SetRoutingProtocol(ns3::Ptr<ns3::Ipv4RoutingProtocol> routingProtocol) [member function]

  1793     cls.add_method('SetRoutingProtocol',

  1794                    'void',

  1795                    [param('ns3::Ptr< ns3::Ipv4RoutingProtocol >', 'routingProtocol')],

  1796                    is_virtual=True)

  1797     ## ipv4-l3-protocol.h: ns3::Ptr<ns3::Ipv4RoutingProtocol> ns3::Ipv4L3Protocol::GetRoutingProtocol() const [member function]

  1798     cls.add_method('GetRoutingProtocol',

  1799                    'ns3::Ptr< ns3::Ipv4RoutingProtocol >',

  1800                    [],

  1801                    is_const=True, is_virtual=True)

  1802     ## ipv4-l3-protocol.h: ns3::Ptr<ns3::Socket> ns3::Ipv4L3Protocol::CreateRawSocket() [member function]

  1803     cls.add_method('CreateRawSocket',

  1804                    'ns3::Ptr< ns3::Socket >',

  1805                    [])

  1806     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::DeleteRawSocket(ns3::Ptr<ns3::Socket> socket) [member function]

  1807     cls.add_method('DeleteRawSocket',

  1808                    'void',

  1809                    [param('ns3::Ptr< ns3::Socket >', 'socket')])

  1810     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::Insert(ns3::Ptr<ns3::Ipv4L4Protocol> protocol) [member function]

  1811     cls.add_method('Insert',

  1812                    'void',

  1813                    [param('ns3::Ptr< ns3::Ipv4L4Protocol >', 'protocol')])

  1814     ## ipv4-l3-protocol.h: ns3::Ptr<ns3::Ipv4L4Protocol> ns3::Ipv4L3Protocol::GetProtocol(int protocolNumber) const [member function]

  1815     cls.add_method('GetProtocol',

  1816                    'ns3::Ptr< ns3::Ipv4L4Protocol >',

  1817                    [param('int', 'protocolNumber')],

  1818                    is_const=True)

  1819     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::Remove(ns3::Ptr<ns3::Ipv4L4Protocol> protocol) [member function]

  1820     cls.add_method('Remove',

  1821                    'void',

  1822                    [param('ns3::Ptr< ns3::Ipv4L4Protocol >', 'protocol')])

  1823     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::SetDefaultTtl(uint8_t ttl) [member function]

  1824     cls.add_method('SetDefaultTtl',

  1825                    'void',

  1826                    [param('uint8_t', 'ttl')])

  1827     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::Receive(ns3::Ptr<ns3::NetDevice> device, ns3::Ptr<ns3::Packet const> p, uint16_t protocol, ns3::Address const & from, ns3::Address const & to, ns3::NetDevice::PacketType packetType) [member function]

  1828     cls.add_method('Receive',

  1829                    'void',

  1830                    [param('ns3::Ptr< ns3::NetDevice >', 'device'), param('ns3::Ptr< ns3::Packet const >', 'p'), param('uint16_t', 'protocol'), param('ns3::Address const &', 'from'), param('ns3::Address const &', 'to'), param('ns3::NetDevice::PacketType', 'packetType')])

  1831     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::Send(ns3::Ptr<ns3::Packet> packet, ns3::Ipv4Address source, ns3::Ipv4Address destination, uint8_t protocol, ns3::Ptr<ns3::Ipv4Route> route) [member function]

  1832     cls.add_method('Send',

  1833                    'void',

  1834                    [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Ipv4Address', 'source'), param('ns3::Ipv4Address', 'destination'), param('uint8_t', 'protocol'), param('ns3::Ptr< ns3::Ipv4Route >', 'route')])

  1835     ## ipv4-l3-protocol.h: uint32_t ns3::Ipv4L3Protocol::AddInterface(ns3::Ptr<ns3::NetDevice> device) [member function]

  1836     cls.add_method('AddInterface',

  1837                    'uint32_t',

  1838                    [param('ns3::Ptr< ns3::NetDevice >', 'device')],

  1839                    is_virtual=True)

  1840     ## ipv4-l3-protocol.h: ns3::Ptr<ns3::Ipv4Interface> ns3::Ipv4L3Protocol::GetInterface(uint32_t i) const [member function]

  1841     cls.add_method('GetInterface',

  1842                    'ns3::Ptr< ns3::Ipv4Interface >',

  1843                    [param('uint32_t', 'i')],

  1844                    is_const=True)

  1845     ## ipv4-l3-protocol.h: uint32_t ns3::Ipv4L3Protocol::GetNInterfaces() const [member function]

  1846     cls.add_method('GetNInterfaces',

  1847                    'uint32_t',

  1848                    [],

  1849                    is_const=True, is_virtual=True)

  1850     ## ipv4-l3-protocol.h: int32_t ns3::Ipv4L3Protocol::GetInterfaceForAddress(ns3::Ipv4Address addr) const [member function]

  1851     cls.add_method('GetInterfaceForAddress',

  1852                    'int32_t',

  1853                    [param('ns3::Ipv4Address', 'addr')],

  1854                    is_const=True, is_virtual=True)

  1855     ## ipv4-l3-protocol.h: int32_t ns3::Ipv4L3Protocol::GetInterfaceForPrefix(ns3::Ipv4Address addr, ns3::Ipv4Mask mask) const [member function]

  1856     cls.add_method('GetInterfaceForPrefix',

  1857                    'int32_t',

  1858                    [param('ns3::Ipv4Address', 'addr'), param('ns3::Ipv4Mask', 'mask')],

  1859                    is_const=True, is_virtual=True)

  1860     ## ipv4-l3-protocol.h: int32_t ns3::Ipv4L3Protocol::GetInterfaceForDevice(ns3::Ptr<const ns3::NetDevice> device) const [member function]

  1861     cls.add_method('GetInterfaceForDevice',

  1862                    'int32_t',

  1863                    [param('ns3::Ptr< ns3::NetDevice const >', 'device')],

  1864                    is_const=True, is_virtual=True)

  1865     ## ipv4-l3-protocol.h: bool ns3::Ipv4L3Protocol::AddAddress(uint32_t i, ns3::Ipv4InterfaceAddress address) [member function]

  1866     cls.add_method('AddAddress',

  1867                    'bool',

  1868                    [param('uint32_t', 'i'), param('ns3::Ipv4InterfaceAddress', 'address')],

  1869                    is_virtual=True)

  1870     ## ipv4-l3-protocol.h: ns3::Ipv4InterfaceAddress ns3::Ipv4L3Protocol::GetAddress(uint32_t interfaceIndex, uint32_t addressIndex) const [member function]

  1871     cls.add_method('GetAddress',

  1872                    'ns3::Ipv4InterfaceAddress',

  1873                    [param('uint32_t', 'interfaceIndex'), param('uint32_t', 'addressIndex')],

  1874                    is_const=True, is_virtual=True)

  1875     ## ipv4-l3-protocol.h: uint32_t ns3::Ipv4L3Protocol::GetNAddresses(uint32_t interface) const [member function]

  1876     cls.add_method('GetNAddresses',

  1877                    'uint32_t',

  1878                    [param('uint32_t', 'interface')],

  1879                    is_const=True, is_virtual=True)

  1880     ## ipv4-l3-protocol.h: bool ns3::Ipv4L3Protocol::RemoveAddress(uint32_t interfaceIndex, uint32_t addressIndex) [member function]

  1881     cls.add_method('RemoveAddress',

  1882                    'bool',

  1883                    [param('uint32_t', 'interfaceIndex'), param('uint32_t', 'addressIndex')],

  1884                    is_virtual=True)

  1885     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::SetMetric(uint32_t i, uint16_t metric) [member function]

  1886     cls.add_method('SetMetric',

  1887                    'void',

  1888                    [param('uint32_t', 'i'), param('uint16_t', 'metric')],

  1889                    is_virtual=True)

  1890     ## ipv4-l3-protocol.h: uint16_t ns3::Ipv4L3Protocol::GetMetric(uint32_t i) const [member function]

  1891     cls.add_method('GetMetric',

  1892                    'uint16_t',

  1893                    [param('uint32_t', 'i')],

  1894                    is_const=True, is_virtual=True)

  1895     ## ipv4-l3-protocol.h: uint16_t ns3::Ipv4L3Protocol::GetMtu(uint32_t i) const [member function]

  1896     cls.add_method('GetMtu',

  1897                    'uint16_t',

  1898                    [param('uint32_t', 'i')],

  1899                    is_const=True, is_virtual=True)

  1900     ## ipv4-l3-protocol.h: bool ns3::Ipv4L3Protocol::IsUp(uint32_t i) const [member function]

  1901     cls.add_method('IsUp',

  1902                    'bool',

  1903                    [param('uint32_t', 'i')],

  1904                    is_const=True, is_virtual=True)

  1905     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::SetUp(uint32_t i) [member function]

  1906     cls.add_method('SetUp',

  1907                    'void',

  1908                    [param('uint32_t', 'i')],

  1909                    is_virtual=True)

  1910     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::SetDown(uint32_t i) [member function]

  1911     cls.add_method('SetDown',

  1912                    'void',

  1913                    [param('uint32_t', 'i')],

  1914                    is_virtual=True)

  1915     ## ipv4-l3-protocol.h: bool ns3::Ipv4L3Protocol::IsForwarding(uint32_t i) const [member function]

  1916     cls.add_method('IsForwarding',

  1917                    'bool',

  1918                    [param('uint32_t', 'i')],

  1919                    is_const=True, is_virtual=True)

  1920     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::SetForwarding(uint32_t i, bool val) [member function]

  1921     cls.add_method('SetForwarding',

  1922                    'void',

  1923                    [param('uint32_t', 'i'), param('bool', 'val')],

  1924                    is_virtual=True)

  1925     ## ipv4-l3-protocol.h: ns3::Ptr<ns3::NetDevice> ns3::Ipv4L3Protocol::GetNetDevice(uint32_t i) [member function]

  1926     cls.add_method('GetNetDevice',

  1927                    'ns3::Ptr< ns3::NetDevice >',

  1928                    [param('uint32_t', 'i')],

  1929                    is_virtual=True)

  1930     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::DoDispose() [member function]

  1931     cls.add_method('DoDispose',

  1932                    'void',

  1933                    [],

  1934                    visibility='protected', is_virtual=True)

  1935     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::NotifyNewAggregate() [member function]

  1936     cls.add_method('NotifyNewAggregate',

  1937                    'void',

  1938                    [],

  1939                    visibility='protected', is_virtual=True)

  1940     ## ipv4-l3-protocol.h: void ns3::Ipv4L3Protocol::SetIpForward(bool forward) [member function]

  1941     cls.add_method('SetIpForward',

  1942                    'void',

  1943                    [param('bool', 'forward')],

  1944                    visibility='private', is_virtual=True)

  1945     ## ipv4-l3-protocol.h: bool ns3::Ipv4L3Protocol::GetIpForward() const [member function]

  1946     cls.add_method('GetIpForward',

  1947                    'bool',

  1948                    [],

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

  1950     return

  1952 def register_Ns3Ipv4L4Protocol_methods(root_module, cls):

  1953     ## ipv4-l4-protocol.h: ns3::Ipv4L4Protocol::Ipv4L4Protocol() [constructor]

  1954     cls.add_constructor([])

  1955     ## ipv4-l4-protocol.h: ns3::Ipv4L4Protocol::Ipv4L4Protocol(ns3::Ipv4L4Protocol const & arg0) [copy constructor]

  1956     cls.add_constructor([param('ns3::Ipv4L4Protocol const &', 'arg0')])

  1957     ## ipv4-l4-protocol.h: int ns3::Ipv4L4Protocol::GetProtocolNumber() const [member function]

  1958     cls.add_method('GetProtocolNumber',

  1959                    'int',

  1960                    [],

  1961                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1962     ## ipv4-l4-protocol.h: static ns3::TypeId ns3::Ipv4L4Protocol::GetTypeId() [member function]

  1963     cls.add_method('GetTypeId',

  1964                    'ns3::TypeId',

  1965                    [],

  1966                    is_static=True)

  1967     ## ipv4-l4-protocol.h: ns3::Ipv4L4Protocol::RxStatus ns3::Ipv4L4Protocol::Receive(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Address const & source, ns3::Ipv4Address const & destination, ns3::Ptr<ns3::Ipv4Interface> incomingInterface) [member function]

  1968     cls.add_method('Receive',

  1969                    'ns3::Ipv4L4Protocol::RxStatus',

  1970                    [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Address const &', 'source'), param('ns3::Ipv4Address const &', 'destination'), param('ns3::Ptr< ns3::Ipv4Interface >', 'incomingInterface')],

  1971                    is_pure_virtual=True, is_virtual=True)

  1972     ## ipv4-l4-protocol.h: void ns3::Ipv4L4Protocol::ReceiveIcmp(ns3::Ipv4Address icmpSource, uint8_t icmpTtl, uint8_t icmpType, uint8_t icmpCode, uint32_t icmpInfo, ns3::Ipv4Address payloadSource, ns3::Ipv4Address payloadDestination, uint8_t const * payload) [member function]

  1973     cls.add_method('ReceiveIcmp',

  1974                    'void',

  1975                    [param('ns3::Ipv4Address', 'icmpSource'), param('uint8_t', 'icmpTtl'), param('uint8_t', 'icmpType'), param('uint8_t', 'icmpCode'), param('uint32_t', 'icmpInfo'), param('ns3::Ipv4Address', 'payloadSource'), param('ns3::Ipv4Address', 'payloadDestination'), param('uint8_t const *', 'payload')],

  1976                    is_virtual=True)

  1977     return

  1979 def register_Ns3TcpL4Protocol_methods(root_module, cls):

  1980     ## tcp-l4-protocol.h: ns3::TcpL4Protocol::PROT_NUMBER [variable]

  1981     cls.add_static_attribute('PROT_NUMBER', 'uint8_t const', is_const=True)

  1982     ## tcp-l4-protocol.h: static ns3::TypeId ns3::TcpL4Protocol::GetTypeId() [member function]

  1983     cls.add_method('GetTypeId',

  1984                    'ns3::TypeId',

  1985                    [],

  1986                    is_static=True)

  1987     ## tcp-l4-protocol.h: ns3::TcpL4Protocol::TcpL4Protocol() [constructor]

  1988     cls.add_constructor([])

  1989     ## tcp-l4-protocol.h: void ns3::TcpL4Protocol::SetNode(ns3::Ptr<ns3::Node> node) [member function]

  1990     cls.add_method('SetNode',

  1991                    'void',

  1992                    [param('ns3::Ptr< ns3::Node >', 'node')])

  1993     ## tcp-l4-protocol.h: int ns3::TcpL4Protocol::GetProtocolNumber() const [member function]

  1994     cls.add_method('GetProtocolNumber',

  1995                    'int',

  1996                    [],

  1997                    is_const=True, is_virtual=True)

  1998     ## tcp-l4-protocol.h: ns3::Ptr<ns3::Socket> ns3::TcpL4Protocol::CreateSocket() [member function]

  1999     cls.add_method('CreateSocket',

  2000                    'ns3::Ptr< ns3::Socket >',

  2001                    [])

  2002     ## tcp-l4-protocol.h: ns3::Ipv4EndPoint * ns3::TcpL4Protocol::Allocate() [member function]

  2003     cls.add_method('Allocate',

  2004                    'ns3::Ipv4EndPoint *',

  2005                    [])

  2006     ## tcp-l4-protocol.h: ns3::Ipv4EndPoint * ns3::TcpL4Protocol::Allocate(ns3::Ipv4Address address) [member function]

  2007     cls.add_method('Allocate',

  2008                    'ns3::Ipv4EndPoint *',

  2009                    [param('ns3::Ipv4Address', 'address')])

  2010     ## tcp-l4-protocol.h: ns3::Ipv4EndPoint * ns3::TcpL4Protocol::Allocate(uint16_t port) [member function]

  2011     cls.add_method('Allocate',

  2012                    'ns3::Ipv4EndPoint *',

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

  2014     ## tcp-l4-protocol.h: ns3::Ipv4EndPoint * ns3::TcpL4Protocol::Allocate(ns3::Ipv4Address address, uint16_t port) [member function]

  2015     cls.add_method('Allocate',

  2016                    'ns3::Ipv4EndPoint *',

  2017                    [param('ns3::Ipv4Address', 'address'), param('uint16_t', 'port')])

  2018     ## tcp-l4-protocol.h: ns3::Ipv4EndPoint * ns3::TcpL4Protocol::Allocate(ns3::Ipv4Address localAddress, uint16_t localPort, ns3::Ipv4Address peerAddress, uint16_t peerPort) [member function]

  2019     cls.add_method('Allocate',

  2020                    'ns3::Ipv4EndPoint *',

  2021                    [param('ns3::Ipv4Address', 'localAddress'), param('uint16_t', 'localPort'), param('ns3::Ipv4Address', 'peerAddress'), param('uint16_t', 'peerPort')])

  2022     ## tcp-l4-protocol.h: void ns3::TcpL4Protocol::DeAllocate(ns3::Ipv4EndPoint * endPoint) [member function]

  2023     cls.add_method('DeAllocate',

  2024                    'void',

  2025                    [param('ns3::Ipv4EndPoint *', 'endPoint')])

  2026     ## tcp-l4-protocol.h: void ns3::TcpL4Protocol::Send(ns3::Ptr<ns3::Packet> packet, ns3::Ipv4Address saddr, ns3::Ipv4Address daddr, uint16_t sport, uint16_t dport) [member function]

  2027     cls.add_method('Send',

  2028                    'void',

  2029                    [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Ipv4Address', 'saddr'), param('ns3::Ipv4Address', 'daddr'), param('uint16_t', 'sport'), param('uint16_t', 'dport')])

  2030     ## tcp-l4-protocol.h: ns3::Ipv4L4Protocol::RxStatus ns3::TcpL4Protocol::Receive(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Address const & source, ns3::Ipv4Address const & destination, ns3::Ptr<ns3::Ipv4Interface> incomingInterface) [member function]

  2031     cls.add_method('Receive',

  2032                    'ns3::Ipv4L4Protocol::RxStatus',

  2033                    [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Address const &', 'source'), param('ns3::Ipv4Address const &', 'destination'), param('ns3::Ptr< ns3::Ipv4Interface >', 'incomingInterface')],

  2034                    is_virtual=True)

  2035     ## tcp-l4-protocol.h: void ns3::TcpL4Protocol::DoDispose() [member function]

  2036     cls.add_method('DoDispose',

  2037                    'void',

  2038                    [],

  2039                    visibility='protected', is_virtual=True)

  2040     ## tcp-l4-protocol.h: void ns3::TcpL4Protocol::NotifyNewAggregate() [member function]

  2041     cls.add_method('NotifyNewAggregate',

  2042                    'void',

  2043                    [],

  2044                    visibility='protected', is_virtual=True)

  2045     return

  2047 def register_Ns3UdpL4Protocol_methods(root_module, cls):

  2048     ## udp-l4-protocol.h: ns3::UdpL4Protocol::UdpL4Protocol(ns3::UdpL4Protocol const & arg0) [copy constructor]

  2049     cls.add_constructor([param('ns3::UdpL4Protocol const &', 'arg0')])

  2050     ## udp-l4-protocol.h: ns3::UdpL4Protocol::UdpL4Protocol() [constructor]

  2051     cls.add_constructor([])

  2052     ## udp-l4-protocol.h: ns3::Ipv4EndPoint * ns3::UdpL4Protocol::Allocate() [member function]

  2053     cls.add_method('Allocate',

  2054                    'ns3::Ipv4EndPoint *',

  2055                    [])

  2056     ## udp-l4-protocol.h: ns3::Ipv4EndPoint * ns3::UdpL4Protocol::Allocate(ns3::Ipv4Address address) [member function]

  2057     cls.add_method('Allocate',

  2058                    'ns3::Ipv4EndPoint *',

  2059                    [param('ns3::Ipv4Address', 'address')])

  2060     ## udp-l4-protocol.h: ns3::Ipv4EndPoint * ns3::UdpL4Protocol::Allocate(uint16_t port) [member function]

  2061     cls.add_method('Allocate',

  2062                    'ns3::Ipv4EndPoint *',

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

  2064     ## udp-l4-protocol.h: ns3::Ipv4EndPoint * ns3::UdpL4Protocol::Allocate(ns3::Ipv4Address address, uint16_t port) [member function]

  2065     cls.add_method('Allocate',

  2066                    'ns3::Ipv4EndPoint *',

  2067                    [param('ns3::Ipv4Address', 'address'), param('uint16_t', 'port')])

  2068     ## udp-l4-protocol.h: ns3::Ipv4EndPoint * ns3::UdpL4Protocol::Allocate(ns3::Ipv4Address localAddress, uint16_t localPort, ns3::Ipv4Address peerAddress, uint16_t peerPort) [member function]

  2069     cls.add_method('Allocate',

  2070                    'ns3::Ipv4EndPoint *',

  2071                    [param('ns3::Ipv4Address', 'localAddress'), param('uint16_t', 'localPort'), param('ns3::Ipv4Address', 'peerAddress'), param('uint16_t', 'peerPort')])

  2072     ## udp-l4-protocol.h: ns3::Ptr<ns3::Socket> ns3::UdpL4Protocol::CreateSocket() [member function]

  2073     cls.add_method('CreateSocket',

  2074                    'ns3::Ptr< ns3::Socket >',

  2075                    [])

  2076     ## udp-l4-protocol.h: void ns3::UdpL4Protocol::DeAllocate(ns3::Ipv4EndPoint * endPoint) [member function]

  2077     cls.add_method('DeAllocate',

  2078                    'void',

  2079                    [param('ns3::Ipv4EndPoint *', 'endPoint')])

  2080     ## udp-l4-protocol.h: int ns3::UdpL4Protocol::GetProtocolNumber() const [member function]

  2081     cls.add_method('GetProtocolNumber',

  2082                    'int',

  2083                    [],

  2084                    is_const=True, is_virtual=True)

  2085     ## udp-l4-protocol.h: static ns3::TypeId ns3::UdpL4Protocol::GetTypeId() [member function]

  2086     cls.add_method('GetTypeId',

  2087                    'ns3::TypeId',

  2088                    [],

  2089                    is_static=True)

  2090     ## udp-l4-protocol.h: ns3::Ipv4L4Protocol::RxStatus ns3::UdpL4Protocol::Receive(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Address const & source, ns3::Ipv4Address const & destination, ns3::Ptr<ns3::Ipv4Interface> interface) [member function]

  2091     cls.add_method('Receive',

  2092                    'ns3::Ipv4L4Protocol::RxStatus',

  2093                    [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Address const &', 'source'), param('ns3::Ipv4Address const &', 'destination'), param('ns3::Ptr< ns3::Ipv4Interface >', 'interface')],

  2094                    is_virtual=True)

  2095     ## udp-l4-protocol.h: void ns3::UdpL4Protocol::ReceiveIcmp(ns3::Ipv4Address icmpSource, uint8_t icmpTtl, uint8_t icmpType, uint8_t icmpCode, uint32_t icmpInfo, ns3::Ipv4Address payloadSource, ns3::Ipv4Address payloadDestination, uint8_t const * payload) [member function]

  2096     cls.add_method('ReceiveIcmp',

  2097                    'void',

  2098                    [param('ns3::Ipv4Address', 'icmpSource'), param('uint8_t', 'icmpTtl'), param('uint8_t', 'icmpType'), param('uint8_t', 'icmpCode'), param('uint32_t', 'icmpInfo'), param('ns3::Ipv4Address', 'payloadSource'), param('ns3::Ipv4Address', 'payloadDestination'), param('uint8_t const *', 'payload')],

  2099                    is_virtual=True)

  2100     ## udp-l4-protocol.h: void ns3::UdpL4Protocol::Send(ns3::Ptr<ns3::Packet> packet, ns3::Ipv4Address saddr, ns3::Ipv4Address daddr, uint16_t sport, uint16_t dport) [member function]

  2101     cls.add_method('Send',

  2102                    'void',

  2103                    [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Ipv4Address', 'saddr'), param('ns3::Ipv4Address', 'daddr'), param('uint16_t', 'sport'), param('uint16_t', 'dport')])

  2104     ## udp-l4-protocol.h: void ns3::UdpL4Protocol::Send(ns3::Ptr<ns3::Packet> packet, ns3::Ipv4Address saddr, ns3::Ipv4Address daddr, uint16_t sport, uint16_t dport, ns3::Ptr<ns3::Ipv4Route> route) [member function]

  2105     cls.add_method('Send',

  2106                    'void',

  2107                    [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Ipv4Address', 'saddr'), param('ns3::Ipv4Address', 'daddr'), param('uint16_t', 'sport'), param('uint16_t', 'dport'), param('ns3::Ptr< ns3::Ipv4Route >', 'route')])

  2108     ## udp-l4-protocol.h: void ns3::UdpL4Protocol::SetNode(ns3::Ptr<ns3::Node> node) [member function]

  2109     cls.add_method('SetNode',

  2110                    'void',

  2111                    [param('ns3::Ptr< ns3::Node >', 'node')])

  2112     ## udp-l4-protocol.h: ns3::UdpL4Protocol::PROT_NUMBER [variable]

  2113     cls.add_static_attribute('PROT_NUMBER', 'uint8_t const', is_const=True)

  2114     ## udp-l4-protocol.h: void ns3::UdpL4Protocol::DoDispose() [member function]

  2115     cls.add_method('DoDispose',

  2116                    'void',

  2117                    [],

  2118                    visibility='protected', is_virtual=True)

  2119     ## udp-l4-protocol.h: void ns3::UdpL4Protocol::NotifyNewAggregate() [member function]

  2120     cls.add_method('NotifyNewAggregate',

  2121                    'void',

  2122                    [],

  2123                    visibility='protected', is_virtual=True)

  2124     return

  2126 def register_Ns3Icmpv4L4Protocol_methods(root_module, cls):

  2127     ## icmpv4-l4-protocol.h: ns3::Icmpv4L4Protocol::Icmpv4L4Protocol(ns3::Icmpv4L4Protocol const & arg0) [copy constructor]

  2128     cls.add_constructor([param('ns3::Icmpv4L4Protocol const &', 'arg0')])

  2129     ## icmpv4-l4-protocol.h: ns3::Icmpv4L4Protocol::Icmpv4L4Protocol() [constructor]

  2130     cls.add_constructor([])

  2131     ## icmpv4-l4-protocol.h: int ns3::Icmpv4L4Protocol::GetProtocolNumber() const [member function]

  2132     cls.add_method('GetProtocolNumber',

  2133                    'int',

  2134                    [],

  2135                    is_const=True, is_virtual=True)

  2136     ## icmpv4-l4-protocol.h: static uint16_t ns3::Icmpv4L4Protocol::GetStaticProtocolNumber() [member function]

  2137     cls.add_method('GetStaticProtocolNumber',

  2138                    'uint16_t',

  2139                    [],

  2140                    is_static=True)

  2141     ## icmpv4-l4-protocol.h: static ns3::TypeId ns3::Icmpv4L4Protocol::GetTypeId() [member function]

  2142     cls.add_method('GetTypeId',

  2143                    'ns3::TypeId',

  2144                    [],

  2145                    is_static=True)

  2146     ## icmpv4-l4-protocol.h: ns3::Ipv4L4Protocol::RxStatus ns3::Icmpv4L4Protocol::Receive(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Address const & source, ns3::Ipv4Address const & destination, ns3::Ptr<ns3::Ipv4Interface> incomingInterface) [member function]

  2147     cls.add_method('Receive',

  2148                    'ns3::Ipv4L4Protocol::RxStatus',

  2149                    [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Address const &', 'source'), param('ns3::Ipv4Address const &', 'destination'), param('ns3::Ptr< ns3::Ipv4Interface >', 'incomingInterface')],

  2150                    is_virtual=True)

  2151     ## icmpv4-l4-protocol.h: void ns3::Icmpv4L4Protocol::SendDestUnreachFragNeeded(ns3::Ipv4Header header, ns3::Ptr<ns3::Packet const> orgData, uint16_t nextHopMtu) [member function]

  2152     cls.add_method('SendDestUnreachFragNeeded',

  2153                    'void',

  2154                    [param('ns3::Ipv4Header', 'header'), param('ns3::Ptr< ns3::Packet const >', 'orgData'), param('uint16_t', 'nextHopMtu')])

  2155     ## icmpv4-l4-protocol.h: void ns3::Icmpv4L4Protocol::SendDestUnreachPort(ns3::Ipv4Header header, ns3::Ptr<ns3::Packet const> orgData) [member function]

  2156     cls.add_method('SendDestUnreachPort',

  2157                    'void',

  2158                    [param('ns3::Ipv4Header', 'header'), param('ns3::Ptr< ns3::Packet const >', 'orgData')])

  2159     ## icmpv4-l4-protocol.h: void ns3::Icmpv4L4Protocol::SendTimeExceededTtl(ns3::Ipv4Header header, ns3::Ptr<ns3::Packet const> orgData) [member function]

  2160     cls.add_method('SendTimeExceededTtl',

  2161                    'void',

  2162                    [param('ns3::Ipv4Header', 'header'), param('ns3::Ptr< ns3::Packet const >', 'orgData')])

  2163     ## icmpv4-l4-protocol.h: void ns3::Icmpv4L4Protocol::SetNode(ns3::Ptr<ns3::Node> node) [member function]

  2164     cls.add_method('SetNode',

  2165                    'void',

  2166                    [param('ns3::Ptr< ns3::Node >', 'node')])

  2167     ## icmpv4-l4-protocol.h: ns3::Icmpv4L4Protocol::PROT_NUMBER [variable]

  2168     cls.add_static_attribute('PROT_NUMBER', 'uint8_t const', is_const=True)

  2169     ## icmpv4-l4-protocol.h: void ns3::Icmpv4L4Protocol::NotifyNewAggregate() [member function]

  2170     cls.add_method('NotifyNewAggregate',

  2171                    'void',

  2172                    [],

  2173                    visibility='protected', is_virtual=True)

  2174     ## icmpv4-l4-protocol.h: void ns3::Icmpv4L4Protocol::DoDispose() [member function]

  2175     cls.add_method('DoDispose',

  2176                    'void',

  2177                    [],

  2178                    visibility='private', is_virtual=True)

  2179     return

  2181 def register_functions(root_module):

  2182     module = root_module

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

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

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

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

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

  2188     return

  2190 def register_functions_ns3_Config(module, root_module):

  2191     return

  2193 def register_functions_ns3_TimeStepPrecision(module, root_module):

  2194     return

  2196 def register_functions_ns3_addressUtils(module, root_module):

  2197     return

  2199 def register_functions_ns3_internal(module, root_module):

  2200     return

  2202 def register_functions_ns3_olsr(module, root_module):

  2203     return

author	Gustavo J. A. M. Carneiro <gjc@inescporto.pt>
	Wed Sep 02 11:29:23 2009 +0100 (2009-09-02)
changeset 4749	af227579ab64
parent 4744	cd473a5cf99c
child 5203	1ccc02a7676b
child 5209	4f5eb479554c
permissions	-rw-r--r--