ns-3.5: bindings/python/ns3_module

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

     3 def register_types(module):

     4     root_module = module.get_root()

     6     ## olsr-state.h: ns3::OlsrState [class]

     7     module.add_class('OlsrState')

     8     module.add_container('std::vector< ns3::olsr::MprSelectorTuple >', 'ns3::olsr::MprSelectorTuple', container_type='vector')

     9     module.add_container('std::vector< ns3::olsr::NeighborTuple >', 'ns3::olsr::NeighborTuple', container_type='vector')

    10     module.add_container('std::vector< ns3::olsr::TwoHopNeighborTuple >', 'ns3::olsr::TwoHopNeighborTuple', container_type='vector')

    11     module.add_container('std::vector< ns3::olsr::LinkTuple >', 'ns3::olsr::LinkTuple', container_type='vector')

    12     module.add_container('std::vector< ns3::olsr::TopologyTuple >', 'ns3::olsr::TopologyTuple', container_type='vector')

    13     module.add_container('std::vector< ns3::olsr::IfaceAssocTuple >', 'ns3::olsr::IfaceAssocTuple', container_type='vector')

    15     ## Register a nested module for the namespace Config

    17     nested_module = module.add_cpp_namespace('Config')

    18     register_types_ns3_Config(nested_module)

    21     ## Register a nested module for the namespace TimeStepPrecision

    23     nested_module = module.add_cpp_namespace('TimeStepPrecision')

    24     register_types_ns3_TimeStepPrecision(nested_module)

    27     ## Register a nested module for the namespace addressUtils

    29     nested_module = module.add_cpp_namespace('addressUtils')

    30     register_types_ns3_addressUtils(nested_module)

    33     ## Register a nested module for the namespace internal

    35     nested_module = module.add_cpp_namespace('internal')

    36     register_types_ns3_internal(nested_module)

    39     ## Register a nested module for the namespace olsr

    41     nested_module = module.add_cpp_namespace('olsr')

    42     register_types_ns3_olsr(nested_module)

    45 def register_types_ns3_Config(module):

    46     root_module = module.get_root()

    49 def register_types_ns3_TimeStepPrecision(module):

    50     root_module = module.get_root()

    53 def register_types_ns3_addressUtils(module):

    54     root_module = module.get_root()

    57 def register_types_ns3_internal(module):

    58     root_module = module.get_root()

    61 def register_types_ns3_olsr(module):

    62     root_module = module.get_root()

    64     ## olsr-repositories.h: ns3::olsr::DuplicateTuple [struct]

    65     module.add_class('DuplicateTuple')

    66     ## olsr-repositories.h: ns3::olsr::IfaceAssocTuple [struct]

    67     module.add_class('IfaceAssocTuple')

    68     ## olsr-repositories.h: ns3::olsr::LinkTuple [struct]

    69     module.add_class('LinkTuple')

    70     ## olsr-header.h: ns3::olsr::MessageHeader [class]

    71     module.add_class('MessageHeader', parent=root_module['ns3::Header'])

    72     ## olsr-header.h: ns3::olsr::MessageHeader::MessageType [enumeration]

    73     module.add_enum('MessageType', ['HELLO_MESSAGE', 'TC_MESSAGE', 'MID_MESSAGE', 'HNA_MESSAGE'], outer_class=root_module['ns3::olsr::MessageHeader'])

    74     ## olsr-header.h: ns3::olsr::MessageHeader::Hello [struct]

    75     module.add_class('Hello', outer_class=root_module['ns3::olsr::MessageHeader'])

    76     ## olsr-header.h: ns3::olsr::MessageHeader::Hello::LinkMessage [struct]

    77     module.add_class('LinkMessage', outer_class=root_module['ns3::olsr::MessageHeader::Hello'])

    78     ## olsr-header.h: ns3::olsr::MessageHeader::Hna [struct]

    79     module.add_class('Hna', outer_class=root_module['ns3::olsr::MessageHeader'])

    80     ## olsr-header.h: ns3::olsr::MessageHeader::Hna::Association [struct]

    81     module.add_class('Association', outer_class=root_module['ns3::olsr::MessageHeader::Hna'])

    82     ## olsr-header.h: ns3::olsr::MessageHeader::Mid [struct]

    83     module.add_class('Mid', outer_class=root_module['ns3::olsr::MessageHeader'])

    84     ## olsr-header.h: ns3::olsr::MessageHeader::Tc [struct]

    85     module.add_class('Tc', outer_class=root_module['ns3::olsr::MessageHeader'])

    86     ## olsr-repositories.h: ns3::olsr::MprSelectorTuple [struct]

    87     module.add_class('MprSelectorTuple')

    88     ## olsr-repositories.h: ns3::olsr::NeighborTuple [struct]

    89     module.add_class('NeighborTuple')

    90     ## olsr-repositories.h: ns3::olsr::NeighborTuple::Status [enumeration]

    91     module.add_enum('Status', ['STATUS_NOT_SYM', 'STATUS_SYM'], outer_class=root_module['ns3::olsr::NeighborTuple'])

    92     ## olsr-header.h: ns3::olsr::PacketHeader [class]

    93     module.add_class('PacketHeader', parent=root_module['ns3::Header'])

    94     ## olsr-routing-protocol.h: ns3::olsr::RoutingProtocol [class]

    95     module.add_class('RoutingProtocol', parent=root_module['ns3::Ipv4RoutingProtocol'])

    96     ## olsr-routing-protocol.h: ns3::olsr::RoutingTableEntry [struct]

    97     module.add_class('RoutingTableEntry')

    98     ## olsr-repositories.h: ns3::olsr::TopologyTuple [struct]

    99     module.add_class('TopologyTuple')

   100     ## olsr-repositories.h: ns3::olsr::TwoHopNeighborTuple [struct]

   101     module.add_class('TwoHopNeighborTuple')

   102     module.add_container('std::vector< ns3::olsr::MessageHeader::Hello::LinkMessage >', 'ns3::olsr::MessageHeader::Hello::LinkMessage', container_type='vector')

   103     module.add_container('std::vector< ns3::olsr::MessageHeader::Hna::Association >', 'ns3::olsr::MessageHeader::Hna::Association', container_type='vector')

   104     typehandlers.add_type_alias('std::vector< ns3::olsr::DuplicateTuple, std::allocator< ns3::olsr::DuplicateTuple > >', 'ns3::olsr::DuplicateSet')

   105     typehandlers.add_type_alias('std::set< ns3::Ipv4Address, std::less< ns3::Ipv4Address >, std::allocator< ns3::Ipv4Address > >', 'ns3::olsr::MprSet')

   106     typehandlers.add_type_alias('std::vector< ns3::olsr::MprSelectorTuple, std::allocator< ns3::olsr::MprSelectorTuple > >', 'ns3::olsr::MprSelectorSet')

   107     typehandlers.add_type_alias('std::vector< ns3::olsr::MessageHeader, std::allocator< ns3::olsr::MessageHeader > >', 'ns3::olsr::MessageList')

   108     typehandlers.add_type_alias('std::vector< ns3::olsr::IfaceAssocTuple, std::allocator< ns3::olsr::IfaceAssocTuple > >', 'ns3::olsr::IfaceAssocSet')

   109     typehandlers.add_type_alias('std::vector< ns3::olsr::NeighborTuple, std::allocator< ns3::olsr::NeighborTuple > >', 'ns3::olsr::NeighborSet')

   110     typehandlers.add_type_alias('std::vector< ns3::olsr::TwoHopNeighborTuple, std::allocator< ns3::olsr::TwoHopNeighborTuple > >', 'ns3::olsr::TwoHopNeighborSet')

   111     typehandlers.add_type_alias('std::vector< ns3::olsr::TopologyTuple, std::allocator< ns3::olsr::TopologyTuple > >', 'ns3::olsr::TopologySet')

   112     typehandlers.add_type_alias('std::vector< ns3::olsr::LinkTuple, std::allocator< ns3::olsr::LinkTuple > >', 'ns3::olsr::LinkSet')

   114 def register_methods(root_module):

   115     register_Ns3OlsrState_methods(root_module, root_module['ns3::OlsrState'])

   116     register_Ns3OlsrDuplicateTuple_methods(root_module, root_module['ns3::olsr::DuplicateTuple'])

   117     register_Ns3OlsrIfaceAssocTuple_methods(root_module, root_module['ns3::olsr::IfaceAssocTuple'])

   118     register_Ns3OlsrLinkTuple_methods(root_module, root_module['ns3::olsr::LinkTuple'])

   119     register_Ns3OlsrMessageHeader_methods(root_module, root_module['ns3::olsr::MessageHeader'])

   120     register_Ns3OlsrMessageHeaderHello_methods(root_module, root_module['ns3::olsr::MessageHeader::Hello'])

   121     register_Ns3OlsrMessageHeaderHelloLinkMessage_methods(root_module, root_module['ns3::olsr::MessageHeader::Hello::LinkMessage'])

   122     register_Ns3OlsrMessageHeaderHna_methods(root_module, root_module['ns3::olsr::MessageHeader::Hna'])

   123     register_Ns3OlsrMessageHeaderHnaAssociation_methods(root_module, root_module['ns3::olsr::MessageHeader::Hna::Association'])

   124     register_Ns3OlsrMessageHeaderMid_methods(root_module, root_module['ns3::olsr::MessageHeader::Mid'])

   125     register_Ns3OlsrMessageHeaderTc_methods(root_module, root_module['ns3::olsr::MessageHeader::Tc'])

   126     register_Ns3OlsrMprSelectorTuple_methods(root_module, root_module['ns3::olsr::MprSelectorTuple'])

   127     register_Ns3OlsrNeighborTuple_methods(root_module, root_module['ns3::olsr::NeighborTuple'])

   128     register_Ns3OlsrPacketHeader_methods(root_module, root_module['ns3::olsr::PacketHeader'])

   129     register_Ns3OlsrRoutingProtocol_methods(root_module, root_module['ns3::olsr::RoutingProtocol'])

   130     register_Ns3OlsrRoutingTableEntry_methods(root_module, root_module['ns3::olsr::RoutingTableEntry'])

   131     register_Ns3OlsrTopologyTuple_methods(root_module, root_module['ns3::olsr::TopologyTuple'])

   132     register_Ns3OlsrTwoHopNeighborTuple_methods(root_module, root_module['ns3::olsr::TwoHopNeighborTuple'])

   133     return

   135 def register_Ns3OlsrState_methods(root_module, cls):

   136     ## olsr-state.h: ns3::OlsrState::OlsrState(ns3::OlsrState const & arg0) [copy constructor]

   137     cls.add_constructor([param('ns3::OlsrState const &', 'arg0')])

   138     ## olsr-state.h: ns3::OlsrState::OlsrState() [constructor]

   139     cls.add_constructor([])

   140     ## olsr-state.h: ns3::olsr::MprSelectorSet const & ns3::OlsrState::GetMprSelectors() const [member function]

   141     cls.add_method('GetMprSelectors',

   142                    'ns3::olsr::MprSelectorSet const &',

   143                    [],

   144                    is_const=True)

   145     ## olsr-state.h: ns3::olsr::MprSelectorTuple * ns3::OlsrState::FindMprSelectorTuple(ns3::Ipv4Address const & mainAddr) [member function]

   146     cls.add_method('FindMprSelectorTuple',

   147                    'ns3::olsr::MprSelectorTuple *',

   148                    [param('ns3::Ipv4Address const &', 'mainAddr')])

   149     ## olsr-state.h: void ns3::OlsrState::EraseMprSelectorTuple(ns3::olsr::MprSelectorTuple const & tuple) [member function]

   150     cls.add_method('EraseMprSelectorTuple',

   151                    'void',

   152                    [param('ns3::olsr::MprSelectorTuple const &', 'tuple')])

   153     ## olsr-state.h: void ns3::OlsrState::EraseMprSelectorTuples(ns3::Ipv4Address const & mainAddr) [member function]

   154     cls.add_method('EraseMprSelectorTuples',

   155                    'void',

   156                    [param('ns3::Ipv4Address const &', 'mainAddr')])

   157     ## olsr-state.h: void ns3::OlsrState::InsertMprSelectorTuple(ns3::olsr::MprSelectorTuple const & tuple) [member function]

   158     cls.add_method('InsertMprSelectorTuple',

   159                    'void',

   160                    [param('ns3::olsr::MprSelectorTuple const &', 'tuple')])

   161     ## olsr-state.h: std::string ns3::OlsrState::PrintMprSelectorSet() const [member function]

   162     cls.add_method('PrintMprSelectorSet',

   163                    'std::string',

   164                    [],

   165                    is_const=True)

   166     ## olsr-state.h: ns3::olsr::NeighborSet const & ns3::OlsrState::GetNeighbors() const [member function]

   167     cls.add_method('GetNeighbors',

   168                    'ns3::olsr::NeighborSet const &',

   169                    [],

   170                    is_const=True)

   171     ## olsr-state.h: ns3::olsr::NeighborSet & ns3::OlsrState::GetNeighbors() [member function]

   172     cls.add_method('GetNeighbors',

   173                    'ns3::olsr::NeighborSet &',

   174                    [])

   175     ## olsr-state.h: ns3::olsr::NeighborTuple * ns3::OlsrState::FindNeighborTuple(ns3::Ipv4Address const & mainAddr) [member function]

   176     cls.add_method('FindNeighborTuple',

   177                    'ns3::olsr::NeighborTuple *',

   178                    [param('ns3::Ipv4Address const &', 'mainAddr')])

   179     ## olsr-state.h: ns3::olsr::NeighborTuple const * ns3::OlsrState::FindSymNeighborTuple(ns3::Ipv4Address const & mainAddr) const [member function]

   180     cls.add_method('FindSymNeighborTuple',

   181                    'ns3::olsr::NeighborTuple const *',

   182                    [param('ns3::Ipv4Address const &', 'mainAddr')],

   183                    is_const=True)

   184     ## olsr-state.h: ns3::olsr::NeighborTuple * ns3::OlsrState::FindNeighborTuple(ns3::Ipv4Address const & mainAddr, uint8_t willingness) [member function]

   185     cls.add_method('FindNeighborTuple',

   186                    'ns3::olsr::NeighborTuple *',

   187                    [param('ns3::Ipv4Address const &', 'mainAddr'), param('uint8_t', 'willingness')])

   188     ## olsr-state.h: void ns3::OlsrState::EraseNeighborTuple(ns3::olsr::NeighborTuple const & neighborTuple) [member function]

   189     cls.add_method('EraseNeighborTuple',

   190                    'void',

   191                    [param('ns3::olsr::NeighborTuple const &', 'neighborTuple')])

   192     ## olsr-state.h: void ns3::OlsrState::EraseNeighborTuple(ns3::Ipv4Address const & mainAddr) [member function]

   193     cls.add_method('EraseNeighborTuple',

   194                    'void',

   195                    [param('ns3::Ipv4Address const &', 'mainAddr')])

   196     ## olsr-state.h: void ns3::OlsrState::InsertNeighborTuple(ns3::olsr::NeighborTuple const & tuple) [member function]

   197     cls.add_method('InsertNeighborTuple',

   198                    'void',

   199                    [param('ns3::olsr::NeighborTuple const &', 'tuple')])

   200     ## olsr-state.h: ns3::olsr::TwoHopNeighborSet const & ns3::OlsrState::GetTwoHopNeighbors() const [member function]

   201     cls.add_method('GetTwoHopNeighbors',

   202                    'ns3::olsr::TwoHopNeighborSet const &',

   203                    [],

   204                    is_const=True)

   205     ## olsr-state.h: ns3::olsr::TwoHopNeighborSet & ns3::OlsrState::GetTwoHopNeighbors() [member function]

   206     cls.add_method('GetTwoHopNeighbors',

   207                    'ns3::olsr::TwoHopNeighborSet &',

   208                    [])

   209     ## olsr-state.h: ns3::olsr::TwoHopNeighborTuple * ns3::OlsrState::FindTwoHopNeighborTuple(ns3::Ipv4Address const & neighbor, ns3::Ipv4Address const & twoHopNeighbor) [member function]

   210     cls.add_method('FindTwoHopNeighborTuple',

   211                    'ns3::olsr::TwoHopNeighborTuple *',

   212                    [param('ns3::Ipv4Address const &', 'neighbor'), param('ns3::Ipv4Address const &', 'twoHopNeighbor')])

   213     ## olsr-state.h: void ns3::OlsrState::EraseTwoHopNeighborTuple(ns3::olsr::TwoHopNeighborTuple const & tuple) [member function]

   214     cls.add_method('EraseTwoHopNeighborTuple',

   215                    'void',

   216                    [param('ns3::olsr::TwoHopNeighborTuple const &', 'tuple')])

   217     ## olsr-state.h: void ns3::OlsrState::EraseTwoHopNeighborTuples(ns3::Ipv4Address const & neighbor) [member function]

   218     cls.add_method('EraseTwoHopNeighborTuples',

   219                    'void',

   220                    [param('ns3::Ipv4Address const &', 'neighbor')])

   221     ## olsr-state.h: void ns3::OlsrState::EraseTwoHopNeighborTuples(ns3::Ipv4Address const & neighbor, ns3::Ipv4Address const & twoHopNeighbor) [member function]

   222     cls.add_method('EraseTwoHopNeighborTuples',

   223                    'void',

   224                    [param('ns3::Ipv4Address const &', 'neighbor'), param('ns3::Ipv4Address const &', 'twoHopNeighbor')])

   225     ## olsr-state.h: void ns3::OlsrState::InsertTwoHopNeighborTuple(ns3::olsr::TwoHopNeighborTuple const & tuple) [member function]

   226     cls.add_method('InsertTwoHopNeighborTuple',

   227                    'void',

   228                    [param('ns3::olsr::TwoHopNeighborTuple const &', 'tuple')])

   229     ## olsr-state.h: bool ns3::OlsrState::FindMprAddress(ns3::Ipv4Address const & address) [member function]

   230     cls.add_method('FindMprAddress',

   231                    'bool',

   232                    [param('ns3::Ipv4Address const &', 'address')])

   233     ## olsr-state.h: void ns3::OlsrState::SetMprSet(ns3::olsr::MprSet mprSet) [member function]

   234     cls.add_method('SetMprSet',

   235                    'void',

   236                    [param('ns3::olsr::MprSet', 'mprSet')])

   237     ## olsr-state.h: ns3::olsr::DuplicateTuple * ns3::OlsrState::FindDuplicateTuple(ns3::Ipv4Address const & address, uint16_t sequenceNumber) [member function]

   238     cls.add_method('FindDuplicateTuple',

   239                    'ns3::olsr::DuplicateTuple *',

   240                    [param('ns3::Ipv4Address const &', 'address'), param('uint16_t', 'sequenceNumber')])

   241     ## olsr-state.h: void ns3::OlsrState::EraseDuplicateTuple(ns3::olsr::DuplicateTuple const & tuple) [member function]

   242     cls.add_method('EraseDuplicateTuple',

   243                    'void',

   244                    [param('ns3::olsr::DuplicateTuple const &', 'tuple')])

   245     ## olsr-state.h: void ns3::OlsrState::InsertDuplicateTuple(ns3::olsr::DuplicateTuple const & tuple) [member function]

   246     cls.add_method('InsertDuplicateTuple',

   247                    'void',

   248                    [param('ns3::olsr::DuplicateTuple const &', 'tuple')])

   249     ## olsr-state.h: ns3::olsr::LinkSet const & ns3::OlsrState::GetLinks() const [member function]

   250     cls.add_method('GetLinks',

   251                    'ns3::olsr::LinkSet const &',

   252                    [],

   253                    is_const=True)

   254     ## olsr-state.h: ns3::olsr::LinkTuple * ns3::OlsrState::FindLinkTuple(ns3::Ipv4Address const & ifaceAddr) [member function]

   255     cls.add_method('FindLinkTuple',

   256                    'ns3::olsr::LinkTuple *',

   257                    [param('ns3::Ipv4Address const &', 'ifaceAddr')])

   258     ## olsr-state.h: ns3::olsr::LinkTuple * ns3::OlsrState::FindSymLinkTuple(ns3::Ipv4Address const & ifaceAddr, ns3::Time time) [member function]

   259     cls.add_method('FindSymLinkTuple',

   260                    'ns3::olsr::LinkTuple *',

   261                    [param('ns3::Ipv4Address const &', 'ifaceAddr'), param('ns3::Time', 'time')])

   262     ## olsr-state.h: void ns3::OlsrState::EraseLinkTuple(ns3::olsr::LinkTuple const & tuple) [member function]

   263     cls.add_method('EraseLinkTuple',

   264                    'void',

   265                    [param('ns3::olsr::LinkTuple const &', 'tuple')])

   266     ## olsr-state.h: ns3::olsr::LinkTuple & ns3::OlsrState::InsertLinkTuple(ns3::olsr::LinkTuple const & tuple) [member function]

   267     cls.add_method('InsertLinkTuple',

   268                    'ns3::olsr::LinkTuple &',

   269                    [param('ns3::olsr::LinkTuple const &', 'tuple')])

   270     ## olsr-state.h: ns3::olsr::TopologySet const & ns3::OlsrState::GetTopologySet() const [member function]

   271     cls.add_method('GetTopologySet',

   272                    'ns3::olsr::TopologySet const &',

   273                    [],

   274                    is_const=True)

   275     ## olsr-state.h: ns3::olsr::TopologyTuple * ns3::OlsrState::FindTopologyTuple(ns3::Ipv4Address const & destAddr, ns3::Ipv4Address const & lastAddr) [member function]

   276     cls.add_method('FindTopologyTuple',

   277                    'ns3::olsr::TopologyTuple *',

   278                    [param('ns3::Ipv4Address const &', 'destAddr'), param('ns3::Ipv4Address const &', 'lastAddr')])

   279     ## olsr-state.h: ns3::olsr::TopologyTuple * ns3::OlsrState::FindNewerTopologyTuple(ns3::Ipv4Address const & lastAddr, uint16_t ansn) [member function]

   280     cls.add_method('FindNewerTopologyTuple',

   281                    'ns3::olsr::TopologyTuple *',

   282                    [param('ns3::Ipv4Address const &', 'lastAddr'), param('uint16_t', 'ansn')])

   283     ## olsr-state.h: void ns3::OlsrState::EraseTopologyTuple(ns3::olsr::TopologyTuple const & tuple) [member function]

   284     cls.add_method('EraseTopologyTuple',

   285                    'void',

   286                    [param('ns3::olsr::TopologyTuple const &', 'tuple')])

   287     ## olsr-state.h: void ns3::OlsrState::EraseOlderTopologyTuples(ns3::Ipv4Address const & lastAddr, uint16_t ansn) [member function]

   288     cls.add_method('EraseOlderTopologyTuples',

   289                    'void',

   290                    [param('ns3::Ipv4Address const &', 'lastAddr'), param('uint16_t', 'ansn')])

   291     ## olsr-state.h: void ns3::OlsrState::InsertTopologyTuple(ns3::olsr::TopologyTuple const & tuple) [member function]

   292     cls.add_method('InsertTopologyTuple',

   293                    'void',

   294                    [param('ns3::olsr::TopologyTuple const &', 'tuple')])

   295     ## olsr-state.h: ns3::olsr::IfaceAssocSet const & ns3::OlsrState::GetIfaceAssocSet() const [member function]

   296     cls.add_method('GetIfaceAssocSet',

   297                    'ns3::olsr::IfaceAssocSet const &',

   298                    [],

   299                    is_const=True)

   300     ## olsr-state.h: ns3::olsr::IfaceAssocSet & ns3::OlsrState::GetIfaceAssocSetMutable() [member function]

   301     cls.add_method('GetIfaceAssocSetMutable',

   302                    'ns3::olsr::IfaceAssocSet &',

   303                    [])

   304     ## olsr-state.h: ns3::olsr::IfaceAssocTuple * ns3::OlsrState::FindIfaceAssocTuple(ns3::Ipv4Address const & ifaceAddr) [member function]

   305     cls.add_method('FindIfaceAssocTuple',

   306                    'ns3::olsr::IfaceAssocTuple *',

   307                    [param('ns3::Ipv4Address const &', 'ifaceAddr')])

   308     ## olsr-state.h: ns3::olsr::IfaceAssocTuple const * ns3::OlsrState::FindIfaceAssocTuple(ns3::Ipv4Address const & ifaceAddr) const [member function]

   309     cls.add_method('FindIfaceAssocTuple',

   310                    'ns3::olsr::IfaceAssocTuple const *',

   311                    [param('ns3::Ipv4Address const &', 'ifaceAddr')],

   312                    is_const=True)

   313     ## olsr-state.h: void ns3::OlsrState::EraseIfaceAssocTuple(ns3::olsr::IfaceAssocTuple const & tuple) [member function]

   314     cls.add_method('EraseIfaceAssocTuple',

   315                    'void',

   316                    [param('ns3::olsr::IfaceAssocTuple const &', 'tuple')])

   317     ## olsr-state.h: void ns3::OlsrState::InsertIfaceAssocTuple(ns3::olsr::IfaceAssocTuple const & tuple) [member function]

   318     cls.add_method('InsertIfaceAssocTuple',

   319                    'void',

   320                    [param('ns3::olsr::IfaceAssocTuple const &', 'tuple')])

   321     ## olsr-state.h: std::vector<ns3::Ipv4Address, std::allocator<ns3::Ipv4Address> > ns3::OlsrState::FindNeighborInterfaces(ns3::Ipv4Address const & neighborMainAddr) const [member function]

   322     cls.add_method('FindNeighborInterfaces',

   323                    'std::vector< ns3::Ipv4Address >',

   324                    [param('ns3::Ipv4Address const &', 'neighborMainAddr')],

   325                    is_const=True)

   326     return

   328 def register_Ns3OlsrDuplicateTuple_methods(root_module, cls):

   329     cls.add_binary_comparison_operator('==')

   330     ## olsr-repositories.h: ns3::olsr::DuplicateTuple::DuplicateTuple() [constructor]

   331     cls.add_constructor([])

   332     ## olsr-repositories.h: ns3::olsr::DuplicateTuple::DuplicateTuple(ns3::olsr::DuplicateTuple const & arg0) [copy constructor]

   333     cls.add_constructor([param('ns3::olsr::DuplicateTuple const &', 'arg0')])

   334     ## olsr-repositories.h: ns3::olsr::DuplicateTuple::address [variable]

   335     cls.add_instance_attribute('address', 'ns3::Ipv4Address', is_const=False)

   336     ## olsr-repositories.h: ns3::olsr::DuplicateTuple::expirationTime [variable]

   337     cls.add_instance_attribute('expirationTime', 'ns3::Time', is_const=False)

   338     ## olsr-repositories.h: ns3::olsr::DuplicateTuple::ifaceList [variable]

   339     cls.add_instance_attribute('ifaceList', 'std::vector< ns3::Ipv4Address >', is_const=False)

   340     ## olsr-repositories.h: ns3::olsr::DuplicateTuple::retransmitted [variable]

   341     cls.add_instance_attribute('retransmitted', 'bool', is_const=False)

   342     ## olsr-repositories.h: ns3::olsr::DuplicateTuple::sequenceNumber [variable]

   343     cls.add_instance_attribute('sequenceNumber', 'uint16_t', is_const=False)

   344     return

   346 def register_Ns3OlsrIfaceAssocTuple_methods(root_module, cls):

   347     cls.add_output_stream_operator()

   348     cls.add_binary_comparison_operator('==')

   349     ## olsr-repositories.h: ns3::olsr::IfaceAssocTuple::IfaceAssocTuple() [constructor]

   350     cls.add_constructor([])

   351     ## olsr-repositories.h: ns3::olsr::IfaceAssocTuple::IfaceAssocTuple(ns3::olsr::IfaceAssocTuple const & arg0) [copy constructor]

   352     cls.add_constructor([param('ns3::olsr::IfaceAssocTuple const &', 'arg0')])

   353     ## olsr-repositories.h: ns3::olsr::IfaceAssocTuple::ifaceAddr [variable]

   354     cls.add_instance_attribute('ifaceAddr', 'ns3::Ipv4Address', is_const=False)

   355     ## olsr-repositories.h: ns3::olsr::IfaceAssocTuple::mainAddr [variable]

   356     cls.add_instance_attribute('mainAddr', 'ns3::Ipv4Address', is_const=False)

   357     ## olsr-repositories.h: ns3::olsr::IfaceAssocTuple::time [variable]

   358     cls.add_instance_attribute('time', 'ns3::Time', is_const=False)

   359     return

   361 def register_Ns3OlsrLinkTuple_methods(root_module, cls):

   362     cls.add_output_stream_operator()

   363     cls.add_binary_comparison_operator('==')

   364     ## olsr-repositories.h: ns3::olsr::LinkTuple::LinkTuple() [constructor]

   365     cls.add_constructor([])

   366     ## olsr-repositories.h: ns3::olsr::LinkTuple::LinkTuple(ns3::olsr::LinkTuple const & arg0) [copy constructor]

   367     cls.add_constructor([param('ns3::olsr::LinkTuple const &', 'arg0')])

   368     ## olsr-repositories.h: ns3::olsr::LinkTuple::asymTime [variable]

   369     cls.add_instance_attribute('asymTime', 'ns3::Time', is_const=False)

   370     ## olsr-repositories.h: ns3::olsr::LinkTuple::localIfaceAddr [variable]

   371     cls.add_instance_attribute('localIfaceAddr', 'ns3::Ipv4Address', is_const=False)

   372     ## olsr-repositories.h: ns3::olsr::LinkTuple::neighborIfaceAddr [variable]

   373     cls.add_instance_attribute('neighborIfaceAddr', 'ns3::Ipv4Address', is_const=False)

   374     ## olsr-repositories.h: ns3::olsr::LinkTuple::symTime [variable]

   375     cls.add_instance_attribute('symTime', 'ns3::Time', is_const=False)

   376     ## olsr-repositories.h: ns3::olsr::LinkTuple::time [variable]

   377     cls.add_instance_attribute('time', 'ns3::Time', is_const=False)

   378     return

   380 def register_Ns3OlsrMessageHeader_methods(root_module, cls):

   381     cls.add_output_stream_operator()

   382     ## olsr-header.h: ns3::olsr::MessageHeader::MessageHeader(ns3::olsr::MessageHeader const & arg0) [copy constructor]

   383     cls.add_constructor([param('ns3::olsr::MessageHeader const &', 'arg0')])

   384     ## olsr-header.h: ns3::olsr::MessageHeader::MessageHeader() [constructor]

   385     cls.add_constructor([])

   386     ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::Deserialize(ns3::Buffer::Iterator start) [member function]

   387     cls.add_method('Deserialize',

   388                    'uint32_t',

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

   390                    is_virtual=True)

   391     ## olsr-header.h: ns3::olsr::MessageHeader::Hello & ns3::olsr::MessageHeader::GetHello() [member function]

   392     cls.add_method('GetHello',

   393                    'ns3::olsr::MessageHeader::Hello &',

   394                    [])

   395     ## olsr-header.h: ns3::olsr::MessageHeader::Hello const & ns3::olsr::MessageHeader::GetHello() const [member function]

   396     cls.add_method('GetHello',

   397                    'ns3::olsr::MessageHeader::Hello const &',

   398                    [],

   399                    is_const=True)

   400     ## olsr-header.h: ns3::olsr::MessageHeader::Hna & ns3::olsr::MessageHeader::GetHna() [member function]

   401     cls.add_method('GetHna',

   402                    'ns3::olsr::MessageHeader::Hna &',

   403                    [])

   404     ## olsr-header.h: ns3::olsr::MessageHeader::Hna const & ns3::olsr::MessageHeader::GetHna() const [member function]

   405     cls.add_method('GetHna',

   406                    'ns3::olsr::MessageHeader::Hna const &',

   407                    [],

   408                    is_const=True)

   409     ## olsr-header.h: uint8_t ns3::olsr::MessageHeader::GetHopCount() const [member function]

   410     cls.add_method('GetHopCount',

   411                    'uint8_t',

   412                    [],

   413                    is_const=True)

   414     ## olsr-header.h: ns3::TypeId ns3::olsr::MessageHeader::GetInstanceTypeId() const [member function]

   415     cls.add_method('GetInstanceTypeId',

   416                    'ns3::TypeId',

   417                    [],

   418                    is_const=True, is_virtual=True)

   419     ## olsr-header.h: uint16_t ns3::olsr::MessageHeader::GetMessageSequenceNumber() const [member function]

   420     cls.add_method('GetMessageSequenceNumber',

   421                    'uint16_t',

   422                    [],

   423                    is_const=True)

   424     ## olsr-header.h: ns3::olsr::MessageHeader::MessageType ns3::olsr::MessageHeader::GetMessageType() const [member function]

   425     cls.add_method('GetMessageType',

   426                    'ns3::olsr::MessageHeader::MessageType',

   427                    [],

   428                    is_const=True)

   429     ## olsr-header.h: ns3::olsr::MessageHeader::Mid & ns3::olsr::MessageHeader::GetMid() [member function]

   430     cls.add_method('GetMid',

   431                    'ns3::olsr::MessageHeader::Mid &',

   432                    [])

   433     ## olsr-header.h: ns3::olsr::MessageHeader::Mid const & ns3::olsr::MessageHeader::GetMid() const [member function]

   434     cls.add_method('GetMid',

   435                    'ns3::olsr::MessageHeader::Mid const &',

   436                    [],

   437                    is_const=True)

   438     ## olsr-header.h: ns3::Ipv4Address ns3::olsr::MessageHeader::GetOriginatorAddress() const [member function]

   439     cls.add_method('GetOriginatorAddress',

   440                    'ns3::Ipv4Address',

   441                    [],

   442                    is_const=True)

   443     ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::GetSerializedSize() const [member function]

   444     cls.add_method('GetSerializedSize',

   445                    'uint32_t',

   446                    [],

   447                    is_const=True, is_virtual=True)

   448     ## olsr-header.h: ns3::olsr::MessageHeader::Tc & ns3::olsr::MessageHeader::GetTc() [member function]

   449     cls.add_method('GetTc',

   450                    'ns3::olsr::MessageHeader::Tc &',

   451                    [])

   452     ## olsr-header.h: ns3::olsr::MessageHeader::Tc const & ns3::olsr::MessageHeader::GetTc() const [member function]

   453     cls.add_method('GetTc',

   454                    'ns3::olsr::MessageHeader::Tc const &',

   455                    [],

   456                    is_const=True)

   457     ## olsr-header.h: uint8_t ns3::olsr::MessageHeader::GetTimeToLive() const [member function]

   458     cls.add_method('GetTimeToLive',

   459                    'uint8_t',

   460                    [],

   461                    is_const=True)

   462     ## olsr-header.h: static ns3::TypeId ns3::olsr::MessageHeader::GetTypeId() [member function]

   463     cls.add_method('GetTypeId',

   464                    'ns3::TypeId',

   465                    [],

   466                    is_static=True)

   467     ## olsr-header.h: ns3::Time ns3::olsr::MessageHeader::GetVTime() const [member function]

   468     cls.add_method('GetVTime',

   469                    'ns3::Time',

   470                    [],

   471                    is_const=True)

   472     ## olsr-header.h: void ns3::olsr::MessageHeader::Print(std::ostream & os) const [member function]

   473     cls.add_method('Print',

   474                    'void',

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

   476                    is_const=True, is_virtual=True)

   477     ## olsr-header.h: void ns3::olsr::MessageHeader::Serialize(ns3::Buffer::Iterator start) const [member function]

   478     cls.add_method('Serialize',

   479                    'void',

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

   481                    is_const=True, is_virtual=True)

   482     ## olsr-header.h: void ns3::olsr::MessageHeader::SetHopCount(uint8_t hopCount) [member function]

   483     cls.add_method('SetHopCount',

   484                    'void',

   485                    [param('uint8_t', 'hopCount')])

   486     ## olsr-header.h: void ns3::olsr::MessageHeader::SetMessageSequenceNumber(uint16_t messageSequenceNumber) [member function]

   487     cls.add_method('SetMessageSequenceNumber',

   488                    'void',

   489                    [param('uint16_t', 'messageSequenceNumber')])

   490     ## olsr-header.h: void ns3::olsr::MessageHeader::SetMessageType(ns3::olsr::MessageHeader::MessageType messageType) [member function]

   491     cls.add_method('SetMessageType',

   492                    'void',

   493                    [param('ns3::olsr::MessageHeader::MessageType', 'messageType')])

   494     ## olsr-header.h: void ns3::olsr::MessageHeader::SetOriginatorAddress(ns3::Ipv4Address originatorAddress) [member function]

   495     cls.add_method('SetOriginatorAddress',

   496                    'void',

   497                    [param('ns3::Ipv4Address', 'originatorAddress')])

   498     ## olsr-header.h: void ns3::olsr::MessageHeader::SetTimeToLive(uint8_t timeToLive) [member function]

   499     cls.add_method('SetTimeToLive',

   500                    'void',

   501                    [param('uint8_t', 'timeToLive')])

   502     ## olsr-header.h: void ns3::olsr::MessageHeader::SetVTime(ns3::Time time) [member function]

   503     cls.add_method('SetVTime',

   504                    'void',

   505                    [param('ns3::Time', 'time')])

   506     return

   508 def register_Ns3OlsrMessageHeaderHello_methods(root_module, cls):

   509     ## olsr-header.h: ns3::olsr::MessageHeader::Hello::Hello() [constructor]

   510     cls.add_constructor([])

   511     ## olsr-header.h: ns3::olsr::MessageHeader::Hello::Hello(ns3::olsr::MessageHeader::Hello const & arg0) [copy constructor]

   512     cls.add_constructor([param('ns3::olsr::MessageHeader::Hello const &', 'arg0')])

   513     ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::Hello::Deserialize(ns3::Buffer::Iterator start, uint32_t messageSize) [member function]

   514     cls.add_method('Deserialize',

   515                    'uint32_t',

   516                    [param('ns3::Buffer::Iterator', 'start'), param('uint32_t', 'messageSize')])

   517     ## olsr-header.h: ns3::Time ns3::olsr::MessageHeader::Hello::GetHTime() const [member function]

   518     cls.add_method('GetHTime',

   519                    'ns3::Time',

   520                    [],

   521                    is_const=True)

   522     ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::Hello::GetSerializedSize() const [member function]

   523     cls.add_method('GetSerializedSize',

   524                    'uint32_t',

   525                    [],

   526                    is_const=True)

   527     ## olsr-header.h: void ns3::olsr::MessageHeader::Hello::Print(std::ostream & os) const [member function]

   528     cls.add_method('Print',

   529                    'void',

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

   531                    is_const=True)

   532     ## olsr-header.h: void ns3::olsr::MessageHeader::Hello::Serialize(ns3::Buffer::Iterator start) const [member function]

   533     cls.add_method('Serialize',

   534                    'void',

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

   536                    is_const=True)

   537     ## olsr-header.h: void ns3::olsr::MessageHeader::Hello::SetHTime(ns3::Time time) [member function]

   538     cls.add_method('SetHTime',

   539                    'void',

   540                    [param('ns3::Time', 'time')])

   541     ## olsr-header.h: ns3::olsr::MessageHeader::Hello::hTime [variable]

   542     cls.add_instance_attribute('hTime', 'uint8_t', is_const=False)

   543     ## olsr-header.h: ns3::olsr::MessageHeader::Hello::linkMessages [variable]

   544     cls.add_instance_attribute('linkMessages', 'std::vector< ns3::olsr::MessageHeader::Hello::LinkMessage >', is_const=False)

   545     ## olsr-header.h: ns3::olsr::MessageHeader::Hello::willingness [variable]

   546     cls.add_instance_attribute('willingness', 'uint8_t', is_const=False)

   547     return

   549 def register_Ns3OlsrMessageHeaderHelloLinkMessage_methods(root_module, cls):

   550     ## olsr-header.h: ns3::olsr::MessageHeader::Hello::LinkMessage::linkCode [variable]

   551     cls.add_instance_attribute('linkCode', 'uint8_t', is_const=False)

   552     ## olsr-header.h: ns3::olsr::MessageHeader::Hello::LinkMessage::neighborInterfaceAddresses [variable]

   553     cls.add_instance_attribute('neighborInterfaceAddresses', 'std::vector< ns3::Ipv4Address >', is_const=False)

   554     ## olsr-header.h: ns3::olsr::MessageHeader::Hello::LinkMessage::LinkMessage(ns3::olsr::MessageHeader::Hello::LinkMessage const & arg0) [copy constructor]

   555     cls.add_constructor([param('ns3::olsr::MessageHeader::Hello::LinkMessage const &', 'arg0')])

   556     ## olsr-header.h: ns3::olsr::MessageHeader::Hello::LinkMessage::LinkMessage() [constructor]

   557     cls.add_constructor([])

   558     return

   560 def register_Ns3OlsrMessageHeaderHna_methods(root_module, cls):

   561     ## olsr-header.h: ns3::olsr::MessageHeader::Hna::Hna() [constructor]

   562     cls.add_constructor([])

   563     ## olsr-header.h: ns3::olsr::MessageHeader::Hna::Hna(ns3::olsr::MessageHeader::Hna const & arg0) [copy constructor]

   564     cls.add_constructor([param('ns3::olsr::MessageHeader::Hna const &', 'arg0')])

   565     ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::Hna::Deserialize(ns3::Buffer::Iterator start, uint32_t messageSize) [member function]

   566     cls.add_method('Deserialize',

   567                    'uint32_t',

   568                    [param('ns3::Buffer::Iterator', 'start'), param('uint32_t', 'messageSize')])

   569     ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::Hna::GetSerializedSize() const [member function]

   570     cls.add_method('GetSerializedSize',

   571                    'uint32_t',

   572                    [],

   573                    is_const=True)

   574     ## olsr-header.h: void ns3::olsr::MessageHeader::Hna::Print(std::ostream & os) const [member function]

   575     cls.add_method('Print',

   576                    'void',

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

   578                    is_const=True)

   579     ## olsr-header.h: void ns3::olsr::MessageHeader::Hna::Serialize(ns3::Buffer::Iterator start) const [member function]

   580     cls.add_method('Serialize',

   581                    'void',

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

   583                    is_const=True)

   584     ## olsr-header.h: ns3::olsr::MessageHeader::Hna::associations [variable]

   585     cls.add_instance_attribute('associations', 'std::vector< ns3::olsr::MessageHeader::Hna::Association >', is_const=False)

   586     return

   588 def register_Ns3OlsrMessageHeaderHnaAssociation_methods(root_module, cls):

   589     ## olsr-header.h: ns3::olsr::MessageHeader::Hna::Association::address [variable]

   590     cls.add_instance_attribute('address', 'ns3::Ipv4Address', is_const=False)

   591     ## olsr-header.h: ns3::olsr::MessageHeader::Hna::Association::mask [variable]

   592     cls.add_instance_attribute('mask', 'ns3::Ipv4Mask', is_const=False)

   593     ## olsr-header.h: ns3::olsr::MessageHeader::Hna::Association::Association(ns3::olsr::MessageHeader::Hna::Association const & arg0) [copy constructor]

   594     cls.add_constructor([param('ns3::olsr::MessageHeader::Hna::Association const &', 'arg0')])

   595     ## olsr-header.h: ns3::olsr::MessageHeader::Hna::Association::Association() [constructor]

   596     cls.add_constructor([])

   597     return

   599 def register_Ns3OlsrMessageHeaderMid_methods(root_module, cls):

   600     ## olsr-header.h: ns3::olsr::MessageHeader::Mid::Mid() [constructor]

   601     cls.add_constructor([])

   602     ## olsr-header.h: ns3::olsr::MessageHeader::Mid::Mid(ns3::olsr::MessageHeader::Mid const & arg0) [copy constructor]

   603     cls.add_constructor([param('ns3::olsr::MessageHeader::Mid const &', 'arg0')])

   604     ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::Mid::Deserialize(ns3::Buffer::Iterator start, uint32_t messageSize) [member function]

   605     cls.add_method('Deserialize',

   606                    'uint32_t',

   607                    [param('ns3::Buffer::Iterator', 'start'), param('uint32_t', 'messageSize')])

   608     ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::Mid::GetSerializedSize() const [member function]

   609     cls.add_method('GetSerializedSize',

   610                    'uint32_t',

   611                    [],

   612                    is_const=True)

   613     ## olsr-header.h: void ns3::olsr::MessageHeader::Mid::Print(std::ostream & os) const [member function]

   614     cls.add_method('Print',

   615                    'void',

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

   617                    is_const=True)

   618     ## olsr-header.h: void ns3::olsr::MessageHeader::Mid::Serialize(ns3::Buffer::Iterator start) const [member function]

   619     cls.add_method('Serialize',

   620                    'void',

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

   622                    is_const=True)

   623     ## olsr-header.h: ns3::olsr::MessageHeader::Mid::interfaceAddresses [variable]

   624     cls.add_instance_attribute('interfaceAddresses', 'std::vector< ns3::Ipv4Address >', is_const=False)

   625     return

   627 def register_Ns3OlsrMessageHeaderTc_methods(root_module, cls):

   628     ## olsr-header.h: ns3::olsr::MessageHeader::Tc::Tc() [constructor]

   629     cls.add_constructor([])

   630     ## olsr-header.h: ns3::olsr::MessageHeader::Tc::Tc(ns3::olsr::MessageHeader::Tc const & arg0) [copy constructor]

   631     cls.add_constructor([param('ns3::olsr::MessageHeader::Tc const &', 'arg0')])

   632     ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::Tc::Deserialize(ns3::Buffer::Iterator start, uint32_t messageSize) [member function]

   633     cls.add_method('Deserialize',

   634                    'uint32_t',

   635                    [param('ns3::Buffer::Iterator', 'start'), param('uint32_t', 'messageSize')])

   636     ## olsr-header.h: uint32_t ns3::olsr::MessageHeader::Tc::GetSerializedSize() const [member function]

   637     cls.add_method('GetSerializedSize',

   638                    'uint32_t',

   639                    [],

   640                    is_const=True)

   641     ## olsr-header.h: void ns3::olsr::MessageHeader::Tc::Print(std::ostream & os) const [member function]

   642     cls.add_method('Print',

   643                    'void',

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

   645                    is_const=True)

   646     ## olsr-header.h: void ns3::olsr::MessageHeader::Tc::Serialize(ns3::Buffer::Iterator start) const [member function]

   647     cls.add_method('Serialize',

   648                    'void',

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

   650                    is_const=True)

   651     ## olsr-header.h: ns3::olsr::MessageHeader::Tc::ansn [variable]

   652     cls.add_instance_attribute('ansn', 'uint16_t', is_const=False)

   653     ## olsr-header.h: ns3::olsr::MessageHeader::Tc::neighborAddresses [variable]

   654     cls.add_instance_attribute('neighborAddresses', 'std::vector< ns3::Ipv4Address >', is_const=False)

   655     return

   657 def register_Ns3OlsrMprSelectorTuple_methods(root_module, cls):

   658     cls.add_binary_comparison_operator('==')

   659     ## olsr-repositories.h: ns3::olsr::MprSelectorTuple::MprSelectorTuple() [constructor]

   660     cls.add_constructor([])

   661     ## olsr-repositories.h: ns3::olsr::MprSelectorTuple::MprSelectorTuple(ns3::olsr::MprSelectorTuple const & arg0) [copy constructor]

   662     cls.add_constructor([param('ns3::olsr::MprSelectorTuple const &', 'arg0')])

   663     ## olsr-repositories.h: ns3::olsr::MprSelectorTuple::expirationTime [variable]

   664     cls.add_instance_attribute('expirationTime', 'ns3::Time', is_const=False)

   665     ## olsr-repositories.h: ns3::olsr::MprSelectorTuple::mainAddr [variable]

   666     cls.add_instance_attribute('mainAddr', 'ns3::Ipv4Address', is_const=False)

   667     return

   669 def register_Ns3OlsrNeighborTuple_methods(root_module, cls):

   670     cls.add_output_stream_operator()

   671     cls.add_binary_comparison_operator('==')

   672     ## olsr-repositories.h: ns3::olsr::NeighborTuple::NeighborTuple() [constructor]

   673     cls.add_constructor([])

   674     ## olsr-repositories.h: ns3::olsr::NeighborTuple::NeighborTuple(ns3::olsr::NeighborTuple const & arg0) [copy constructor]

   675     cls.add_constructor([param('ns3::olsr::NeighborTuple const &', 'arg0')])

   676     ## olsr-repositories.h: ns3::olsr::NeighborTuple::neighborMainAddr [variable]

   677     cls.add_instance_attribute('neighborMainAddr', 'ns3::Ipv4Address', is_const=False)

   678     ## olsr-repositories.h: ns3::olsr::NeighborTuple::status [variable]

   679     cls.add_instance_attribute('status', 'ns3::olsr::NeighborTuple::Status', is_const=False)

   680     ## olsr-repositories.h: ns3::olsr::NeighborTuple::willingness [variable]

   681     cls.add_instance_attribute('willingness', 'uint8_t', is_const=False)

   682     return

   684 def register_Ns3OlsrPacketHeader_methods(root_module, cls):

   685     cls.add_output_stream_operator()

   686     ## olsr-header.h: ns3::olsr::PacketHeader::PacketHeader(ns3::olsr::PacketHeader const & arg0) [copy constructor]

   687     cls.add_constructor([param('ns3::olsr::PacketHeader const &', 'arg0')])

   688     ## olsr-header.h: ns3::olsr::PacketHeader::PacketHeader() [constructor]

   689     cls.add_constructor([])

   690     ## olsr-header.h: uint32_t ns3::olsr::PacketHeader::Deserialize(ns3::Buffer::Iterator start) [member function]

   691     cls.add_method('Deserialize',

   692                    'uint32_t',

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

   694                    is_virtual=True)

   695     ## olsr-header.h: ns3::TypeId ns3::olsr::PacketHeader::GetInstanceTypeId() const [member function]

   696     cls.add_method('GetInstanceTypeId',

   697                    'ns3::TypeId',

   698                    [],

   699                    is_const=True, is_virtual=True)

   700     ## olsr-header.h: uint16_t ns3::olsr::PacketHeader::GetPacketLength() const [member function]

   701     cls.add_method('GetPacketLength',

   702                    'uint16_t',

   703                    [],

   704                    is_const=True)

   705     ## olsr-header.h: uint16_t ns3::olsr::PacketHeader::GetPacketSequenceNumber() const [member function]

   706     cls.add_method('GetPacketSequenceNumber',

   707                    'uint16_t',

   708                    [],

   709                    is_const=True)

   710     ## olsr-header.h: uint32_t ns3::olsr::PacketHeader::GetSerializedSize() const [member function]

   711     cls.add_method('GetSerializedSize',

   712                    'uint32_t',

   713                    [],

   714                    is_const=True, is_virtual=True)

   715     ## olsr-header.h: static ns3::TypeId ns3::olsr::PacketHeader::GetTypeId() [member function]

   716     cls.add_method('GetTypeId',

   717                    'ns3::TypeId',

   718                    [],

   719                    is_static=True)

   720     ## olsr-header.h: void ns3::olsr::PacketHeader::Print(std::ostream & os) const [member function]

   721     cls.add_method('Print',

   722                    'void',

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

   724                    is_const=True, is_virtual=True)

   725     ## olsr-header.h: void ns3::olsr::PacketHeader::Serialize(ns3::Buffer::Iterator start) const [member function]

   726     cls.add_method('Serialize',

   727                    'void',

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

   729                    is_const=True, is_virtual=True)

   730     ## olsr-header.h: void ns3::olsr::PacketHeader::SetPacketLength(uint16_t length) [member function]

   731     cls.add_method('SetPacketLength',

   732                    'void',

   733                    [param('uint16_t', 'length')])

   734     ## olsr-header.h: void ns3::olsr::PacketHeader::SetPacketSequenceNumber(uint16_t seqnum) [member function]

   735     cls.add_method('SetPacketSequenceNumber',

   736                    'void',

   737                    [param('uint16_t', 'seqnum')])

   738     return

   740 def register_Ns3OlsrRoutingProtocol_methods(root_module, cls):

   741     ## olsr-routing-protocol.h: ns3::olsr::RoutingProtocol::RoutingProtocol(ns3::olsr::RoutingProtocol const & arg0) [copy constructor]

   742     cls.add_constructor([param('ns3::olsr::RoutingProtocol const &', 'arg0')])

   743     ## olsr-routing-protocol.h: static ns3::TypeId ns3::olsr::RoutingProtocol::GetTypeId() [member function]

   744     cls.add_method('GetTypeId',

   745                    'ns3::TypeId',

   746                    [],

   747                    is_static=True)

   748     ## olsr-routing-protocol.h: ns3::olsr::RoutingProtocol::RoutingProtocol() [constructor]

   749     cls.add_constructor([])

   750     ## olsr-routing-protocol.h: void ns3::olsr::RoutingProtocol::SetMainInterface(uint32_t interface) [member function]

   751     cls.add_method('SetMainInterface',

   752                    'void',

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

   754     ## olsr-routing-protocol.h: ns3::Ptr<ns3::Ipv4Route> ns3::olsr::RoutingProtocol::RouteOutput(ns3::Ptr<ns3::Packet> p, ns3::Ipv4Header const & header, uint32_t oif, ns3::Socket::SocketErrno & sockerr) [member function]

   755     cls.add_method('RouteOutput',

   756                    'ns3::Ptr< ns3::Ipv4Route >',

   757                    [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('uint32_t', 'oif'), param('ns3::Socket::SocketErrno &', 'sockerr')],

   758                    visibility='private', is_virtual=True)

   759     ## olsr-routing-protocol.h: bool ns3::olsr::RoutingProtocol::RouteInput(ns3::Ptr<ns3::Packet const> p, ns3::Ipv4Header const & header, ns3::Ptr<const ns3::NetDevice> idev, ns3::Callback<void,ns3::Ptr<ns3::Ipv4Route>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ucb, ns3::Callback<void,ns3::Ptr<ns3::Ipv4MulticastRoute>,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> mcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,unsigned int,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> lcb, ns3::Callback<void,ns3::Ptr<const ns3::Packet>,const ns3::Ipv4Header&,ns3::Socket::SocketErrno,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ecb) [member function]

   760     cls.add_method('RouteInput',

   761                    'bool',

   762                    [param('ns3::Ptr< ns3::Packet const >', 'p'), param('ns3::Ipv4Header const &', 'header'), param('ns3::Ptr< ns3::NetDevice const >', 'idev'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv4Route >, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ucb'), param('ns3::Callback< void, ns3::Ptr< ns3::Ipv4MulticastRoute >, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'mcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'lcb'), param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::Ipv4Header const &, ns3::Socket::SocketErrno, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ecb')],

   763                    visibility='private', is_virtual=True)

   764     ## olsr-routing-protocol.h: void ns3::olsr::RoutingProtocol::NotifyInterfaceUp(uint32_t interface) [member function]

   765     cls.add_method('NotifyInterfaceUp',

   766                    'void',

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

   768                    visibility='private', is_virtual=True)

   769     ## olsr-routing-protocol.h: void ns3::olsr::RoutingProtocol::NotifyInterfaceDown(uint32_t interface) [member function]

   770     cls.add_method('NotifyInterfaceDown',

   771                    'void',

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

   773                    visibility='private', is_virtual=True)

   774     ## olsr-routing-protocol.h: void ns3::olsr::RoutingProtocol::NotifyAddAddress(uint32_t interface, ns3::Ipv4InterfaceAddress address) [member function]

   775     cls.add_method('NotifyAddAddress',

   776                    'void',

   777                    [param('uint32_t', 'interface'), param('ns3::Ipv4InterfaceAddress', 'address')],

   778                    visibility='private', is_virtual=True)

   779     ## olsr-routing-protocol.h: void ns3::olsr::RoutingProtocol::NotifyRemoveAddress(uint32_t interface, ns3::Ipv4InterfaceAddress address) [member function]

   780     cls.add_method('NotifyRemoveAddress',

   781                    'void',

   782                    [param('uint32_t', 'interface'), param('ns3::Ipv4InterfaceAddress', 'address')],

   783                    visibility='private', is_virtual=True)

   784     ## olsr-routing-protocol.h: void ns3::olsr::RoutingProtocol::SetIpv4(ns3::Ptr<ns3::Ipv4> ipv4) [member function]

   785     cls.add_method('SetIpv4',

   786                    'void',

   787                    [param('ns3::Ptr< ns3::Ipv4 >', 'ipv4')],

   788                    visibility='private', is_virtual=True)

   789     ## olsr-routing-protocol.h: void ns3::olsr::RoutingProtocol::DoDispose() [member function]

   790     cls.add_method('DoDispose',

   791                    'void',

   792                    [],

   793                    visibility='private', is_virtual=True)

   794     return

   796 def register_Ns3OlsrRoutingTableEntry_methods(root_module, cls):

   797     ## olsr-routing-protocol.h: ns3::olsr::RoutingTableEntry::destAddr [variable]

   798     cls.add_instance_attribute('destAddr', 'ns3::Ipv4Address', is_const=False)

   799     ## olsr-routing-protocol.h: ns3::olsr::RoutingTableEntry::nextAddr [variable]

   800     cls.add_instance_attribute('nextAddr', 'ns3::Ipv4Address', is_const=False)

   801     ## olsr-routing-protocol.h: ns3::olsr::RoutingTableEntry::interface [variable]

   802     cls.add_instance_attribute('interface', 'uint32_t', is_const=False)

   803     ## olsr-routing-protocol.h: ns3::olsr::RoutingTableEntry::distance [variable]

   804     cls.add_instance_attribute('distance', 'uint32_t', is_const=False)

   805     ## olsr-routing-protocol.h: ns3::olsr::RoutingTableEntry::RoutingTableEntry(ns3::olsr::RoutingTableEntry const & arg0) [copy constructor]

   806     cls.add_constructor([param('ns3::olsr::RoutingTableEntry const &', 'arg0')])

   807     ## olsr-routing-protocol.h: ns3::olsr::RoutingTableEntry::RoutingTableEntry() [constructor]

   808     cls.add_constructor([])

   809     return

   811 def register_Ns3OlsrTopologyTuple_methods(root_module, cls):

   812     cls.add_output_stream_operator()

   813     cls.add_binary_comparison_operator('==')

   814     ## olsr-repositories.h: ns3::olsr::TopologyTuple::TopologyTuple() [constructor]

   815     cls.add_constructor([])

   816     ## olsr-repositories.h: ns3::olsr::TopologyTuple::TopologyTuple(ns3::olsr::TopologyTuple const & arg0) [copy constructor]

   817     cls.add_constructor([param('ns3::olsr::TopologyTuple const &', 'arg0')])

   818     ## olsr-repositories.h: ns3::olsr::TopologyTuple::destAddr [variable]

   819     cls.add_instance_attribute('destAddr', 'ns3::Ipv4Address', is_const=False)

   820     ## olsr-repositories.h: ns3::olsr::TopologyTuple::expirationTime [variable]

   821     cls.add_instance_attribute('expirationTime', 'ns3::Time', is_const=False)

   822     ## olsr-repositories.h: ns3::olsr::TopologyTuple::lastAddr [variable]

   823     cls.add_instance_attribute('lastAddr', 'ns3::Ipv4Address', is_const=False)

   824     ## olsr-repositories.h: ns3::olsr::TopologyTuple::sequenceNumber [variable]

   825     cls.add_instance_attribute('sequenceNumber', 'uint16_t', is_const=False)

   826     return

   828 def register_Ns3OlsrTwoHopNeighborTuple_methods(root_module, cls):

   829     cls.add_output_stream_operator()

   830     cls.add_binary_comparison_operator('==')

   831     ## olsr-repositories.h: ns3::olsr::TwoHopNeighborTuple::TwoHopNeighborTuple() [constructor]

   832     cls.add_constructor([])

   833     ## olsr-repositories.h: ns3::olsr::TwoHopNeighborTuple::TwoHopNeighborTuple(ns3::olsr::TwoHopNeighborTuple const & arg0) [copy constructor]

   834     cls.add_constructor([param('ns3::olsr::TwoHopNeighborTuple const &', 'arg0')])

   835     ## olsr-repositories.h: ns3::olsr::TwoHopNeighborTuple::expirationTime [variable]

   836     cls.add_instance_attribute('expirationTime', 'ns3::Time', is_const=False)

   837     ## olsr-repositories.h: ns3::olsr::TwoHopNeighborTuple::neighborMainAddr [variable]

   838     cls.add_instance_attribute('neighborMainAddr', 'ns3::Ipv4Address', is_const=False)

   839     ## olsr-repositories.h: ns3::olsr::TwoHopNeighborTuple::twoHopNeighborAddr [variable]

   840     cls.add_instance_attribute('twoHopNeighborAddr', 'ns3::Ipv4Address', is_const=False)

   841     return

   843 def register_functions(root_module):

   844     module = root_module

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

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

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

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

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

   850     return

   852 def register_functions_ns3_Config(module, root_module):

   853     return

   855 def register_functions_ns3_TimeStepPrecision(module, root_module):

   856     return

   858 def register_functions_ns3_addressUtils(module, root_module):

   859     return

   861 def register_functions_ns3_internal(module, root_module):

   862     return

   864 def register_functions_ns3_olsr(module, root_module):

   865     ## olsr-header.h: extern double ns3::olsr::EmfToSeconds(uint8_t emf) [free function]

   866     module.add_function('EmfToSeconds',

   867                         'double',

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

   869     ## olsr-header.h: extern uint8_t ns3::olsr::SecondsToEmf(double seconds) [free function]

   870     module.add_function('SecondsToEmf',

   871                         'uint8_t',

   872                         [param('double', 'seconds')])

   873     return

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