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

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

     3 def register_types(module):

     4     root_module = module.get_root()

     6     ## event-id.h: ns3::EventId [class]

     7     module.add_class('EventId')

     8     ## event-impl.h: ns3::EventImpl [class]

     9     module.add_class('EventImpl', allow_subclassing=True)

    10     ## high-precision-128.h: ns3::HighPrecision [class]

    11     module.add_class('HighPrecision')

    12     ## simulator.h: ns3::Simulator [class]

    13     module.add_class('Simulator', is_singleton=True)

    14     ## nstime.h: ns3::TimeUnit<-1> [class]

    15     module.add_class('TimeInvert')

    16     ## nstime.h: ns3::TimeUnit<0> [class]

    17     module.add_class('Scalar')

    18     ## nstime.h: ns3::TimeUnit<1> [class]

    19     module.add_class('Time')

    20     ## nstime.h: ns3::TimeUnit<2> [class]

    21     module.add_class('TimeSquare')

    22     ## timer.h: ns3::Timer [class]

    23     module.add_class('Timer')

    24     ## timer.h: ns3::Timer::DestroyPolicy [enumeration]

    25     module.add_enum('DestroyPolicy', ['CANCEL_ON_DESTROY', 'REMOVE_ON_DESTROY', 'CHECK_ON_DESTROY'], outer_class=root_module['ns3::Timer'])

    26     ## timer.h: ns3::Timer::State [enumeration]

    27     module.add_enum('State', ['RUNNING', 'EXPIRED', 'SUSPENDED'], outer_class=root_module['ns3::Timer'])

    28     ## timer-impl.h: ns3::TimerImpl [class]

    29     module.add_class('TimerImpl', allow_subclassing=True)

    30     ## watchdog.h: ns3::Watchdog [class]

    31     module.add_class('Watchdog')

    32     ## scheduler.h: ns3::Scheduler [class]

    33     module.add_class('Scheduler', parent=root_module['ns3::Object'])

    34     ## scheduler.h: ns3::Scheduler::Event [struct]

    35     module.add_class('Event', outer_class=root_module['ns3::Scheduler'])

    36     ## scheduler.h: ns3::Scheduler::EventKey [struct]

    37     module.add_class('EventKey', outer_class=root_module['ns3::Scheduler'])

    38     ## simulator-impl.h: ns3::SimulatorImpl [class]

    39     module.add_class('SimulatorImpl', parent=root_module['ns3::Object'])

    40     ## synchronizer.h: ns3::Synchronizer [class]

    41     module.add_class('Synchronizer', parent=root_module['ns3::Object'])

    42     ## nstime.h: ns3::TimeChecker [class]

    43     module.add_class('TimeChecker', parent=root_module['ns3::AttributeChecker'])

    44     ## nstime.h: ns3::TimeValue [class]

    45     module.add_class('TimeValue', parent=root_module['ns3::AttributeValue'])

    46     ## wall-clock-synchronizer.h: ns3::WallClockSynchronizer [class]

    47     module.add_class('WallClockSynchronizer', parent=root_module['ns3::Synchronizer'])

    48     ## calendar-scheduler.h: ns3::CalendarScheduler [class]

    49     module.add_class('CalendarScheduler', parent=root_module['ns3::Scheduler'])

    50     ## default-simulator-impl.h: ns3::DefaultSimulatorImpl [class]

    51     module.add_class('DefaultSimulatorImpl', parent=root_module['ns3::SimulatorImpl'])

    52     ## heap-scheduler.h: ns3::HeapScheduler [class]

    53     module.add_class('HeapScheduler', parent=root_module['ns3::Scheduler'])

    54     ## list-scheduler.h: ns3::ListScheduler [class]

    55     module.add_class('ListScheduler', parent=root_module['ns3::Scheduler'])

    56     ## map-scheduler.h: ns3::MapScheduler [class]

    57     module.add_class('MapScheduler', parent=root_module['ns3::Scheduler'])

    58     ## ns2-calendar-scheduler.h: ns3::Ns2CalendarScheduler [class]

    59     module.add_class('Ns2CalendarScheduler', parent=root_module['ns3::Scheduler'])

    60     ## realtime-simulator-impl.h: ns3::RealtimeSimulatorImpl [class]

    61     module.add_class('RealtimeSimulatorImpl', parent=root_module['ns3::SimulatorImpl'])

    62     ## realtime-simulator-impl.h: ns3::RealtimeSimulatorImpl::SynchronizationMode [enumeration]

    63     module.add_enum('SynchronizationMode', ['SYNC_BEST_EFFORT', 'SYNC_HARD_LIMIT'], outer_class=root_module['ns3::RealtimeSimulatorImpl'])

    64     typehandlers.add_type_alias('ns3::TimeUnit< 2 >', 'ns3::TimeSquare')

    65     typehandlers.add_type_alias('ns3::TimeUnit< - 1 >', 'ns3::TimeInvert')

    66     typehandlers.add_type_alias('ns3::TimeUnit< 0 >', 'ns3::Scalar')

    67     typehandlers.add_type_alias('ns3::TimeUnit< 1 >', 'ns3::Time')

    69     ## Register a nested module for the namespace Config

    71     nested_module = module.add_cpp_namespace('Config')

    72     register_types_ns3_Config(nested_module)

    75     ## Register a nested module for the namespace TimeStepPrecision

    77     nested_module = module.add_cpp_namespace('TimeStepPrecision')

    78     register_types_ns3_TimeStepPrecision(nested_module)

    81     ## Register a nested module for the namespace addressUtils

    83     nested_module = module.add_cpp_namespace('addressUtils')

    84     register_types_ns3_addressUtils(nested_module)

    87     ## Register a nested module for the namespace internal

    89     nested_module = module.add_cpp_namespace('internal')

    90     register_types_ns3_internal(nested_module)

    93     ## Register a nested module for the namespace olsr

    95     nested_module = module.add_cpp_namespace('olsr')

    96     register_types_ns3_olsr(nested_module)

    99 def register_types_ns3_Config(module):

   100     root_module = module.get_root()

   103 def register_types_ns3_TimeStepPrecision(module):

   104     root_module = module.get_root()

   106     ## nstime.h: ns3::TimeStepPrecision::precision_t [enumeration]

   107     module.add_enum('precision_t', ['S', 'MS', 'US', 'NS', 'PS', 'FS'])

   109 def register_types_ns3_addressUtils(module):

   110     root_module = module.get_root()

   113 def register_types_ns3_internal(module):

   114     root_module = module.get_root()

   117 def register_types_ns3_olsr(module):

   118     root_module = module.get_root()

   121 def register_methods(root_module):

   122     register_Ns3EventId_methods(root_module, root_module['ns3::EventId'])

   123     register_Ns3EventImpl_methods(root_module, root_module['ns3::EventImpl'])

   124     register_Ns3HighPrecision_methods(root_module, root_module['ns3::HighPrecision'])

   125     register_Ns3Simulator_methods(root_module, root_module['ns3::Simulator'])

   126     register_Ns3TimeInvert_methods(root_module, root_module['ns3::TimeInvert'])

   127     register_Ns3Scalar_methods(root_module, root_module['ns3::Scalar'])

   128     register_Ns3Time_methods(root_module, root_module['ns3::Time'])

   129     register_Ns3TimeSquare_methods(root_module, root_module['ns3::TimeSquare'])

   130     register_Ns3Timer_methods(root_module, root_module['ns3::Timer'])

   131     register_Ns3TimerImpl_methods(root_module, root_module['ns3::TimerImpl'])

   132     register_Ns3Watchdog_methods(root_module, root_module['ns3::Watchdog'])

   133     register_Ns3Scheduler_methods(root_module, root_module['ns3::Scheduler'])

   134     register_Ns3SchedulerEvent_methods(root_module, root_module['ns3::Scheduler::Event'])

   135     register_Ns3SchedulerEventKey_methods(root_module, root_module['ns3::Scheduler::EventKey'])

   136     register_Ns3SimulatorImpl_methods(root_module, root_module['ns3::SimulatorImpl'])

   137     register_Ns3Synchronizer_methods(root_module, root_module['ns3::Synchronizer'])

   138     register_Ns3TimeChecker_methods(root_module, root_module['ns3::TimeChecker'])

   139     register_Ns3TimeValue_methods(root_module, root_module['ns3::TimeValue'])

   140     register_Ns3WallClockSynchronizer_methods(root_module, root_module['ns3::WallClockSynchronizer'])

   141     register_Ns3CalendarScheduler_methods(root_module, root_module['ns3::CalendarScheduler'])

   142     register_Ns3DefaultSimulatorImpl_methods(root_module, root_module['ns3::DefaultSimulatorImpl'])

   143     register_Ns3HeapScheduler_methods(root_module, root_module['ns3::HeapScheduler'])

   144     register_Ns3ListScheduler_methods(root_module, root_module['ns3::ListScheduler'])

   145     register_Ns3MapScheduler_methods(root_module, root_module['ns3::MapScheduler'])

   146     register_Ns3Ns2CalendarScheduler_methods(root_module, root_module['ns3::Ns2CalendarScheduler'])

   147     register_Ns3RealtimeSimulatorImpl_methods(root_module, root_module['ns3::RealtimeSimulatorImpl'])

   148     return

   150 def register_Ns3EventId_methods(root_module, cls):

   151     cls.add_binary_comparison_operator('!=')

   152     cls.add_binary_comparison_operator('==')

   153     ## event-id.h: ns3::EventId::EventId(ns3::EventId const & arg0) [copy constructor]

   154     cls.add_constructor([param('ns3::EventId const &', 'arg0')])

   155     ## event-id.h: ns3::EventId::EventId() [constructor]

   156     cls.add_constructor([])

   157     ## event-id.h: ns3::EventId::EventId(ns3::Ptr<ns3::EventImpl> const & impl, uint64_t ts, uint32_t uid) [constructor]

   158     cls.add_constructor([param('ns3::Ptr< ns3::EventImpl > const &', 'impl'), param('uint64_t', 'ts'), param('uint32_t', 'uid')])

   159     ## event-id.h: void ns3::EventId::Cancel() [member function]

   160     cls.add_method('Cancel',

   161                    'void',

   162                    [])

   163     ## event-id.h: uint64_t ns3::EventId::GetTs() const [member function]

   164     cls.add_method('GetTs',

   165                    'uint64_t',

   166                    [],

   167                    is_const=True)

   168     ## event-id.h: uint32_t ns3::EventId::GetUid() const [member function]

   169     cls.add_method('GetUid',

   170                    'uint32_t',

   171                    [],

   172                    is_const=True)

   173     ## event-id.h: bool ns3::EventId::IsExpired() const [member function]

   174     cls.add_method('IsExpired',

   175                    'bool',

   176                    [],

   177                    is_const=True)

   178     ## event-id.h: bool ns3::EventId::IsRunning() const [member function]

   179     cls.add_method('IsRunning',

   180                    'bool',

   181                    [],

   182                    is_const=True)

   183     ## event-id.h: ns3::EventImpl * ns3::EventId::PeekEventImpl() const [member function]

   184     cls.add_method('PeekEventImpl',

   185                    'ns3::EventImpl *',

   186                    [],

   187                    is_const=True)

   188     return

   190 def register_Ns3EventImpl_methods(root_module, cls):

   191     ## event-impl.h: ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [copy constructor]

   192     cls.add_constructor([param('ns3::EventImpl const &', 'arg0')])

   193     ## event-impl.h: ns3::EventImpl::EventImpl() [constructor]

   194     cls.add_constructor([])

   195     ## event-impl.h: void ns3::EventImpl::Ref() const [member function]

   196     cls.add_method('Ref',

   197                    'void',

   198                    [],

   199                    is_const=True)

   200     ## event-impl.h: void ns3::EventImpl::Unref() const [member function]

   201     cls.add_method('Unref',

   202                    'void',

   203                    [],

   204                    is_const=True)

   205     ## event-impl.h: void ns3::EventImpl::Invoke() [member function]

   206     cls.add_method('Invoke',

   207                    'void',

   208                    [])

   209     ## event-impl.h: void ns3::EventImpl::Cancel() [member function]

   210     cls.add_method('Cancel',

   211                    'void',

   212                    [])

   213     ## event-impl.h: bool ns3::EventImpl::IsCancelled() [member function]

   214     cls.add_method('IsCancelled',

   215                    'bool',

   216                    [])

   217     ## event-impl.h: void ns3::EventImpl::Notify() [member function]

   218     cls.add_method('Notify',

   219                    'void',

   220                    [],

   221                    is_pure_virtual=True, visibility='protected', is_virtual=True)

   222     return

   224 def register_Ns3HighPrecision_methods(root_module, cls):

   225     ## high-precision-128.h: ns3::HighPrecision::HighPrecision(ns3::HighPrecision const & arg0) [copy constructor]

   226     cls.add_constructor([param('ns3::HighPrecision const &', 'arg0')])

   227     ## high-precision-128.h: ns3::HighPrecision::HighPrecision() [constructor]

   228     cls.add_constructor([])

   229     ## high-precision-128.h: ns3::HighPrecision::HighPrecision(int64_t value, bool dummy) [constructor]

   230     cls.add_constructor([param('int64_t', 'value'), param('bool', 'dummy')])

   231     ## high-precision-128.h: ns3::HighPrecision::HighPrecision(double value) [constructor]

   232     cls.add_constructor([param('double', 'value')])

   233     ## high-precision-128.h: static void ns3::HighPrecision::PrintStats() [member function]

   234     cls.add_method('PrintStats',

   235                    'void',

   236                    [],

   237                    is_static=True)

   238     ## high-precision-128.h: int64_t ns3::HighPrecision::GetInteger() const [member function]

   239     cls.add_method('GetInteger',

   240                    'int64_t',

   241                    [],

   242                    is_const=True)

   243     ## high-precision-128.h: double ns3::HighPrecision::GetDouble() const [member function]

   244     cls.add_method('GetDouble',

   245                    'double',

   246                    [],

   247                    is_const=True)

   248     ## high-precision-128.h: bool ns3::HighPrecision::Add(ns3::HighPrecision const & o) [member function]

   249     cls.add_method('Add',

   250                    'bool',

   251                    [param('ns3::HighPrecision const &', 'o')])

   252     ## high-precision-128.h: bool ns3::HighPrecision::Sub(ns3::HighPrecision const & o) [member function]

   253     cls.add_method('Sub',

   254                    'bool',

   255                    [param('ns3::HighPrecision const &', 'o')])

   256     ## high-precision-128.h: bool ns3::HighPrecision::Mul(ns3::HighPrecision const & o) [member function]

   257     cls.add_method('Mul',

   258                    'bool',

   259                    [param('ns3::HighPrecision const &', 'o')])

   260     ## high-precision-128.h: bool ns3::HighPrecision::Div(ns3::HighPrecision const & o) [member function]

   261     cls.add_method('Div',

   262                    'bool',

   263                    [param('ns3::HighPrecision const &', 'o')])

   264     ## high-precision-128.h: int ns3::HighPrecision::Compare(ns3::HighPrecision const & o) const [member function]

   265     cls.add_method('Compare',

   266                    'int',

   267                    [param('ns3::HighPrecision const &', 'o')],

   268                    is_const=True)

   269     ## high-precision-128.h: static ns3::HighPrecision ns3::HighPrecision::Zero() [member function]

   270     cls.add_method('Zero',

   271                    'ns3::HighPrecision',

   272                    [],

   273                    is_static=True)

   274     return

   276 def register_Ns3Simulator_methods(root_module, cls):

   277     ## simulator.h: ns3::Simulator::Simulator(ns3::Simulator const & arg0) [copy constructor]

   278     cls.add_constructor([param('ns3::Simulator const &', 'arg0')])

   279     ## simulator.h: static void ns3::Simulator::SetImplementation(ns3::Ptr<ns3::SimulatorImpl> impl) [member function]

   280     cls.add_method('SetImplementation',

   281                    'void',

   282                    [param('ns3::Ptr< ns3::SimulatorImpl >', 'impl')],

   283                    is_static=True)

   284     ## simulator.h: static ns3::Ptr<ns3::SimulatorImpl> ns3::Simulator::GetImplementation() [member function]

   285     cls.add_method('GetImplementation',

   286                    'ns3::Ptr< ns3::SimulatorImpl >',

   287                    [],

   288                    is_static=True)

   289     ## simulator.h: static void ns3::Simulator::SetScheduler(ns3::Ptr<ns3::Scheduler> scheduler) [member function]

   290     cls.add_method('SetScheduler',

   291                    'void',

   292                    [param('ns3::Ptr< ns3::Scheduler >', 'scheduler')],

   293                    is_static=True)

   294     ## simulator.h: static void ns3::Simulator::Destroy() [member function]

   295     cls.add_method('Destroy',

   296                    'void',

   297                    [],

   298                    is_static=True)

   299     ## simulator.h: static bool ns3::Simulator::IsFinished() [member function]

   300     cls.add_method('IsFinished',

   301                    'bool',

   302                    [],

   303                    is_static=True)

   304     ## simulator.h: static ns3::Time ns3::Simulator::Next() [member function]

   305     cls.add_method('Next',

   306                    'ns3::Time',

   307                    [],

   308                    is_static=True)

   309     ## simulator.h: static void ns3::Simulator::RunOneEvent() [member function]

   310     cls.add_method('RunOneEvent',

   311                    'void',

   312                    [],

   313                    is_static=True)

   314     ## simulator.h: static void ns3::Simulator::Stop() [member function]

   315     cls.add_method('Stop',

   316                    'void',

   317                    [],

   318                    is_static=True)

   319     ## simulator.h: static void ns3::Simulator::Stop(ns3::Time const & time) [member function]

   320     cls.add_method('Stop',

   321                    'void',

   322                    [param('ns3::Time const &', 'time')],

   323                    is_static=True)

   324     ## simulator.h: static void ns3::Simulator::Remove(ns3::EventId const & id) [member function]

   325     cls.add_method('Remove',

   326                    'void',

   327                    [param('ns3::EventId const &', 'id')],

   328                    is_static=True)

   329     ## simulator.h: static void ns3::Simulator::Cancel(ns3::EventId const & id) [member function]

   330     cls.add_method('Cancel',

   331                    'void',

   332                    [param('ns3::EventId const &', 'id')],

   333                    is_static=True)

   334     ## simulator.h: static bool ns3::Simulator::IsExpired(ns3::EventId const & id) [member function]

   335     cls.add_method('IsExpired',

   336                    'bool',

   337                    [param('ns3::EventId const &', 'id')],

   338                    is_static=True)

   339     ## simulator.h: static ns3::Time ns3::Simulator::Now() [member function]

   340     cls.add_method('Now',

   341                    'ns3::Time',

   342                    [],

   343                    is_static=True)

   344     ## simulator.h: static ns3::Time ns3::Simulator::GetDelayLeft(ns3::EventId const & id) [member function]

   345     cls.add_method('GetDelayLeft',

   346                    'ns3::Time',

   347                    [param('ns3::EventId const &', 'id')],

   348                    is_static=True)

   349     ## simulator.h: static ns3::Time ns3::Simulator::GetMaximumSimulationTime() [member function]

   350     cls.add_method('GetMaximumSimulationTime',

   351                    'ns3::Time',

   352                    [],

   353                    is_static=True)

   354     return

   356 def register_Ns3TimeInvert_methods(root_module, cls):

   357     ## nstime.h: ns3::TimeUnit<-1>::TimeUnit() [constructor]

   358     cls.add_constructor([])

   359     ## nstime.h: ns3::TimeUnit<-1>::TimeUnit(ns3::TimeUnit<-1> const & o) [copy constructor]

   360     cls.add_constructor([param('ns3::TimeUnit< - 1 > const &', 'o')])

   361     ## nstime.h: ns3::TimeUnit<-1>::TimeUnit(ns3::HighPrecision data) [constructor]

   362     cls.add_constructor([param('ns3::HighPrecision', 'data')])

   363     ## nstime.h: ns3::HighPrecision const & ns3::TimeUnit<-1>::GetHighPrecision() const [member function]

   364     cls.add_method('GetHighPrecision',

   365                    'ns3::HighPrecision const &',

   366                    [],

   367                    is_const=True)

   368     ## nstime.h: bool ns3::TimeUnit<-1>::IsNegative() const [member function]

   369     cls.add_method('IsNegative',

   370                    'bool',

   371                    [],

   372                    is_const=True)

   373     ## nstime.h: bool ns3::TimeUnit<-1>::IsPositive() const [member function]

   374     cls.add_method('IsPositive',

   375                    'bool',

   376                    [],

   377                    is_const=True)

   378     ## nstime.h: bool ns3::TimeUnit<-1>::IsStrictlyNegative() const [member function]

   379     cls.add_method('IsStrictlyNegative',

   380                    'bool',

   381                    [],

   382                    is_const=True)

   383     ## nstime.h: bool ns3::TimeUnit<-1>::IsStrictlyPositive() const [member function]

   384     cls.add_method('IsStrictlyPositive',

   385                    'bool',

   386                    [],

   387                    is_const=True)

   388     ## nstime.h: bool ns3::TimeUnit<-1>::IsZero() const [member function]

   389     cls.add_method('IsZero',

   390                    'bool',

   391                    [],

   392                    is_const=True)

   393     ## nstime.h: ns3::HighPrecision * ns3::TimeUnit<-1>::PeekHighPrecision() [member function]

   394     cls.add_method('PeekHighPrecision',

   395                    'ns3::HighPrecision *',

   396                    [])

   397     return

   399 def register_Ns3Scalar_methods(root_module, cls):

   400     cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Scalar'], root_module['ns3::Time'])

   401     cls.add_binary_numeric_operator('/', root_module['ns3::Time'], root_module['ns3::Time'], root_module['ns3::Scalar'])

   402     cls.add_binary_numeric_operator('/', root_module['ns3::TimeInvert'], root_module['ns3::Scalar'], root_module['ns3::Time'])

   403     ## nstime.h: ns3::TimeUnit<0>::TimeUnit(double scalar) [constructor]

   404     cls.add_constructor([param('double', 'scalar')])

   405     ## nstime.h: ns3::TimeUnit<0>::TimeUnit() [constructor]

   406     cls.add_constructor([])

   407     ## nstime.h: ns3::TimeUnit<0>::TimeUnit(ns3::TimeUnit<0> const & o) [copy constructor]

   408     cls.add_constructor([param('ns3::TimeUnit< 0 > const &', 'o')])

   409     ## nstime.h: ns3::TimeUnit<0>::TimeUnit(ns3::HighPrecision data) [constructor]

   410     cls.add_constructor([param('ns3::HighPrecision', 'data')])

   411     ## nstime.h: double ns3::TimeUnit<0>::GetDouble() const [member function]

   412     cls.add_method('GetDouble',

   413                    'double',

   414                    [],

   415                    is_const=True)

   416     ## nstime.h: ns3::HighPrecision const & ns3::TimeUnit<0>::GetHighPrecision() const [member function]

   417     cls.add_method('GetHighPrecision',

   418                    'ns3::HighPrecision const &',

   419                    [],

   420                    is_const=True)

   421     ## nstime.h: bool ns3::TimeUnit<0>::IsNegative() const [member function]

   422     cls.add_method('IsNegative',

   423                    'bool',

   424                    [],

   425                    is_const=True)

   426     ## nstime.h: bool ns3::TimeUnit<0>::IsPositive() const [member function]

   427     cls.add_method('IsPositive',

   428                    'bool',

   429                    [],

   430                    is_const=True)

   431     ## nstime.h: bool ns3::TimeUnit<0>::IsStrictlyNegative() const [member function]

   432     cls.add_method('IsStrictlyNegative',

   433                    'bool',

   434                    [],

   435                    is_const=True)

   436     ## nstime.h: bool ns3::TimeUnit<0>::IsStrictlyPositive() const [member function]

   437     cls.add_method('IsStrictlyPositive',

   438                    'bool',

   439                    [],

   440                    is_const=True)

   441     ## nstime.h: bool ns3::TimeUnit<0>::IsZero() const [member function]

   442     cls.add_method('IsZero',

   443                    'bool',

   444                    [],

   445                    is_const=True)

   446     ## nstime.h: ns3::HighPrecision * ns3::TimeUnit<0>::PeekHighPrecision() [member function]

   447     cls.add_method('PeekHighPrecision',

   448                    'ns3::HighPrecision *',

   449                    [])

   450     return

   452 def register_Ns3Time_methods(root_module, cls):

   453     cls.add_binary_comparison_operator('!=')

   454     cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Scalar'], root_module['ns3::Time'])

   455     cls.add_binary_numeric_operator('*', root_module['ns3::TimeSquare'], root_module['ns3::Time'], root_module['ns3::Time'])

   456     cls.add_binary_numeric_operator('+', root_module['ns3::Time'], root_module['ns3::Time'], root_module['ns3::Time'])

   457     cls.add_binary_numeric_operator('-', root_module['ns3::Time'], root_module['ns3::Time'], root_module['ns3::Time'])

   458     cls.add_binary_numeric_operator('/', root_module['ns3::Time'], root_module['ns3::Time'], root_module['ns3::Scalar'])

   459     cls.add_binary_numeric_operator('/', root_module['ns3::TimeInvert'], root_module['ns3::Scalar'], root_module['ns3::Time'])

   460     cls.add_binary_numeric_operator('/', root_module['ns3::Scalar'], root_module['ns3::Time'], root_module['ns3::Time'])

   461     cls.add_binary_numeric_operator('/', root_module['ns3::Time'], root_module['ns3::TimeSquare'], root_module['ns3::Time'])

   462     cls.add_binary_comparison_operator('<')

   463     cls.add_binary_comparison_operator('>')

   464     cls.add_output_stream_operator()

   465     cls.add_binary_comparison_operator('<=')

   466     cls.add_binary_comparison_operator('==')

   467     cls.add_binary_comparison_operator('>=')

   468     ## nstime.h: ns3::TimeUnit<1>::TimeUnit(std::string const & s) [constructor]

   469     cls.add_constructor([param('std::string const &', 's')])

   470     ## nstime.h: ns3::TimeUnit<1>::TimeUnit() [constructor]

   471     cls.add_constructor([])

   472     ## nstime.h: ns3::TimeUnit<1>::TimeUnit(ns3::TimeUnit<1> const & o) [copy constructor]

   473     cls.add_constructor([param('ns3::TimeUnit< 1 > const &', 'o')])

   474     ## nstime.h: ns3::TimeUnit<1>::TimeUnit(ns3::HighPrecision data) [constructor]

   475     cls.add_constructor([param('ns3::HighPrecision', 'data')])

   476     ## nstime.h: int64_t ns3::TimeUnit<1>::GetFemtoSeconds() const [member function]

   477     cls.add_method('GetFemtoSeconds',

   478                    'int64_t',

   479                    [],

   480                    is_const=True)

   481     ## nstime.h: ns3::HighPrecision const & ns3::TimeUnit<1>::GetHighPrecision() const [member function]

   482     cls.add_method('GetHighPrecision',

   483                    'ns3::HighPrecision const &',

   484                    [],

   485                    is_const=True)

   486     ## nstime.h: int64_t ns3::TimeUnit<1>::GetMicroSeconds() const [member function]

   487     cls.add_method('GetMicroSeconds',

   488                    'int64_t',

   489                    [],

   490                    is_const=True)

   491     ## nstime.h: int64_t ns3::TimeUnit<1>::GetMilliSeconds() const [member function]

   492     cls.add_method('GetMilliSeconds',

   493                    'int64_t',

   494                    [],

   495                    is_const=True)

   496     ## nstime.h: int64_t ns3::TimeUnit<1>::GetNanoSeconds() const [member function]

   497     cls.add_method('GetNanoSeconds',

   498                    'int64_t',

   499                    [],

   500                    is_const=True)

   501     ## nstime.h: int64_t ns3::TimeUnit<1>::GetPicoSeconds() const [member function]

   502     cls.add_method('GetPicoSeconds',

   503                    'int64_t',

   504                    [],

   505                    is_const=True)

   506     ## nstime.h: double ns3::TimeUnit<1>::GetSeconds() const [member function]

   507     cls.add_method('GetSeconds',

   508                    'double',

   509                    [],

   510                    is_const=True)

   511     ## nstime.h: int64_t ns3::TimeUnit<1>::GetTimeStep() const [member function]

   512     cls.add_method('GetTimeStep',

   513                    'int64_t',

   514                    [],

   515                    is_const=True)

   516     ## nstime.h: bool ns3::TimeUnit<1>::IsNegative() const [member function]

   517     cls.add_method('IsNegative',

   518                    'bool',

   519                    [],

   520                    is_const=True)

   521     ## nstime.h: bool ns3::TimeUnit<1>::IsPositive() const [member function]

   522     cls.add_method('IsPositive',

   523                    'bool',

   524                    [],

   525                    is_const=True)

   526     ## nstime.h: bool ns3::TimeUnit<1>::IsStrictlyNegative() const [member function]

   527     cls.add_method('IsStrictlyNegative',

   528                    'bool',

   529                    [],

   530                    is_const=True)

   531     ## nstime.h: bool ns3::TimeUnit<1>::IsStrictlyPositive() const [member function]

   532     cls.add_method('IsStrictlyPositive',

   533                    'bool',

   534                    [],

   535                    is_const=True)

   536     ## nstime.h: bool ns3::TimeUnit<1>::IsZero() const [member function]

   537     cls.add_method('IsZero',

   538                    'bool',

   539                    [],

   540                    is_const=True)

   541     ## nstime.h: ns3::HighPrecision * ns3::TimeUnit<1>::PeekHighPrecision() [member function]

   542     cls.add_method('PeekHighPrecision',

   543                    'ns3::HighPrecision *',

   544                    [])

   545     ## nstime.h: static uint64_t ns3::TimeUnit<1>::UnitsToTimestep(uint64_t unitValue, uint64_t unitFactor) [member function]

   546     cls.add_method('UnitsToTimestep',

   547                    'uint64_t',

   548                    [param('uint64_t', 'unitValue'), param('uint64_t', 'unitFactor')],

   549                    is_static=True)

   550     return

   552 def register_Ns3TimeSquare_methods(root_module, cls):

   553     cls.add_binary_numeric_operator('/', root_module['ns3::Time'], root_module['ns3::TimeSquare'], root_module['ns3::Time'])

   554     ## nstime.h: ns3::TimeUnit<2>::TimeUnit() [constructor]

   555     cls.add_constructor([])

   556     ## nstime.h: ns3::TimeUnit<2>::TimeUnit(ns3::TimeUnit<2> const & o) [copy constructor]

   557     cls.add_constructor([param('ns3::TimeUnit< 2 > const &', 'o')])

   558     ## nstime.h: ns3::TimeUnit<2>::TimeUnit(ns3::HighPrecision data) [constructor]

   559     cls.add_constructor([param('ns3::HighPrecision', 'data')])

   560     ## nstime.h: ns3::HighPrecision const & ns3::TimeUnit<2>::GetHighPrecision() const [member function]

   561     cls.add_method('GetHighPrecision',

   562                    'ns3::HighPrecision const &',

   563                    [],

   564                    is_const=True)

   565     ## nstime.h: bool ns3::TimeUnit<2>::IsNegative() const [member function]

   566     cls.add_method('IsNegative',

   567                    'bool',

   568                    [],

   569                    is_const=True)

   570     ## nstime.h: bool ns3::TimeUnit<2>::IsPositive() const [member function]

   571     cls.add_method('IsPositive',

   572                    'bool',

   573                    [],

   574                    is_const=True)

   575     ## nstime.h: bool ns3::TimeUnit<2>::IsStrictlyNegative() const [member function]

   576     cls.add_method('IsStrictlyNegative',

   577                    'bool',

   578                    [],

   579                    is_const=True)

   580     ## nstime.h: bool ns3::TimeUnit<2>::IsStrictlyPositive() const [member function]

   581     cls.add_method('IsStrictlyPositive',

   582                    'bool',

   583                    [],

   584                    is_const=True)

   585     ## nstime.h: bool ns3::TimeUnit<2>::IsZero() const [member function]

   586     cls.add_method('IsZero',

   587                    'bool',

   588                    [],

   589                    is_const=True)

   590     ## nstime.h: ns3::HighPrecision * ns3::TimeUnit<2>::PeekHighPrecision() [member function]

   591     cls.add_method('PeekHighPrecision',

   592                    'ns3::HighPrecision *',

   593                    [])

   594     return

   596 def register_Ns3Timer_methods(root_module, cls):

   597     ## timer.h: ns3::Timer::Timer(ns3::Timer const & arg0) [copy constructor]

   598     cls.add_constructor([param('ns3::Timer const &', 'arg0')])

   599     ## timer.h: ns3::Timer::Timer() [constructor]

   600     cls.add_constructor([])

   601     ## timer.h: ns3::Timer::Timer(ns3::Timer::DestroyPolicy destroyPolicy) [constructor]

   602     cls.add_constructor([param('ns3::Timer::DestroyPolicy', 'destroyPolicy')])

   603     ## timer.h: void ns3::Timer::SetDelay(ns3::Time const & delay) [member function]

   604     cls.add_method('SetDelay',

   605                    'void',

   606                    [param('ns3::Time const &', 'delay')])

   607     ## timer.h: ns3::Time ns3::Timer::GetDelay() const [member function]

   608     cls.add_method('GetDelay',

   609                    'ns3::Time',

   610                    [],

   611                    is_const=True)

   612     ## timer.h: ns3::Time ns3::Timer::GetDelayLeft() const [member function]

   613     cls.add_method('GetDelayLeft',

   614                    'ns3::Time',

   615                    [],

   616                    is_const=True)

   617     ## timer.h: void ns3::Timer::Cancel() [member function]

   618     cls.add_method('Cancel',

   619                    'void',

   620                    [])

   621     ## timer.h: void ns3::Timer::Remove() [member function]

   622     cls.add_method('Remove',

   623                    'void',

   624                    [])

   625     ## timer.h: bool ns3::Timer::IsExpired() const [member function]

   626     cls.add_method('IsExpired',

   627                    'bool',

   628                    [],

   629                    is_const=True)

   630     ## timer.h: bool ns3::Timer::IsRunning() const [member function]

   631     cls.add_method('IsRunning',

   632                    'bool',

   633                    [],

   634                    is_const=True)

   635     ## timer.h: bool ns3::Timer::IsSuspended() const [member function]

   636     cls.add_method('IsSuspended',

   637                    'bool',

   638                    [],

   639                    is_const=True)

   640     ## timer.h: ns3::Timer::State ns3::Timer::GetState() const [member function]

   641     cls.add_method('GetState',

   642                    'ns3::Timer::State',

   643                    [],

   644                    is_const=True)

   645     ## timer.h: void ns3::Timer::Schedule() [member function]

   646     cls.add_method('Schedule',

   647                    'void',

   648                    [])

   649     ## timer.h: void ns3::Timer::Schedule(ns3::Time delay) [member function]

   650     cls.add_method('Schedule',

   651                    'void',

   652                    [param('ns3::Time', 'delay')])

   653     ## timer.h: void ns3::Timer::Suspend() [member function]

   654     cls.add_method('Suspend',

   655                    'void',

   656                    [])

   657     ## timer.h: void ns3::Timer::Resume() [member function]

   658     cls.add_method('Resume',

   659                    'void',

   660                    [])

   661     return

   663 def register_Ns3TimerImpl_methods(root_module, cls):

   664     ## timer-impl.h: ns3::TimerImpl::TimerImpl(ns3::TimerImpl const & arg0) [copy constructor]

   665     cls.add_constructor([param('ns3::TimerImpl const &', 'arg0')])

   666     ## timer-impl.h: ns3::TimerImpl::TimerImpl() [constructor]

   667     cls.add_constructor([])

   668     ## timer-impl.h: ns3::EventId ns3::TimerImpl::Schedule(ns3::Time const & delay) [member function]

   669     cls.add_method('Schedule',

   670                    'ns3::EventId',

   671                    [param('ns3::Time const &', 'delay')],

   672                    is_pure_virtual=True, is_virtual=True)

   673     ## timer-impl.h: void ns3::TimerImpl::Invoke() [member function]

   674     cls.add_method('Invoke',

   675                    'void',

   676                    [],

   677                    is_pure_virtual=True, is_virtual=True)

   678     return

   680 def register_Ns3Watchdog_methods(root_module, cls):

   681     ## watchdog.h: ns3::Watchdog::Watchdog(ns3::Watchdog const & arg0) [copy constructor]

   682     cls.add_constructor([param('ns3::Watchdog const &', 'arg0')])

   683     ## watchdog.h: ns3::Watchdog::Watchdog() [constructor]

   684     cls.add_constructor([])

   685     ## watchdog.h: void ns3::Watchdog::Ping(ns3::Time delay) [member function]

   686     cls.add_method('Ping',

   687                    'void',

   688                    [param('ns3::Time', 'delay')])

   689     return

   691 def register_Ns3Scheduler_methods(root_module, cls):

   692     ## scheduler.h: ns3::Scheduler::Scheduler(ns3::Scheduler const & arg0) [copy constructor]

   693     cls.add_constructor([param('ns3::Scheduler const &', 'arg0')])

   694     ## scheduler.h: ns3::Scheduler::Scheduler() [constructor]

   695     cls.add_constructor([])

   696     ## scheduler.h: static ns3::TypeId ns3::Scheduler::GetTypeId() [member function]

   697     cls.add_method('GetTypeId',

   698                    'ns3::TypeId',

   699                    [],

   700                    is_static=True)

   701     ## scheduler.h: void ns3::Scheduler::Insert(ns3::Scheduler::Event const & ev) [member function]

   702     cls.add_method('Insert',

   703                    'void',

   704                    [param('ns3::Scheduler::Event const &', 'ev')],

   705                    is_pure_virtual=True, is_virtual=True)

   706     ## scheduler.h: bool ns3::Scheduler::IsEmpty() const [member function]

   707     cls.add_method('IsEmpty',

   708                    'bool',

   709                    [],

   710                    is_pure_virtual=True, is_const=True, is_virtual=True)

   711     ## scheduler.h: ns3::Scheduler::Event ns3::Scheduler::PeekNext() const [member function]

   712     cls.add_method('PeekNext',

   713                    'ns3::Scheduler::Event',

   714                    [],

   715                    is_pure_virtual=True, is_const=True, is_virtual=True)

   716     ## scheduler.h: ns3::Scheduler::Event ns3::Scheduler::RemoveNext() [member function]

   717     cls.add_method('RemoveNext',

   718                    'ns3::Scheduler::Event',

   719                    [],

   720                    is_pure_virtual=True, is_virtual=True)

   721     ## scheduler.h: void ns3::Scheduler::Remove(ns3::Scheduler::Event const & ev) [member function]

   722     cls.add_method('Remove',

   723                    'void',

   724                    [param('ns3::Scheduler::Event const &', 'ev')],

   725                    is_pure_virtual=True, is_virtual=True)

   726     return

   728 def register_Ns3SchedulerEvent_methods(root_module, cls):

   729     cls.add_binary_comparison_operator('<')

   730     ## scheduler.h: ns3::Scheduler::Event::Event() [constructor]

   731     cls.add_constructor([])

   732     ## scheduler.h: ns3::Scheduler::Event::Event(ns3::Scheduler::Event const & arg0) [copy constructor]

   733     cls.add_constructor([param('ns3::Scheduler::Event const &', 'arg0')])

   734     ## scheduler.h: ns3::Scheduler::Event::impl [variable]

   735     cls.add_instance_attribute('impl', 'ns3::EventImpl *', is_const=False)

   736     ## scheduler.h: ns3::Scheduler::Event::key [variable]

   737     cls.add_instance_attribute('key', 'ns3::Scheduler::EventKey', is_const=False)

   738     return

   740 def register_Ns3SchedulerEventKey_methods(root_module, cls):

   741     cls.add_binary_comparison_operator('!=')

   742     cls.add_binary_comparison_operator('<')

   743     cls.add_binary_comparison_operator('>')

   744     ## scheduler.h: ns3::Scheduler::EventKey::EventKey() [constructor]

   745     cls.add_constructor([])

   746     ## scheduler.h: ns3::Scheduler::EventKey::EventKey(ns3::Scheduler::EventKey const & arg0) [copy constructor]

   747     cls.add_constructor([param('ns3::Scheduler::EventKey const &', 'arg0')])

   748     ## scheduler.h: ns3::Scheduler::EventKey::m_ts [variable]

   749     cls.add_instance_attribute('m_ts', 'uint64_t', is_const=False)

   750     ## scheduler.h: ns3::Scheduler::EventKey::m_uid [variable]

   751     cls.add_instance_attribute('m_uid', 'uint32_t', is_const=False)

   752     return

   754 def register_Ns3SimulatorImpl_methods(root_module, cls):

   755     ## simulator-impl.h: ns3::SimulatorImpl::SimulatorImpl(ns3::SimulatorImpl const & arg0) [copy constructor]

   756     cls.add_constructor([param('ns3::SimulatorImpl const &', 'arg0')])

   757     ## simulator-impl.h: ns3::SimulatorImpl::SimulatorImpl() [constructor]

   758     cls.add_constructor([])

   759     ## simulator-impl.h: void ns3::SimulatorImpl::Destroy() [member function]

   760     cls.add_method('Destroy',

   761                    'void',

   762                    [],

   763                    is_pure_virtual=True, is_virtual=True)

   764     ## simulator-impl.h: bool ns3::SimulatorImpl::IsFinished() const [member function]

   765     cls.add_method('IsFinished',

   766                    'bool',

   767                    [],

   768                    is_pure_virtual=True, is_const=True, is_virtual=True)

   769     ## simulator-impl.h: ns3::Time ns3::SimulatorImpl::Next() const [member function]

   770     cls.add_method('Next',

   771                    'ns3::Time',

   772                    [],

   773                    is_pure_virtual=True, is_const=True, is_virtual=True)

   774     ## simulator-impl.h: void ns3::SimulatorImpl::Stop() [member function]

   775     cls.add_method('Stop',

   776                    'void',

   777                    [],

   778                    is_pure_virtual=True, is_virtual=True)

   779     ## simulator-impl.h: ns3::EventId ns3::SimulatorImpl::Schedule(ns3::Time const & time, ns3::EventImpl * event) [member function]

   780     cls.add_method('Schedule',

   781                    'ns3::EventId',

   782                    [param('ns3::Time const &', 'time'), param('ns3::EventImpl *', 'event')],

   783                    is_pure_virtual=True, is_virtual=True)

   784     ## simulator-impl.h: ns3::EventId ns3::SimulatorImpl::ScheduleNow(ns3::EventImpl * event) [member function]

   785     cls.add_method('ScheduleNow',

   786                    'ns3::EventId',

   787                    [param('ns3::EventImpl *', 'event')],

   788                    is_pure_virtual=True, is_virtual=True)

   789     ## simulator-impl.h: ns3::EventId ns3::SimulatorImpl::ScheduleDestroy(ns3::EventImpl * event) [member function]

   790     cls.add_method('ScheduleDestroy',

   791                    'ns3::EventId',

   792                    [param('ns3::EventImpl *', 'event')],

   793                    is_pure_virtual=True, is_virtual=True)

   794     ## simulator-impl.h: void ns3::SimulatorImpl::Remove(ns3::EventId const & ev) [member function]

   795     cls.add_method('Remove',

   796                    'void',

   797                    [param('ns3::EventId const &', 'ev')],

   798                    is_pure_virtual=True, is_virtual=True)

   799     ## simulator-impl.h: void ns3::SimulatorImpl::Cancel(ns3::EventId const & ev) [member function]

   800     cls.add_method('Cancel',

   801                    'void',

   802                    [param('ns3::EventId const &', 'ev')],

   803                    is_pure_virtual=True, is_virtual=True)

   804     ## simulator-impl.h: bool ns3::SimulatorImpl::IsExpired(ns3::EventId const & ev) const [member function]

   805     cls.add_method('IsExpired',

   806                    'bool',

   807                    [param('ns3::EventId const &', 'ev')],

   808                    is_pure_virtual=True, is_const=True, is_virtual=True)

   809     ## simulator-impl.h: void ns3::SimulatorImpl::Run() [member function]

   810     cls.add_method('Run',

   811                    'void',

   812                    [],

   813                    is_pure_virtual=True, is_virtual=True)

   814     ## simulator-impl.h: void ns3::SimulatorImpl::RunOneEvent() [member function]

   815     cls.add_method('RunOneEvent',

   816                    'void',

   817                    [],

   818                    is_pure_virtual=True, is_virtual=True)

   819     ## simulator-impl.h: ns3::Time ns3::SimulatorImpl::Now() const [member function]

   820     cls.add_method('Now',

   821                    'ns3::Time',

   822                    [],

   823                    is_pure_virtual=True, is_const=True, is_virtual=True)

   824     ## simulator-impl.h: ns3::Time ns3::SimulatorImpl::GetDelayLeft(ns3::EventId const & id) const [member function]

   825     cls.add_method('GetDelayLeft',

   826                    'ns3::Time',

   827                    [param('ns3::EventId const &', 'id')],

   828                    is_pure_virtual=True, is_const=True, is_virtual=True)

   829     ## simulator-impl.h: ns3::Time ns3::SimulatorImpl::GetMaximumSimulationTime() const [member function]

   830     cls.add_method('GetMaximumSimulationTime',

   831                    'ns3::Time',

   832                    [],

   833                    is_pure_virtual=True, is_const=True, is_virtual=True)

   834     ## simulator-impl.h: void ns3::SimulatorImpl::SetScheduler(ns3::Ptr<ns3::Scheduler> scheduler) [member function]

   835     cls.add_method('SetScheduler',

   836                    'void',

   837                    [param('ns3::Ptr< ns3::Scheduler >', 'scheduler')],

   838                    is_pure_virtual=True, is_virtual=True)

   839     return

   841 def register_Ns3Synchronizer_methods(root_module, cls):

   842     ## synchronizer.h: ns3::Synchronizer::Synchronizer(ns3::Synchronizer const & arg0) [copy constructor]

   843     cls.add_constructor([param('ns3::Synchronizer const &', 'arg0')])

   844     ## synchronizer.h: static ns3::TypeId ns3::Synchronizer::GetTypeId() [member function]

   845     cls.add_method('GetTypeId',

   846                    'ns3::TypeId',

   847                    [],

   848                    is_static=True)

   849     ## synchronizer.h: ns3::Synchronizer::Synchronizer() [constructor]

   850     cls.add_constructor([])

   851     ## synchronizer.h: bool ns3::Synchronizer::Realtime() [member function]

   852     cls.add_method('Realtime',

   853                    'bool',

   854                    [])

   855     ## synchronizer.h: uint64_t ns3::Synchronizer::GetCurrentRealtime() [member function]

   856     cls.add_method('GetCurrentRealtime',

   857                    'uint64_t',

   858                    [])

   859     ## synchronizer.h: void ns3::Synchronizer::SetOrigin(uint64_t ts) [member function]

   860     cls.add_method('SetOrigin',

   861                    'void',

   862                    [param('uint64_t', 'ts')])

   863     ## synchronizer.h: uint64_t ns3::Synchronizer::GetOrigin() [member function]

   864     cls.add_method('GetOrigin',

   865                    'uint64_t',

   866                    [])

   867     ## synchronizer.h: int64_t ns3::Synchronizer::GetDrift(uint64_t ts) [member function]

   868     cls.add_method('GetDrift',

   869                    'int64_t',

   870                    [param('uint64_t', 'ts')])

   871     ## synchronizer.h: bool ns3::Synchronizer::Synchronize(uint64_t tsCurrent, uint64_t tsDelay) [member function]

   872     cls.add_method('Synchronize',

   873                    'bool',

   874                    [param('uint64_t', 'tsCurrent'), param('uint64_t', 'tsDelay')])

   875     ## synchronizer.h: void ns3::Synchronizer::Signal() [member function]

   876     cls.add_method('Signal',

   877                    'void',

   878                    [])

   879     ## synchronizer.h: void ns3::Synchronizer::SetCondition(bool arg0) [member function]

   880     cls.add_method('SetCondition',

   881                    'void',

   882                    [param('bool', 'arg0')])

   883     ## synchronizer.h: void ns3::Synchronizer::EventStart() [member function]

   884     cls.add_method('EventStart',

   885                    'void',

   886                    [])

   887     ## synchronizer.h: uint64_t ns3::Synchronizer::EventEnd() [member function]

   888     cls.add_method('EventEnd',

   889                    'uint64_t',

   890                    [])

   891     ## synchronizer.h: void ns3::Synchronizer::DoSetOrigin(uint64_t ns) [member function]

   892     cls.add_method('DoSetOrigin',

   893                    'void',

   894                    [param('uint64_t', 'ns')],

   895                    is_pure_virtual=True, visibility='protected', is_virtual=True)

   896     ## synchronizer.h: bool ns3::Synchronizer::DoRealtime() [member function]

   897     cls.add_method('DoRealtime',

   898                    'bool',

   899                    [],

   900                    is_pure_virtual=True, visibility='protected', is_virtual=True)

   901     ## synchronizer.h: uint64_t ns3::Synchronizer::DoGetCurrentRealtime() [member function]

   902     cls.add_method('DoGetCurrentRealtime',

   903                    'uint64_t',

   904                    [],

   905                    is_pure_virtual=True, visibility='protected', is_virtual=True)

   906     ## synchronizer.h: bool ns3::Synchronizer::DoSynchronize(uint64_t nsCurrent, uint64_t nsDelay) [member function]

   907     cls.add_method('DoSynchronize',

   908                    'bool',

   909                    [param('uint64_t', 'nsCurrent'), param('uint64_t', 'nsDelay')],

   910                    is_pure_virtual=True, visibility='protected', is_virtual=True)

   911     ## synchronizer.h: void ns3::Synchronizer::DoSignal() [member function]

   912     cls.add_method('DoSignal',

   913                    'void',

   914                    [],

   915                    is_pure_virtual=True, visibility='protected', is_virtual=True)

   916     ## synchronizer.h: void ns3::Synchronizer::DoSetCondition(bool arg0) [member function]

   917     cls.add_method('DoSetCondition',

   918                    'void',

   919                    [param('bool', 'arg0')],

   920                    is_pure_virtual=True, visibility='protected', is_virtual=True)

   921     ## synchronizer.h: int64_t ns3::Synchronizer::DoGetDrift(uint64_t ns) [member function]

   922     cls.add_method('DoGetDrift',

   923                    'int64_t',

   924                    [param('uint64_t', 'ns')],

   925                    is_pure_virtual=True, visibility='protected', is_virtual=True)

   926     ## synchronizer.h: void ns3::Synchronizer::DoEventStart() [member function]

   927     cls.add_method('DoEventStart',

   928                    'void',

   929                    [],

   930                    is_pure_virtual=True, visibility='protected', is_virtual=True)

   931     ## synchronizer.h: uint64_t ns3::Synchronizer::DoEventEnd() [member function]

   932     cls.add_method('DoEventEnd',

   933                    'uint64_t',

   934                    [],

   935                    is_pure_virtual=True, visibility='protected', is_virtual=True)

   936     return

   938 def register_Ns3TimeChecker_methods(root_module, cls):

   939     ## nstime.h: ns3::TimeChecker::TimeChecker(ns3::TimeChecker const & arg0) [copy constructor]

   940     cls.add_constructor([param('ns3::TimeChecker const &', 'arg0')])

   941     ## nstime.h: ns3::TimeChecker::TimeChecker() [constructor]

   942     cls.add_constructor([])

   943     return

   945 def register_Ns3TimeValue_methods(root_module, cls):

   946     ## nstime.h: ns3::TimeValue::TimeValue(ns3::TimeValue const & arg0) [copy constructor]

   947     cls.add_constructor([param('ns3::TimeValue const &', 'arg0')])

   948     ## nstime.h: ns3::TimeValue::TimeValue() [constructor]

   949     cls.add_constructor([])

   950     ## nstime.h: ns3::TimeValue::TimeValue(ns3::Time const & value) [constructor]

   951     cls.add_constructor([param('ns3::Time const &', 'value')])

   952     ## nstime.h: void ns3::TimeValue::Set(ns3::Time const & value) [member function]

   953     cls.add_method('Set',

   954                    'void',

   955                    [param('ns3::Time const &', 'value')])

   956     ## nstime.h: ns3::Time ns3::TimeValue::Get() const [member function]

   957     cls.add_method('Get',

   958                    'ns3::Time',

   959                    [],

   960                    is_const=True)

   961     ## nstime.h: ns3::Ptr<ns3::AttributeValue> ns3::TimeValue::Copy() const [member function]

   962     cls.add_method('Copy',

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

   964                    [],

   965                    is_const=True, is_virtual=True)

   966     ## nstime.h: std::string ns3::TimeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

   967     cls.add_method('SerializeToString',

   968                    'std::string',

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

   970                    is_const=True, is_virtual=True)

   971     ## nstime.h: bool ns3::TimeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

   972     cls.add_method('DeserializeFromString',

   973                    'bool',

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

   975                    is_virtual=True)

   976     return

   978 def register_Ns3WallClockSynchronizer_methods(root_module, cls):

   979     ## wall-clock-synchronizer.h: ns3::WallClockSynchronizer::US_PER_NS [variable]

   980     cls.add_static_attribute('US_PER_NS', 'uint64_t const', is_const=True)

   981     ## wall-clock-synchronizer.h: ns3::WallClockSynchronizer::US_PER_SEC [variable]

   982     cls.add_static_attribute('US_PER_SEC', 'uint64_t const', is_const=True)

   983     ## wall-clock-synchronizer.h: ns3::WallClockSynchronizer::NS_PER_SEC [variable]

   984     cls.add_static_attribute('NS_PER_SEC', 'uint64_t const', is_const=True)

   985     ## wall-clock-synchronizer.h: ns3::WallClockSynchronizer::WallClockSynchronizer(ns3::WallClockSynchronizer const & arg0) [copy constructor]

   986     cls.add_constructor([param('ns3::WallClockSynchronizer const &', 'arg0')])

   987     ## wall-clock-synchronizer.h: ns3::WallClockSynchronizer::WallClockSynchronizer() [constructor]

   988     cls.add_constructor([])

   989     ## wall-clock-synchronizer.h: bool ns3::WallClockSynchronizer::DoRealtime() [member function]

   990     cls.add_method('DoRealtime',

   991                    'bool',

   992                    [],

   993                    visibility='protected', is_virtual=True)

   994     ## wall-clock-synchronizer.h: uint64_t ns3::WallClockSynchronizer::DoGetCurrentRealtime() [member function]

   995     cls.add_method('DoGetCurrentRealtime',

   996                    'uint64_t',

   997                    [],

   998                    visibility='protected', is_virtual=True)

   999     ## wall-clock-synchronizer.h: void ns3::WallClockSynchronizer::DoSetOrigin(uint64_t ns) [member function]

  1000     cls.add_method('DoSetOrigin',

  1001                    'void',

  1002                    [param('uint64_t', 'ns')],

  1003                    visibility='protected', is_virtual=True)

  1004     ## wall-clock-synchronizer.h: int64_t ns3::WallClockSynchronizer::DoGetDrift(uint64_t ns) [member function]

  1005     cls.add_method('DoGetDrift',

  1006                    'int64_t',

  1007                    [param('uint64_t', 'ns')],

  1008                    visibility='protected', is_virtual=True)

  1009     ## wall-clock-synchronizer.h: bool ns3::WallClockSynchronizer::DoSynchronize(uint64_t nsCurrent, uint64_t nsDelay) [member function]

  1010     cls.add_method('DoSynchronize',

  1011                    'bool',

  1012                    [param('uint64_t', 'nsCurrent'), param('uint64_t', 'nsDelay')],

  1013                    visibility='protected', is_virtual=True)

  1014     ## wall-clock-synchronizer.h: void ns3::WallClockSynchronizer::DoSignal() [member function]

  1015     cls.add_method('DoSignal',

  1016                    'void',

  1017                    [],

  1018                    visibility='protected', is_virtual=True)

  1019     ## wall-clock-synchronizer.h: void ns3::WallClockSynchronizer::DoSetCondition(bool cond) [member function]

  1020     cls.add_method('DoSetCondition',

  1021                    'void',

  1022                    [param('bool', 'cond')],

  1023                    visibility='protected', is_virtual=True)

  1024     ## wall-clock-synchronizer.h: void ns3::WallClockSynchronizer::DoEventStart() [member function]

  1025     cls.add_method('DoEventStart',

  1026                    'void',

  1027                    [],

  1028                    visibility='protected', is_virtual=True)

  1029     ## wall-clock-synchronizer.h: uint64_t ns3::WallClockSynchronizer::DoEventEnd() [member function]

  1030     cls.add_method('DoEventEnd',

  1031                    'uint64_t',

  1032                    [],

  1033                    visibility='protected', is_virtual=True)

  1034     ## wall-clock-synchronizer.h: bool ns3::WallClockSynchronizer::SpinWait(uint64_t arg0) [member function]

  1035     cls.add_method('SpinWait',

  1036                    'bool',

  1037                    [param('uint64_t', 'arg0')],

  1038                    visibility='protected')

  1039     ## wall-clock-synchronizer.h: bool ns3::WallClockSynchronizer::SleepWait(uint64_t arg0) [member function]

  1040     cls.add_method('SleepWait',

  1041                    'bool',

  1042                    [param('uint64_t', 'arg0')],

  1043                    visibility='protected')

  1044     ## wall-clock-synchronizer.h: uint64_t ns3::WallClockSynchronizer::DriftCorrect(uint64_t nsNow, uint64_t nsDelay) [member function]

  1045     cls.add_method('DriftCorrect',

  1046                    'uint64_t',

  1047                    [param('uint64_t', 'nsNow'), param('uint64_t', 'nsDelay')],

  1048                    visibility='protected')

  1049     ## wall-clock-synchronizer.h: uint64_t ns3::WallClockSynchronizer::GetRealtime() [member function]

  1050     cls.add_method('GetRealtime',

  1051                    'uint64_t',

  1052                    [],

  1053                    visibility='protected')

  1054     ## wall-clock-synchronizer.h: uint64_t ns3::WallClockSynchronizer::GetNormalizedRealtime() [member function]

  1055     cls.add_method('GetNormalizedRealtime',

  1056                    'uint64_t',

  1057                    [],

  1058                    visibility='protected')

  1059     ## wall-clock-synchronizer.h: void ns3::WallClockSynchronizer::NsToTimeval(int64_t ns, timeval * tv) [member function]

  1060     cls.add_method('NsToTimeval',

  1061                    'void',

  1062                    [param('int64_t', 'ns'), param('timeval *', 'tv')],

  1063                    visibility='protected')

  1064     ## wall-clock-synchronizer.h: uint64_t ns3::WallClockSynchronizer::TimevalToNs(timeval * tv) [member function]

  1065     cls.add_method('TimevalToNs',

  1066                    'uint64_t',

  1067                    [param('timeval *', 'tv')],

  1068                    visibility='protected')

  1069     ## wall-clock-synchronizer.h: void ns3::WallClockSynchronizer::TimevalAdd(timeval * tv1, timeval * tv2, timeval * result) [member function]

  1070     cls.add_method('TimevalAdd',

  1071                    'void',

  1072                    [param('timeval *', 'tv1'), param('timeval *', 'tv2'), param('timeval *', 'result')],

  1073                    visibility='protected')

  1074     return

  1076 def register_Ns3CalendarScheduler_methods(root_module, cls):

  1077     ## calendar-scheduler.h: ns3::CalendarScheduler::CalendarScheduler(ns3::CalendarScheduler const & arg0) [copy constructor]

  1078     cls.add_constructor([param('ns3::CalendarScheduler const &', 'arg0')])

  1079     ## calendar-scheduler.h: static ns3::TypeId ns3::CalendarScheduler::GetTypeId() [member function]

  1080     cls.add_method('GetTypeId',

  1081                    'ns3::TypeId',

  1082                    [],

  1083                    is_static=True)

  1084     ## calendar-scheduler.h: ns3::CalendarScheduler::CalendarScheduler() [constructor]

  1085     cls.add_constructor([])

  1086     ## calendar-scheduler.h: void ns3::CalendarScheduler::Insert(ns3::Scheduler::Event const & ev) [member function]

  1087     cls.add_method('Insert',

  1088                    'void',

  1089                    [param('ns3::Scheduler::Event const &', 'ev')],

  1090                    is_virtual=True)

  1091     ## calendar-scheduler.h: bool ns3::CalendarScheduler::IsEmpty() const [member function]

  1092     cls.add_method('IsEmpty',

  1093                    'bool',

  1094                    [],

  1095                    is_const=True, is_virtual=True)

  1096     ## calendar-scheduler.h: ns3::Scheduler::Event ns3::CalendarScheduler::PeekNext() const [member function]

  1097     cls.add_method('PeekNext',

  1098                    'ns3::Scheduler::Event',

  1099                    [],

  1100                    is_const=True, is_virtual=True)

  1101     ## calendar-scheduler.h: ns3::Scheduler::Event ns3::CalendarScheduler::RemoveNext() [member function]

  1102     cls.add_method('RemoveNext',

  1103                    'ns3::Scheduler::Event',

  1104                    [],

  1105                    is_virtual=True)

  1106     ## calendar-scheduler.h: void ns3::CalendarScheduler::Remove(ns3::Scheduler::Event const & ev) [member function]

  1107     cls.add_method('Remove',

  1108                    'void',

  1109                    [param('ns3::Scheduler::Event const &', 'ev')],

  1110                    is_virtual=True)

  1111     return

  1113 def register_Ns3DefaultSimulatorImpl_methods(root_module, cls):

  1114     ## default-simulator-impl.h: ns3::DefaultSimulatorImpl::DefaultSimulatorImpl(ns3::DefaultSimulatorImpl const & arg0) [copy constructor]

  1115     cls.add_constructor([param('ns3::DefaultSimulatorImpl const &', 'arg0')])

  1116     ## default-simulator-impl.h: static ns3::TypeId ns3::DefaultSimulatorImpl::GetTypeId() [member function]

  1117     cls.add_method('GetTypeId',

  1118                    'ns3::TypeId',

  1119                    [],

  1120                    is_static=True)

  1121     ## default-simulator-impl.h: ns3::DefaultSimulatorImpl::DefaultSimulatorImpl() [constructor]

  1122     cls.add_constructor([])

  1123     ## default-simulator-impl.h: void ns3::DefaultSimulatorImpl::Destroy() [member function]

  1124     cls.add_method('Destroy',

  1125                    'void',

  1126                    [],

  1127                    is_virtual=True)

  1128     ## default-simulator-impl.h: bool ns3::DefaultSimulatorImpl::IsFinished() const [member function]

  1129     cls.add_method('IsFinished',

  1130                    'bool',

  1131                    [],

  1132                    is_const=True, is_virtual=True)

  1133     ## default-simulator-impl.h: ns3::Time ns3::DefaultSimulatorImpl::Next() const [member function]

  1134     cls.add_method('Next',

  1135                    'ns3::Time',

  1136                    [],

  1137                    is_const=True, is_virtual=True)

  1138     ## default-simulator-impl.h: void ns3::DefaultSimulatorImpl::Stop() [member function]

  1139     cls.add_method('Stop',

  1140                    'void',

  1141                    [],

  1142                    is_virtual=True)

  1143     ## default-simulator-impl.h: ns3::EventId ns3::DefaultSimulatorImpl::Schedule(ns3::Time const & time, ns3::EventImpl * event) [member function]

  1144     cls.add_method('Schedule',

  1145                    'ns3::EventId',

  1146                    [param('ns3::Time const &', 'time'), param('ns3::EventImpl *', 'event')],

  1147                    is_virtual=True)

  1148     ## default-simulator-impl.h: ns3::EventId ns3::DefaultSimulatorImpl::ScheduleNow(ns3::EventImpl * event) [member function]

  1149     cls.add_method('ScheduleNow',

  1150                    'ns3::EventId',

  1151                    [param('ns3::EventImpl *', 'event')],

  1152                    is_virtual=True)

  1153     ## default-simulator-impl.h: ns3::EventId ns3::DefaultSimulatorImpl::ScheduleDestroy(ns3::EventImpl * event) [member function]

  1154     cls.add_method('ScheduleDestroy',

  1155                    'ns3::EventId',

  1156                    [param('ns3::EventImpl *', 'event')],

  1157                    is_virtual=True)

  1158     ## default-simulator-impl.h: void ns3::DefaultSimulatorImpl::Remove(ns3::EventId const & ev) [member function]

  1159     cls.add_method('Remove',

  1160                    'void',

  1161                    [param('ns3::EventId const &', 'ev')],

  1162                    is_virtual=True)

  1163     ## default-simulator-impl.h: void ns3::DefaultSimulatorImpl::Cancel(ns3::EventId const & ev) [member function]

  1164     cls.add_method('Cancel',

  1165                    'void',

  1166                    [param('ns3::EventId const &', 'ev')],

  1167                    is_virtual=True)

  1168     ## default-simulator-impl.h: bool ns3::DefaultSimulatorImpl::IsExpired(ns3::EventId const & ev) const [member function]

  1169     cls.add_method('IsExpired',

  1170                    'bool',

  1171                    [param('ns3::EventId const &', 'ev')],

  1172                    is_const=True, is_virtual=True)

  1173     ## default-simulator-impl.h: void ns3::DefaultSimulatorImpl::Run() [member function]

  1174     cls.add_method('Run',

  1175                    'void',

  1176                    [],

  1177                    is_virtual=True)

  1178     ## default-simulator-impl.h: void ns3::DefaultSimulatorImpl::RunOneEvent() [member function]

  1179     cls.add_method('RunOneEvent',

  1180                    'void',

  1181                    [],

  1182                    is_virtual=True)

  1183     ## default-simulator-impl.h: ns3::Time ns3::DefaultSimulatorImpl::Now() const [member function]

  1184     cls.add_method('Now',

  1185                    'ns3::Time',

  1186                    [],

  1187                    is_const=True, is_virtual=True)

  1188     ## default-simulator-impl.h: ns3::Time ns3::DefaultSimulatorImpl::GetDelayLeft(ns3::EventId const & id) const [member function]

  1189     cls.add_method('GetDelayLeft',

  1190                    'ns3::Time',

  1191                    [param('ns3::EventId const &', 'id')],

  1192                    is_const=True, is_virtual=True)

  1193     ## default-simulator-impl.h: ns3::Time ns3::DefaultSimulatorImpl::GetMaximumSimulationTime() const [member function]

  1194     cls.add_method('GetMaximumSimulationTime',

  1195                    'ns3::Time',

  1196                    [],

  1197                    is_const=True, is_virtual=True)

  1198     ## default-simulator-impl.h: void ns3::DefaultSimulatorImpl::SetScheduler(ns3::Ptr<ns3::Scheduler> scheduler) [member function]

  1199     cls.add_method('SetScheduler',

  1200                    'void',

  1201                    [param('ns3::Ptr< ns3::Scheduler >', 'scheduler')],

  1202                    is_virtual=True)

  1203     return

  1205 def register_Ns3HeapScheduler_methods(root_module, cls):

  1206     ## heap-scheduler.h: ns3::HeapScheduler::HeapScheduler(ns3::HeapScheduler const & arg0) [copy constructor]

  1207     cls.add_constructor([param('ns3::HeapScheduler const &', 'arg0')])

  1208     ## heap-scheduler.h: static ns3::TypeId ns3::HeapScheduler::GetTypeId() [member function]

  1209     cls.add_method('GetTypeId',

  1210                    'ns3::TypeId',

  1211                    [],

  1212                    is_static=True)

  1213     ## heap-scheduler.h: ns3::HeapScheduler::HeapScheduler() [constructor]

  1214     cls.add_constructor([])

  1215     ## heap-scheduler.h: void ns3::HeapScheduler::Insert(ns3::Scheduler::Event const & ev) [member function]

  1216     cls.add_method('Insert',

  1217                    'void',

  1218                    [param('ns3::Scheduler::Event const &', 'ev')],

  1219                    is_virtual=True)

  1220     ## heap-scheduler.h: bool ns3::HeapScheduler::IsEmpty() const [member function]

  1221     cls.add_method('IsEmpty',

  1222                    'bool',

  1223                    [],

  1224                    is_const=True, is_virtual=True)

  1225     ## heap-scheduler.h: ns3::Scheduler::Event ns3::HeapScheduler::PeekNext() const [member function]

  1226     cls.add_method('PeekNext',

  1227                    'ns3::Scheduler::Event',

  1228                    [],

  1229                    is_const=True, is_virtual=True)

  1230     ## heap-scheduler.h: ns3::Scheduler::Event ns3::HeapScheduler::RemoveNext() [member function]

  1231     cls.add_method('RemoveNext',

  1232                    'ns3::Scheduler::Event',

  1233                    [],

  1234                    is_virtual=True)

  1235     ## heap-scheduler.h: void ns3::HeapScheduler::Remove(ns3::Scheduler::Event const & ev) [member function]

  1236     cls.add_method('Remove',

  1237                    'void',

  1238                    [param('ns3::Scheduler::Event const &', 'ev')],

  1239                    is_virtual=True)

  1240     return

  1242 def register_Ns3ListScheduler_methods(root_module, cls):

  1243     ## list-scheduler.h: ns3::ListScheduler::ListScheduler(ns3::ListScheduler const & arg0) [copy constructor]

  1244     cls.add_constructor([param('ns3::ListScheduler const &', 'arg0')])

  1245     ## list-scheduler.h: static ns3::TypeId ns3::ListScheduler::GetTypeId() [member function]

  1246     cls.add_method('GetTypeId',

  1247                    'ns3::TypeId',

  1248                    [],

  1249                    is_static=True)

  1250     ## list-scheduler.h: ns3::ListScheduler::ListScheduler() [constructor]

  1251     cls.add_constructor([])

  1252     ## list-scheduler.h: void ns3::ListScheduler::Insert(ns3::Scheduler::Event const & ev) [member function]

  1253     cls.add_method('Insert',

  1254                    'void',

  1255                    [param('ns3::Scheduler::Event const &', 'ev')],

  1256                    is_virtual=True)

  1257     ## list-scheduler.h: bool ns3::ListScheduler::IsEmpty() const [member function]

  1258     cls.add_method('IsEmpty',

  1259                    'bool',

  1260                    [],

  1261                    is_const=True, is_virtual=True)

  1262     ## list-scheduler.h: ns3::Scheduler::Event ns3::ListScheduler::PeekNext() const [member function]

  1263     cls.add_method('PeekNext',

  1264                    'ns3::Scheduler::Event',

  1265                    [],

  1266                    is_const=True, is_virtual=True)

  1267     ## list-scheduler.h: ns3::Scheduler::Event ns3::ListScheduler::RemoveNext() [member function]

  1268     cls.add_method('RemoveNext',

  1269                    'ns3::Scheduler::Event',

  1270                    [],

  1271                    is_virtual=True)

  1272     ## list-scheduler.h: void ns3::ListScheduler::Remove(ns3::Scheduler::Event const & ev) [member function]

  1273     cls.add_method('Remove',

  1274                    'void',

  1275                    [param('ns3::Scheduler::Event const &', 'ev')],

  1276                    is_virtual=True)

  1277     return

  1279 def register_Ns3MapScheduler_methods(root_module, cls):

  1280     ## map-scheduler.h: ns3::MapScheduler::MapScheduler(ns3::MapScheduler const & arg0) [copy constructor]

  1281     cls.add_constructor([param('ns3::MapScheduler const &', 'arg0')])

  1282     ## map-scheduler.h: static ns3::TypeId ns3::MapScheduler::GetTypeId() [member function]

  1283     cls.add_method('GetTypeId',

  1284                    'ns3::TypeId',

  1285                    [],

  1286                    is_static=True)

  1287     ## map-scheduler.h: ns3::MapScheduler::MapScheduler() [constructor]

  1288     cls.add_constructor([])

  1289     ## map-scheduler.h: void ns3::MapScheduler::Insert(ns3::Scheduler::Event const & ev) [member function]

  1290     cls.add_method('Insert',

  1291                    'void',

  1292                    [param('ns3::Scheduler::Event const &', 'ev')],

  1293                    is_virtual=True)

  1294     ## map-scheduler.h: bool ns3::MapScheduler::IsEmpty() const [member function]

  1295     cls.add_method('IsEmpty',

  1296                    'bool',

  1297                    [],

  1298                    is_const=True, is_virtual=True)

  1299     ## map-scheduler.h: ns3::Scheduler::Event ns3::MapScheduler::PeekNext() const [member function]

  1300     cls.add_method('PeekNext',

  1301                    'ns3::Scheduler::Event',

  1302                    [],

  1303                    is_const=True, is_virtual=True)

  1304     ## map-scheduler.h: ns3::Scheduler::Event ns3::MapScheduler::RemoveNext() [member function]

  1305     cls.add_method('RemoveNext',

  1306                    'ns3::Scheduler::Event',

  1307                    [],

  1308                    is_virtual=True)

  1309     ## map-scheduler.h: void ns3::MapScheduler::Remove(ns3::Scheduler::Event const & ev) [member function]

  1310     cls.add_method('Remove',

  1311                    'void',

  1312                    [param('ns3::Scheduler::Event const &', 'ev')],

  1313                    is_virtual=True)

  1314     return

  1316 def register_Ns3Ns2CalendarScheduler_methods(root_module, cls):

  1317     ## ns2-calendar-scheduler.h: ns3::Ns2CalendarScheduler::Ns2CalendarScheduler(ns3::Ns2CalendarScheduler const & arg0) [copy constructor]

  1318     cls.add_constructor([param('ns3::Ns2CalendarScheduler const &', 'arg0')])

  1319     ## ns2-calendar-scheduler.h: static ns3::TypeId ns3::Ns2CalendarScheduler::GetTypeId() [member function]

  1320     cls.add_method('GetTypeId',

  1321                    'ns3::TypeId',

  1322                    [],

  1323                    is_static=True)

  1324     ## ns2-calendar-scheduler.h: ns3::Ns2CalendarScheduler::Ns2CalendarScheduler() [constructor]

  1325     cls.add_constructor([])

  1326     ## ns2-calendar-scheduler.h: void ns3::Ns2CalendarScheduler::Insert(ns3::Scheduler::Event const & ev) [member function]

  1327     cls.add_method('Insert',

  1328                    'void',

  1329                    [param('ns3::Scheduler::Event const &', 'ev')],

  1330                    is_virtual=True)

  1331     ## ns2-calendar-scheduler.h: bool ns3::Ns2CalendarScheduler::IsEmpty() const [member function]

  1332     cls.add_method('IsEmpty',

  1333                    'bool',

  1334                    [],

  1335                    is_const=True, is_virtual=True)

  1336     ## ns2-calendar-scheduler.h: ns3::Scheduler::Event ns3::Ns2CalendarScheduler::PeekNext() const [member function]

  1337     cls.add_method('PeekNext',

  1338                    'ns3::Scheduler::Event',

  1339                    [],

  1340                    is_const=True, is_virtual=True)

  1341     ## ns2-calendar-scheduler.h: ns3::Scheduler::Event ns3::Ns2CalendarScheduler::RemoveNext() [member function]

  1342     cls.add_method('RemoveNext',

  1343                    'ns3::Scheduler::Event',

  1344                    [],

  1345                    is_virtual=True)

  1346     ## ns2-calendar-scheduler.h: void ns3::Ns2CalendarScheduler::Remove(ns3::Scheduler::Event const & ev) [member function]

  1347     cls.add_method('Remove',

  1348                    'void',

  1349                    [param('ns3::Scheduler::Event const &', 'ev')],

  1350                    is_virtual=True)

  1351     return

  1353 def register_Ns3RealtimeSimulatorImpl_methods(root_module, cls):

  1354     ## realtime-simulator-impl.h: ns3::RealtimeSimulatorImpl::RealtimeSimulatorImpl(ns3::RealtimeSimulatorImpl const & arg0) [copy constructor]

  1355     cls.add_constructor([param('ns3::RealtimeSimulatorImpl const &', 'arg0')])

  1356     ## realtime-simulator-impl.h: static ns3::TypeId ns3::RealtimeSimulatorImpl::GetTypeId() [member function]

  1357     cls.add_method('GetTypeId',

  1358                    'ns3::TypeId',

  1359                    [],

  1360                    is_static=True)

  1361     ## realtime-simulator-impl.h: ns3::RealtimeSimulatorImpl::RealtimeSimulatorImpl() [constructor]

  1362     cls.add_constructor([])

  1363     ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::Destroy() [member function]

  1364     cls.add_method('Destroy',

  1365                    'void',

  1366                    [],

  1367                    is_virtual=True)

  1368     ## realtime-simulator-impl.h: bool ns3::RealtimeSimulatorImpl::IsFinished() const [member function]

  1369     cls.add_method('IsFinished',

  1370                    'bool',

  1371                    [],

  1372                    is_const=True, is_virtual=True)

  1373     ## realtime-simulator-impl.h: ns3::Time ns3::RealtimeSimulatorImpl::Next() const [member function]

  1374     cls.add_method('Next',

  1375                    'ns3::Time',

  1376                    [],

  1377                    is_const=True, is_virtual=True)

  1378     ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::Stop() [member function]

  1379     cls.add_method('Stop',

  1380                    'void',

  1381                    [],

  1382                    is_virtual=True)

  1383     ## realtime-simulator-impl.h: ns3::EventId ns3::RealtimeSimulatorImpl::Schedule(ns3::Time const & time, ns3::EventImpl * event) [member function]

  1384     cls.add_method('Schedule',

  1385                    'ns3::EventId',

  1386                    [param('ns3::Time const &', 'time'), param('ns3::EventImpl *', 'event')],

  1387                    is_virtual=True)

  1388     ## realtime-simulator-impl.h: ns3::EventId ns3::RealtimeSimulatorImpl::ScheduleNow(ns3::EventImpl * event) [member function]

  1389     cls.add_method('ScheduleNow',

  1390                    'ns3::EventId',

  1391                    [param('ns3::EventImpl *', 'event')],

  1392                    is_virtual=True)

  1393     ## realtime-simulator-impl.h: ns3::EventId ns3::RealtimeSimulatorImpl::ScheduleDestroy(ns3::EventImpl * event) [member function]

  1394     cls.add_method('ScheduleDestroy',

  1395                    'ns3::EventId',

  1396                    [param('ns3::EventImpl *', 'event')],

  1397                    is_virtual=True)

  1398     ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::Remove(ns3::EventId const & ev) [member function]

  1399     cls.add_method('Remove',

  1400                    'void',

  1401                    [param('ns3::EventId const &', 'ev')],

  1402                    is_virtual=True)

  1403     ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::Cancel(ns3::EventId const & ev) [member function]

  1404     cls.add_method('Cancel',

  1405                    'void',

  1406                    [param('ns3::EventId const &', 'ev')],

  1407                    is_virtual=True)

  1408     ## realtime-simulator-impl.h: bool ns3::RealtimeSimulatorImpl::IsExpired(ns3::EventId const & ev) const [member function]

  1409     cls.add_method('IsExpired',

  1410                    'bool',

  1411                    [param('ns3::EventId const &', 'ev')],

  1412                    is_const=True, is_virtual=True)

  1413     ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::Run() [member function]

  1414     cls.add_method('Run',

  1415                    'void',

  1416                    [],

  1417                    is_virtual=True)

  1418     ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::RunOneEvent() [member function]

  1419     cls.add_method('RunOneEvent',

  1420                    'void',

  1421                    [],

  1422                    is_virtual=True)

  1423     ## realtime-simulator-impl.h: ns3::Time ns3::RealtimeSimulatorImpl::Now() const [member function]

  1424     cls.add_method('Now',

  1425                    'ns3::Time',

  1426                    [],

  1427                    is_const=True, is_virtual=True)

  1428     ## realtime-simulator-impl.h: ns3::Time ns3::RealtimeSimulatorImpl::GetDelayLeft(ns3::EventId const & id) const [member function]

  1429     cls.add_method('GetDelayLeft',

  1430                    'ns3::Time',

  1431                    [param('ns3::EventId const &', 'id')],

  1432                    is_const=True, is_virtual=True)

  1433     ## realtime-simulator-impl.h: ns3::Time ns3::RealtimeSimulatorImpl::GetMaximumSimulationTime() const [member function]

  1434     cls.add_method('GetMaximumSimulationTime',

  1435                    'ns3::Time',

  1436                    [],

  1437                    is_const=True, is_virtual=True)

  1438     ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::SetScheduler(ns3::Ptr<ns3::Scheduler> scheduler) [member function]

  1439     cls.add_method('SetScheduler',

  1440                    'void',

  1441                    [param('ns3::Ptr< ns3::Scheduler >', 'scheduler')],

  1442                    is_virtual=True)

  1443     ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::ScheduleRealtime(ns3::Time const & time, ns3::EventImpl * event) [member function]

  1444     cls.add_method('ScheduleRealtime',

  1445                    'void',

  1446                    [param('ns3::Time const &', 'time'), param('ns3::EventImpl *', 'event')])

  1447     ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::ScheduleRealtimeNow(ns3::EventImpl * event) [member function]

  1448     cls.add_method('ScheduleRealtimeNow',

  1449                    'void',

  1450                    [param('ns3::EventImpl *', 'event')])

  1451     ## realtime-simulator-impl.h: ns3::Time ns3::RealtimeSimulatorImpl::RealtimeNow() const [member function]

  1452     cls.add_method('RealtimeNow',

  1453                    'ns3::Time',

  1454                    [],

  1455                    is_const=True)

  1456     ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::SetSynchronizationMode(ns3::RealtimeSimulatorImpl::SynchronizationMode mode) [member function]

  1457     cls.add_method('SetSynchronizationMode',

  1458                    'void',

  1459                    [param('ns3::RealtimeSimulatorImpl::SynchronizationMode', 'mode')])

  1460     ## realtime-simulator-impl.h: ns3::RealtimeSimulatorImpl::SynchronizationMode ns3::RealtimeSimulatorImpl::GetSynchronizationMode() const [member function]

  1461     cls.add_method('GetSynchronizationMode',

  1462                    'ns3::RealtimeSimulatorImpl::SynchronizationMode',

  1463                    [],

  1464                    is_const=True)

  1465     ## realtime-simulator-impl.h: void ns3::RealtimeSimulatorImpl::SetHardLimit(ns3::Time limit) [member function]

  1466     cls.add_method('SetHardLimit',

  1467                    'void',

  1468                    [param('ns3::Time', 'limit')])

  1469     ## realtime-simulator-impl.h: ns3::Time ns3::RealtimeSimulatorImpl::GetHardLimit() const [member function]

  1470     cls.add_method('GetHardLimit',

  1471                    'ns3::Time',

  1472                    [],

  1473                    is_const=True)

  1474     return

  1476 def register_functions(root_module):

  1477     module = root_module

  1478     ## high-precision.h: extern ns3::HighPrecision ns3::Abs(ns3::HighPrecision const & value) [free function]

  1479     module.add_function('Abs',

  1480                         'ns3::HighPrecision',

  1481                         [param('ns3::HighPrecision const &', 'value')])

  1482     ## nstime.h: extern ns3::Time ns3::FemtoSeconds(uint64_t fs) [free function]

  1483     module.add_function('FemtoSeconds',

  1484                         'ns3::Time',

  1485                         [param('uint64_t', 'fs')])

  1486     ## make-event.h: extern ns3::EventImpl * ns3::MakeEvent(void (*)(  ) * f) [free function]

  1487     module.add_function('MakeEvent',

  1488                         'ns3::EventImpl *',

  1489                         [param('void ( * ) (  ) *', 'f')])

  1490     ## nstime.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeTimeChecker() [free function]

  1491     module.add_function('MakeTimeChecker',

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

  1493                         [])

  1494     ## high-precision.h: extern ns3::HighPrecision ns3::Max(ns3::HighPrecision const & a, ns3::HighPrecision const & b) [free function]

  1495     module.add_function('Max',

  1496                         'ns3::HighPrecision',

  1497                         [param('ns3::HighPrecision const &', 'a'), param('ns3::HighPrecision const &', 'b')])

  1498     ## nstime.h: extern ns3::Time ns3::MicroSeconds(uint64_t us) [free function]

  1499     module.add_function('MicroSeconds',

  1500                         'ns3::Time',

  1501                         [param('uint64_t', 'us')])

  1502     ## nstime.h: extern ns3::Time ns3::MilliSeconds(uint64_t ms) [free function]

  1503     module.add_function('MilliSeconds',

  1504                         'ns3::Time',

  1505                         [param('uint64_t', 'ms')])

  1506     ## high-precision.h: extern ns3::HighPrecision ns3::Min(ns3::HighPrecision const & a, ns3::HighPrecision const & b) [free function]

  1507     module.add_function('Min',

  1508                         'ns3::HighPrecision',

  1509                         [param('ns3::HighPrecision const &', 'a'), param('ns3::HighPrecision const &', 'b')])

  1510     ## nstime.h: extern ns3::Time ns3::NanoSeconds(uint64_t ns) [free function]

  1511     module.add_function('NanoSeconds',

  1512                         'ns3::Time',

  1513                         [param('uint64_t', 'ns')])

  1514     ## simulator.h: extern ns3::Time ns3::Now() [free function]

  1515     module.add_function('Now',

  1516                         'ns3::Time',

  1517                         [])

  1518     ## nstime.h: extern ns3::Time ns3::PicoSeconds(uint64_t ps) [free function]

  1519     module.add_function('PicoSeconds',

  1520                         'ns3::Time',

  1521                         [param('uint64_t', 'ps')])

  1522     ## nstime.h: extern ns3::Time ns3::Seconds(double seconds) [free function]

  1523     module.add_function('Seconds',

  1524                         'ns3::Time',

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

  1526     ## nstime.h: extern ns3::Time ns3::TimeStep(uint64_t ts) [free function]

  1527     module.add_function('TimeStep',

  1528                         'ns3::Time',

  1529                         [param('uint64_t', 'ts')])

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

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

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

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

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

  1535     return

  1537 def register_functions_ns3_Config(module, root_module):

  1538     return

  1540 def register_functions_ns3_TimeStepPrecision(module, root_module):

  1541     ## nstime.h: extern ns3::TimeStepPrecision::precision_t ns3::TimeStepPrecision::Get() [free function]

  1542     module.add_function('Get',

  1543                         'ns3::TimeStepPrecision::precision_t',

  1544                         [])

  1545     ## nstime.h: extern void ns3::TimeStepPrecision::Set(ns3::TimeStepPrecision::precision_t precision) [free function]

  1546     module.add_function('Set',

  1547                         'void',

  1548                         [param('ns3::TimeStepPrecision::precision_t', 'precision')])

  1549     return

  1551 def register_functions_ns3_addressUtils(module, root_module):

  1552     return

  1554 def register_functions_ns3_internal(module, root_module):

  1555     return

  1557 def register_functions_ns3_olsr(module, root_module):

  1558     return

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