bindings/python/ns3_module_simulator.py
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--
Added tag ns-3.5 for changeset c975274c9707
     1 from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandlers
     2 
     3 def register_types(module):
     4     root_module = module.get_root()
     5     
     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')
    68     
    69     ## Register a nested module for the namespace Config
    70     
    71     nested_module = module.add_cpp_namespace('Config')
    72     register_types_ns3_Config(nested_module)
    73     
    74     
    75     ## Register a nested module for the namespace TimeStepPrecision
    76     
    77     nested_module = module.add_cpp_namespace('TimeStepPrecision')
    78     register_types_ns3_TimeStepPrecision(nested_module)
    79     
    80     
    81     ## Register a nested module for the namespace addressUtils
    82     
    83     nested_module = module.add_cpp_namespace('addressUtils')
    84     register_types_ns3_addressUtils(nested_module)
    85     
    86     
    87     ## Register a nested module for the namespace internal
    88     
    89     nested_module = module.add_cpp_namespace('internal')
    90     register_types_ns3_internal(nested_module)
    91     
    92     
    93     ## Register a nested module for the namespace olsr
    94     
    95     nested_module = module.add_cpp_namespace('olsr')
    96     register_types_ns3_olsr(nested_module)
    97     
    98 
    99 def register_types_ns3_Config(module):
   100     root_module = module.get_root()
   101     
   102 
   103 def register_types_ns3_TimeStepPrecision(module):
   104     root_module = module.get_root()
   105     
   106     ## nstime.h: ns3::TimeStepPrecision::precision_t [enumeration]
   107     module.add_enum('precision_t', ['S', 'MS', 'US', 'NS', 'PS', 'FS'])
   108 
   109 def register_types_ns3_addressUtils(module):
   110     root_module = module.get_root()
   111     
   112 
   113 def register_types_ns3_internal(module):
   114     root_module = module.get_root()
   115     
   116 
   117 def register_types_ns3_olsr(module):
   118     root_module = module.get_root()
   119     
   120 
   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
   149 
   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
   189 
   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
   223 
   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
   275 
   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
   355 
   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
   398 
   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
   451 
   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
   551 
   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
   595 
   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
   662 
   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
   679 
   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
   690 
   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
   727 
   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
   739 
   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
   753 
   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
   840 
   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
   937 
   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
   944 
   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
   977 
   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
  1075 
  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
  1112 
  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
  1204 
  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
  1241 
  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
  1278 
  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
  1315 
  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
  1352 
  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
  1475 
  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
  1536 
  1537 def register_functions_ns3_Config(module, root_module):
  1538     return
  1539 
  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
  1550 
  1551 def register_functions_ns3_addressUtils(module, root_module):
  1552     return
  1553 
  1554 def register_functions_ns3_internal(module, root_module):
  1555     return
  1556 
  1557 def register_functions_ns3_olsr(module, root_module):
  1558     return
  1559