bindings/python/ns3_module_core.py
changeset 3468 0bb5275704fc
parent 3460 99698bc858e8
child 3474 dac9146297c8
equal deleted inserted replaced
3467:351f5847dda5 3468:0bb5275704fc
     1 from pybindgen import Module, FileCodeSink, write_preamble, param, retval
     1 from pybindgen import Module, FileCodeSink, param, retval, cppclass
     2 
     2 
     3 def register_types(module):
     3 def register_types(module):
     4     root_module = module.get_root()
     4     root_module = module.get_root()
     5     
     5     
     6     ## random-variable.h: ns3::RandomVariable [class]
     6     ## random-variable.h: ns3::RandomVariable [class]
     8     ## random-variable.h: ns3::TriangularVariable [class]
     8     ## random-variable.h: ns3::TriangularVariable [class]
     9     module.add_class('TriangularVariable', parent=root_module['ns3::RandomVariable'])
     9     module.add_class('TriangularVariable', parent=root_module['ns3::RandomVariable'])
    10     ## global-value.h: ns3::GlobalValue [class]
    10     ## global-value.h: ns3::GlobalValue [class]
    11     module.add_class('GlobalValue')
    11     module.add_class('GlobalValue')
    12     ## ref-count-base.h: ns3::RefCountBase [class]
    12     ## ref-count-base.h: ns3::RefCountBase [class]
    13     module.add_class('RefCountBase', incref_method='Ref', automatic_type_narrowing=True, decref_method='Unref', peekref_method='GetReferenceCount')
    13     module.add_class('RefCountBase', automatic_type_narrowing=True, memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
    14     ## type-id.h: ns3::TypeId [class]
    14     ## type-id.h: ns3::TypeId [class]
    15     module.add_class('TypeId')
    15     module.add_class('TypeId')
    16     ## type-id.h: ns3::TypeId::AttributeFlag [enumeration]
    16     ## type-id.h: ns3::TypeId::AttributeFlag [enumeration]
    17     module.add_enum('AttributeFlag', ['ATTR_GET', 'ATTR_SET', 'ATTR_CONSTRUCT', 'ATTR_SGC'], outer_class=root_module['ns3::TypeId'])
    17     module.add_enum('AttributeFlag', ['ATTR_GET', 'ATTR_SET', 'ATTR_CONSTRUCT', 'ATTR_SGC'], outer_class=root_module['ns3::TypeId'])
    18     ## type-id.h: ns3::TypeId::AttributeInfo [struct]
    18     ## type-id.h: ns3::TypeId::AttributeInfo [struct]
    19     module.add_class('AttributeInfo', outer_class=root_module['ns3::TypeId'])
    19     module.add_class('AttributeInfo', outer_class=root_module['ns3::TypeId'])
    20     ## system-wall-clock-ms.h: ns3::SystemWallClockMs [class]
    20     ## system-wall-clock-ms.h: ns3::SystemWallClockMs [class]
    21     module.add_class('SystemWallClockMs')
    21     module.add_class('SystemWallClockMs')
    22     ## callback.h: ns3::CallbackImplBase [class]
    22     ## callback.h: ns3::CallbackImplBase [class]
    23     module.add_class('CallbackImplBase', incref_method='Ref', allow_subclassing=True, decref_method='Unref', peekref_method='GetReferenceCount')
    23     module.add_class('CallbackImplBase', allow_subclassing=True, memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
    24     ## system-mutex.h: ns3::CriticalSection [class]
    24     ## system-mutex.h: ns3::CriticalSection [class]
    25     module.add_class('CriticalSection')
    25     module.add_class('CriticalSection')
    26     ## trace-source-accessor.h: ns3::TraceSourceAccessor [class]
    26     ## trace-source-accessor.h: ns3::TraceSourceAccessor [class]
    27     module.add_class('TraceSourceAccessor', allow_subclassing=True)
    27     module.add_class('TraceSourceAccessor', allow_subclassing=True)
    28     ## attribute.h: ns3::AttributeChecker [class]
    28     ## attribute.h: ns3::AttributeChecker [class]
    29     module.add_class('AttributeChecker', incref_method='Ref', allow_subclassing=False, automatic_type_narrowing=True, decref_method='Unref', parent=root_module['ns3::RefCountBase'])
    29     module.add_class('AttributeChecker', allow_subclassing=False, automatic_type_narrowing=True, parent=root_module['ns3::RefCountBase'])
    30     ## random-variable.h: ns3::RandomVariableChecker [class]
    30     ## random-variable.h: ns3::RandomVariableChecker [class]
    31     module.add_class('RandomVariableChecker', parent=root_module['ns3::AttributeChecker'])
    31     module.add_class('RandomVariableChecker', parent=root_module['ns3::AttributeChecker'])
    32     ## system-mutex.h: ns3::SystemMutex [class]
    32     ## system-mutex.h: ns3::SystemMutex [class]
    33     module.add_class('SystemMutex')
    33     module.add_class('SystemMutex')
    34     ## random-variable.h: ns3::NormalVariable [class]
    34     ## random-variable.h: ns3::NormalVariable [class]
   118     ## random-variable.h: ns3::DeterministicVariable [class]
   118     ## random-variable.h: ns3::DeterministicVariable [class]
   119     module.add_class('DeterministicVariable', parent=root_module['ns3::RandomVariable'])
   119     module.add_class('DeterministicVariable', parent=root_module['ns3::RandomVariable'])
   120     ## attribute-list.h: ns3::AttributeList [class]
   120     ## attribute-list.h: ns3::AttributeList [class]
   121     module.add_class('AttributeList')
   121     module.add_class('AttributeList')
   122     ## attribute.h: ns3::AttributeValue [class]
   122     ## attribute.h: ns3::AttributeValue [class]
   123     module.add_class('AttributeValue', incref_method='Ref', allow_subclassing=False, automatic_type_narrowing=True, decref_method='Unref', parent=root_module['ns3::RefCountBase'])
   123     module.add_class('AttributeValue', allow_subclassing=False, automatic_type_narrowing=True, parent=root_module['ns3::RefCountBase'])
   124     ## random-variable.h: ns3::UniformVariable [class]
   124     ## random-variable.h: ns3::UniformVariable [class]
   125     module.add_class('UniformVariable', parent=root_module['ns3::RandomVariable'])
   125     module.add_class('UniformVariable', parent=root_module['ns3::RandomVariable'])
   126     ## object.h: ns3::Object [class]
   126     ## object.h: ns3::Object [class]
   127     module.add_class('Object', incref_method='Ref', automatic_type_narrowing=True, decref_method='Unref', parent=root_module['ns3::ObjectBase'], peekref_method='GetReferenceCount')
   127     module.add_class('Object', automatic_type_narrowing=True, parent=root_module['ns3::ObjectBase'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
   128     ## object.h: ns3::Object::AggregateIterator [class]
   128     ## object.h: ns3::Object::AggregateIterator [class]
   129     module.add_class('AggregateIterator', outer_class=root_module['ns3::Object'])
   129     module.add_class('AggregateIterator', outer_class=root_module['ns3::Object'])
   130     ## system-condition.h: ns3::SystemCondition [class]
   130     ## system-condition.h: ns3::SystemCondition [class]
   131     module.add_class('SystemCondition')
   131     module.add_class('SystemCondition')
   132     ## random-variable.h: ns3::SequentialVariable [class]
   132     ## random-variable.h: ns3::SequentialVariable [class]
   296     register_Ns3TracedValue__Unsigned_int_methods(root_module, root_module['ns3::TracedValue< unsigned int >'])
   296     register_Ns3TracedValue__Unsigned_int_methods(root_module, root_module['ns3::TracedValue< unsigned int >'])
   297     return
   297     return
   298 
   298 
   299 def register_Ns3RandomVariable_methods(root_module, cls):
   299 def register_Ns3RandomVariable_methods(root_module, cls):
   300     ## random-variable.h: ns3::RandomVariable::RandomVariable() [constructor]
   300     ## random-variable.h: ns3::RandomVariable::RandomVariable() [constructor]
   301     cls.add_constructor([], visibility='public')
   301     cls.add_constructor([])
   302     ## random-variable.h: ns3::RandomVariable::RandomVariable(ns3::RandomVariable const & o) [copy constructor]
   302     ## random-variable.h: ns3::RandomVariable::RandomVariable(ns3::RandomVariable const & o) [copy constructor]
   303     cls.add_constructor([param('ns3::RandomVariable&', 'o', is_const=True)], visibility='public')
   303     cls.add_constructor([param('ns3::RandomVariable&', 'o', is_const=True)])
   304     ## random-variable.h: uint32_t ns3::RandomVariable::GetInteger() const [member function]
   304     ## random-variable.h: uint32_t ns3::RandomVariable::GetInteger() const [member function]
   305     cls.add_method('GetInteger', 'uint32_t', [], is_const=True)
   305     cls.add_method('GetInteger', 
       
   306                    'uint32_t', 
       
   307                    [], 
       
   308                    is_const=True)
   306     ## random-variable.h: void ns3::RandomVariable::GetSeed(uint32_t * seed) const [member function]
   309     ## random-variable.h: void ns3::RandomVariable::GetSeed(uint32_t * seed) const [member function]
   307     cls.add_method('GetSeed', 'void', [param('uint32_t *', 'seed', direction=2, array_length=6)], is_const=True)
   310     cls.add_method('GetSeed', 
       
   311                    'void', 
       
   312                    [param('uint32_t *', 'seed', direction=2, array_length=6)], 
       
   313                    is_const=True)
   308     ## random-variable.h: double ns3::RandomVariable::GetValue() const [member function]
   314     ## random-variable.h: double ns3::RandomVariable::GetValue() const [member function]
   309     cls.add_method('GetValue', 'double', [], is_const=True)
   315     cls.add_method('GetValue', 
       
   316                    'double', 
       
   317                    [], 
       
   318                    is_const=True)
   310     ## random-variable.h: static void ns3::RandomVariable::SetRunNumber(uint32_t n) [member function]
   319     ## random-variable.h: static void ns3::RandomVariable::SetRunNumber(uint32_t n) [member function]
   311     cls.add_method('SetRunNumber', 'void', [param('uint32_t', 'n')], is_static=True)
   320     cls.add_method('SetRunNumber', 
       
   321                    'void', 
       
   322                    [param('uint32_t', 'n')], 
       
   323                    is_static=True)
   312     ## random-variable.h: static void ns3::RandomVariable::UseDevRandom(bool udr=true) [member function]
   324     ## random-variable.h: static void ns3::RandomVariable::UseDevRandom(bool udr=true) [member function]
   313     cls.add_method('UseDevRandom', 'void', [param('bool', 'udr', default_value='true')], is_static=True)
   325     cls.add_method('UseDevRandom', 
       
   326                    'void', 
       
   327                    [param('bool', 'udr', default_value='true')], 
       
   328                    is_static=True)
   314     ## random-variable.h: static void ns3::RandomVariable::UseGlobalSeed(uint32_t s0, uint32_t s1, uint32_t s2, uint32_t s3, uint32_t s4, uint32_t s5) [member function]
   329     ## random-variable.h: static void ns3::RandomVariable::UseGlobalSeed(uint32_t s0, uint32_t s1, uint32_t s2, uint32_t s3, uint32_t s4, uint32_t s5) [member function]
   315     cls.add_method('UseGlobalSeed', 'void', [param('uint32_t', 's0'), param('uint32_t', 's1'), param('uint32_t', 's2'), param('uint32_t', 's3'), param('uint32_t', 's4'), param('uint32_t', 's5')], is_static=True)
   330     cls.add_method('UseGlobalSeed', 
       
   331                    'void', 
       
   332                    [param('uint32_t', 's0'), param('uint32_t', 's1'), param('uint32_t', 's2'), param('uint32_t', 's3'), param('uint32_t', 's4'), param('uint32_t', 's5')], 
       
   333                    is_static=True)
   316     cls.add_output_stream_operator()
   334     cls.add_output_stream_operator()
   317     return
   335     return
   318 
   336 
   319 def register_Ns3TriangularVariable_methods(root_module, cls):
   337 def register_Ns3TriangularVariable_methods(root_module, cls):
   320     ## random-variable.h: ns3::TriangularVariable::TriangularVariable() [constructor]
   338     ## random-variable.h: ns3::TriangularVariable::TriangularVariable() [constructor]
   321     cls.add_constructor([], visibility='public')
   339     cls.add_constructor([])
   322     ## random-variable.h: ns3::TriangularVariable::TriangularVariable(double s, double l, double mean) [constructor]
   340     ## random-variable.h: ns3::TriangularVariable::TriangularVariable(double s, double l, double mean) [constructor]
   323     cls.add_constructor([param('double', 's'), param('double', 'l'), param('double', 'mean')], visibility='public')
   341     cls.add_constructor([param('double', 's'), param('double', 'l'), param('double', 'mean')])
   324     ## random-variable.h: static double ns3::TriangularVariable::GetSingleValue(double s, double l, double mean) [member function]
   342     ## random-variable.h: static double ns3::TriangularVariable::GetSingleValue(double s, double l, double mean) [member function]
   325     cls.add_method('GetSingleValue', 'double', [param('double', 's'), param('double', 'l'), param('double', 'mean')], is_static=True)
   343     cls.add_method('GetSingleValue', 
       
   344                    'double', 
       
   345                    [param('double', 's'), param('double', 'l'), param('double', 'mean')], 
       
   346                    is_static=True)
   326     return
   347     return
   327 
   348 
   328 def register_Ns3GlobalValue_methods(root_module, cls):
   349 def register_Ns3GlobalValue_methods(root_module, cls):
   329     ## global-value.h: ns3::GlobalValue::GlobalValue(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr<ns3::AttributeChecker const> checker) [constructor]
   350     ## global-value.h: ns3::GlobalValue::GlobalValue(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr<ns3::AttributeChecker const> checker) [constructor]
   330     cls.add_constructor([param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue&', 'initialValue', is_const=True), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], visibility='public')
   351     cls.add_constructor([param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue&', 'initialValue', is_const=True), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')])
   331     ## global-value.h: std::string ns3::GlobalValue::GetName() const [member function]
   352     ## global-value.h: std::string ns3::GlobalValue::GetName() const [member function]
   332     cls.add_method('GetName', 'std::string', [], is_const=True)
   353     cls.add_method('GetName', 
       
   354                    'std::string', 
       
   355                    [], 
       
   356                    is_const=True)
   333     ## global-value.h: std::string ns3::GlobalValue::GetHelp() const [member function]
   357     ## global-value.h: std::string ns3::GlobalValue::GetHelp() const [member function]
   334     cls.add_method('GetHelp', 'std::string', [], is_const=True)
   358     cls.add_method('GetHelp', 
       
   359                    'std::string', 
       
   360                    [], 
       
   361                    is_const=True)
   335     ## global-value.h: void ns3::GlobalValue::GetValue(ns3::AttributeValue & value) const [member function]
   362     ## global-value.h: void ns3::GlobalValue::GetValue(ns3::AttributeValue & value) const [member function]
   336     cls.add_method('GetValue', 'void', [param('ns3::AttributeValue&', 'value')], is_const=True)
   363     cls.add_method('GetValue', 
       
   364                    'void', 
       
   365                    [param('ns3::AttributeValue&', 'value')], 
       
   366                    is_const=True)
   337     ## global-value.h: ns3::Ptr<ns3::AttributeChecker const> ns3::GlobalValue::GetChecker() const [member function]
   367     ## global-value.h: ns3::Ptr<ns3::AttributeChecker const> ns3::GlobalValue::GetChecker() const [member function]
   338     cls.add_method('GetChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [], is_const=True)
   368     cls.add_method('GetChecker', 
       
   369                    'ns3::Ptr< ns3::AttributeChecker const >', 
       
   370                    [], 
       
   371                    is_const=True)
   339     ## global-value.h: bool ns3::GlobalValue::SetValue(ns3::AttributeValue const & value) [member function]
   372     ## global-value.h: bool ns3::GlobalValue::SetValue(ns3::AttributeValue const & value) [member function]
   340     cls.add_method('SetValue', 'bool', [param('ns3::AttributeValue&', 'value', is_const=True)])
   373     cls.add_method('SetValue', 
       
   374                    'bool', 
       
   375                    [param('ns3::AttributeValue&', 'value', is_const=True)])
   341     ## global-value.h: static void ns3::GlobalValue::Bind(std::string name, ns3::AttributeValue const & value) [member function]
   376     ## global-value.h: static void ns3::GlobalValue::Bind(std::string name, ns3::AttributeValue const & value) [member function]
   342     cls.add_method('Bind', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)], is_static=True)
   377     cls.add_method('Bind', 
       
   378                    'void', 
       
   379                    [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)], 
       
   380                    is_static=True)
   343     ## global-value.h: static bool ns3::GlobalValue::BindFailSafe(std::string name, ns3::AttributeValue const & value) [member function]
   381     ## global-value.h: static bool ns3::GlobalValue::BindFailSafe(std::string name, ns3::AttributeValue const & value) [member function]
   344     cls.add_method('BindFailSafe', 'bool', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)], is_static=True)
   382     cls.add_method('BindFailSafe', 
       
   383                    'bool', 
       
   384                    [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)], 
       
   385                    is_static=True)
   345     ## global-value.h: static __gnu_cxx::__normal_iterator<ns3::GlobalValue* const*,std::vector<ns3::GlobalValue*, std::allocator<ns3::GlobalValue*> > > ns3::GlobalValue::Begin() [member function]
   386     ## global-value.h: static __gnu_cxx::__normal_iterator<ns3::GlobalValue* const*,std::vector<ns3::GlobalValue*, std::allocator<ns3::GlobalValue*> > > ns3::GlobalValue::Begin() [member function]
   346     cls.add_method('Begin', '__gnu_cxx::__normal_iterator< ns3::GlobalValue* const*, std::vector< ns3::GlobalValue*, std::allocator< ns3::GlobalValue* > > >', [], is_static=True)
   387     cls.add_method('Begin', 
       
   388                    '__gnu_cxx::__normal_iterator< ns3::GlobalValue* const*, std::vector< ns3::GlobalValue*, std::allocator< ns3::GlobalValue* > > >', 
       
   389                    [], 
       
   390                    is_static=True)
   347     ## global-value.h: static __gnu_cxx::__normal_iterator<ns3::GlobalValue* const*,std::vector<ns3::GlobalValue*, std::allocator<ns3::GlobalValue*> > > ns3::GlobalValue::End() [member function]
   391     ## global-value.h: static __gnu_cxx::__normal_iterator<ns3::GlobalValue* const*,std::vector<ns3::GlobalValue*, std::allocator<ns3::GlobalValue*> > > ns3::GlobalValue::End() [member function]
   348     cls.add_method('End', '__gnu_cxx::__normal_iterator< ns3::GlobalValue* const*, std::vector< ns3::GlobalValue*, std::allocator< ns3::GlobalValue* > > >', [], is_static=True)
   392     cls.add_method('End', 
       
   393                    '__gnu_cxx::__normal_iterator< ns3::GlobalValue* const*, std::vector< ns3::GlobalValue*, std::allocator< ns3::GlobalValue* > > >', 
       
   394                    [], 
       
   395                    is_static=True)
   349     return
   396     return
   350 
   397 
   351 def register_Ns3RefCountBase_methods(root_module, cls):
   398 def register_Ns3RefCountBase_methods(root_module, cls):
   352     ## ref-count-base.h: ns3::RefCountBase::RefCountBase() [constructor]
   399     ## ref-count-base.h: ns3::RefCountBase::RefCountBase() [constructor]
   353     cls.add_constructor([], visibility='public')
   400     cls.add_constructor([])
   354     ## ref-count-base.h: ns3::RefCountBase::RefCountBase(ns3::RefCountBase const & o) [copy constructor]
   401     ## ref-count-base.h: ns3::RefCountBase::RefCountBase(ns3::RefCountBase const & o) [copy constructor]
   355     cls.add_constructor([param('ns3::RefCountBase&', 'o', is_const=True)], visibility='public')
   402     cls.add_constructor([param('ns3::RefCountBase&', 'o', is_const=True)])
   356     return
   403     return
   357 
   404 
   358 def register_Ns3TypeId_methods(root_module, cls):
   405 def register_Ns3TypeId_methods(root_module, cls):
   359     ## type-id.h: ns3::TypeId::TypeId(ns3::TypeId const & arg0) [copy constructor]
   406     ## type-id.h: ns3::TypeId::TypeId(ns3::TypeId const & arg0) [copy constructor]
   360     cls.add_constructor([param('ns3::TypeId&', 'arg0', is_const=True)], visibility='public')
   407     cls.add_constructor([param('ns3::TypeId&', 'arg0', is_const=True)])
   361     ## type-id.h: ns3::TypeId::TypeId(char const * name) [constructor]
   408     ## type-id.h: ns3::TypeId::TypeId(char const * name) [constructor]
   362     cls.add_constructor([param('char *', 'name', transfer_ownership=False, is_const=True)], visibility='public')
   409     cls.add_constructor([param('char *', 'name', transfer_ownership=False, is_const=True)])
   363     ## type-id.h: ns3::TypeId::TypeId() [constructor]
   410     ## type-id.h: ns3::TypeId::TypeId() [constructor]
   364     cls.add_constructor([], visibility='public')
   411     cls.add_constructor([])
   365     ## type-id.h: ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr<ns3::AttributeAccessor const> accessor, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   412     ## type-id.h: ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr<ns3::AttributeAccessor const> accessor, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   366     cls.add_method('AddAttribute', 'ns3::TypeId', [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue&', 'initialValue', is_const=True), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')])
   413     cls.add_method('AddAttribute', 
       
   414                    'ns3::TypeId', 
       
   415                    [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue&', 'initialValue', is_const=True), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')])
   367     ## type-id.h: ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, uint32_t flags, ns3::AttributeValue const & initialValue, ns3::Ptr<ns3::AttributeAccessor const> accessor, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   416     ## type-id.h: ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, uint32_t flags, ns3::AttributeValue const & initialValue, ns3::Ptr<ns3::AttributeAccessor const> accessor, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   368     cls.add_method('AddAttribute', 'ns3::TypeId', [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue&', 'initialValue', is_const=True), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')])
   417     cls.add_method('AddAttribute', 
       
   418                    'ns3::TypeId', 
       
   419                    [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue&', 'initialValue', is_const=True), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')])
   369     ## type-id.h: ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr<ns3::TraceSourceAccessor const> accessor) [member function]
   420     ## type-id.h: ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr<ns3::TraceSourceAccessor const> accessor) [member function]
   370     cls.add_method('AddTraceSource', 'ns3::TypeId', [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')])
   421     cls.add_method('AddTraceSource', 
       
   422                    'ns3::TypeId', 
       
   423                    [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')])
   371     ## type-id.h: ns3::Ptr<ns3::AttributeAccessor const> ns3::TypeId::GetAttributeAccessor(uint32_t i) const [member function]
   424     ## type-id.h: ns3::Ptr<ns3::AttributeAccessor const> ns3::TypeId::GetAttributeAccessor(uint32_t i) const [member function]
   372     cls.add_method('GetAttributeAccessor', 'ns3::Ptr< ns3::AttributeAccessor const >', [param('uint32_t', 'i')], is_const=True)
   425     cls.add_method('GetAttributeAccessor', 
       
   426                    'ns3::Ptr< ns3::AttributeAccessor const >', 
       
   427                    [param('uint32_t', 'i')], 
       
   428                    is_const=True)
   373     ## type-id.h: ns3::Ptr<ns3::AttributeChecker const> ns3::TypeId::GetAttributeChecker(uint32_t i) const [member function]
   429     ## type-id.h: ns3::Ptr<ns3::AttributeChecker const> ns3::TypeId::GetAttributeChecker(uint32_t i) const [member function]
   374     cls.add_method('GetAttributeChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [param('uint32_t', 'i')], is_const=True)
   430     cls.add_method('GetAttributeChecker', 
       
   431                    'ns3::Ptr< ns3::AttributeChecker const >', 
       
   432                    [param('uint32_t', 'i')], 
       
   433                    is_const=True)
   375     ## type-id.h: uint32_t ns3::TypeId::GetAttributeFlags(uint32_t i) const [member function]
   434     ## type-id.h: uint32_t ns3::TypeId::GetAttributeFlags(uint32_t i) const [member function]
   376     cls.add_method('GetAttributeFlags', 'uint32_t', [param('uint32_t', 'i')], is_const=True)
   435     cls.add_method('GetAttributeFlags', 
       
   436                    'uint32_t', 
       
   437                    [param('uint32_t', 'i')], 
       
   438                    is_const=True)
   377     ## type-id.h: std::string ns3::TypeId::GetAttributeFullName(uint32_t i) const [member function]
   439     ## type-id.h: std::string ns3::TypeId::GetAttributeFullName(uint32_t i) const [member function]
   378     cls.add_method('GetAttributeFullName', 'std::string', [param('uint32_t', 'i')], is_const=True)
   440     cls.add_method('GetAttributeFullName', 
       
   441                    'std::string', 
       
   442                    [param('uint32_t', 'i')], 
       
   443                    is_const=True)
   379     ## type-id.h: std::string ns3::TypeId::GetAttributeHelp(uint32_t i) const [member function]
   444     ## type-id.h: std::string ns3::TypeId::GetAttributeHelp(uint32_t i) const [member function]
   380     cls.add_method('GetAttributeHelp', 'std::string', [param('uint32_t', 'i')], is_const=True)
   445     cls.add_method('GetAttributeHelp', 
       
   446                    'std::string', 
       
   447                    [param('uint32_t', 'i')], 
       
   448                    is_const=True)
   381     ## type-id.h: ns3::Ptr<ns3::AttributeValue const> ns3::TypeId::GetAttributeInitialValue(uint32_t i) const [member function]
   449     ## type-id.h: ns3::Ptr<ns3::AttributeValue const> ns3::TypeId::GetAttributeInitialValue(uint32_t i) const [member function]
   382     cls.add_method('GetAttributeInitialValue', 'ns3::Ptr< ns3::AttributeValue const >', [param('uint32_t', 'i')], is_const=True)
   450     cls.add_method('GetAttributeInitialValue', 
       
   451                    'ns3::Ptr< ns3::AttributeValue const >', 
       
   452                    [param('uint32_t', 'i')], 
       
   453                    is_const=True)
   383     ## type-id.h: uint32_t ns3::TypeId::GetAttributeN() const [member function]
   454     ## type-id.h: uint32_t ns3::TypeId::GetAttributeN() const [member function]
   384     cls.add_method('GetAttributeN', 'uint32_t', [], is_const=True)
   455     cls.add_method('GetAttributeN', 
       
   456                    'uint32_t', 
       
   457                    [], 
       
   458                    is_const=True)
   385     ## type-id.h: std::string ns3::TypeId::GetAttributeName(uint32_t i) const [member function]
   459     ## type-id.h: std::string ns3::TypeId::GetAttributeName(uint32_t i) const [member function]
   386     cls.add_method('GetAttributeName', 'std::string', [param('uint32_t', 'i')], is_const=True)
   460     cls.add_method('GetAttributeName', 
       
   461                    'std::string', 
       
   462                    [param('uint32_t', 'i')], 
       
   463                    is_const=True)
   387     ## type-id.h: ns3::Callback<ns3::ObjectBase*,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ns3::TypeId::GetConstructor() const [member function]
   464     ## type-id.h: ns3::Callback<ns3::ObjectBase*,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ns3::TypeId::GetConstructor() const [member function]
   388     cls.add_method('GetConstructor', 'ns3::Callback< ns3::ObjectBase*, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', [], is_const=True)
   465     cls.add_method('GetConstructor', 
       
   466                    'ns3::Callback< ns3::ObjectBase*, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 
       
   467                    [], 
       
   468                    is_const=True)
   389     ## type-id.h: std::string ns3::TypeId::GetGroupName() const [member function]
   469     ## type-id.h: std::string ns3::TypeId::GetGroupName() const [member function]
   390     cls.add_method('GetGroupName', 'std::string', [], is_const=True)
   470     cls.add_method('GetGroupName', 
       
   471                    'std::string', 
       
   472                    [], 
       
   473                    is_const=True)
   391     ## type-id.h: std::string ns3::TypeId::GetName() const [member function]
   474     ## type-id.h: std::string ns3::TypeId::GetName() const [member function]
   392     cls.add_method('GetName', 'std::string', [], is_const=True)
   475     cls.add_method('GetName', 
       
   476                    'std::string', 
       
   477                    [], 
       
   478                    is_const=True)
   393     ## type-id.h: ns3::TypeId ns3::TypeId::GetParent() const [member function]
   479     ## type-id.h: ns3::TypeId ns3::TypeId::GetParent() const [member function]
   394     cls.add_method('GetParent', 'ns3::TypeId', [], is_const=True)
   480     cls.add_method('GetParent', 
       
   481                    'ns3::TypeId', 
       
   482                    [], 
       
   483                    is_const=True)
   395     ## type-id.h: static ns3::TypeId ns3::TypeId::GetRegistered(uint32_t i) [member function]
   484     ## type-id.h: static ns3::TypeId ns3::TypeId::GetRegistered(uint32_t i) [member function]
   396     cls.add_method('GetRegistered', 'ns3::TypeId', [param('uint32_t', 'i')], is_static=True)
   485     cls.add_method('GetRegistered', 
       
   486                    'ns3::TypeId', 
       
   487                    [param('uint32_t', 'i')], 
       
   488                    is_static=True)
   397     ## type-id.h: static uint32_t ns3::TypeId::GetRegisteredN() [member function]
   489     ## type-id.h: static uint32_t ns3::TypeId::GetRegisteredN() [member function]
   398     cls.add_method('GetRegisteredN', 'uint32_t', [], is_static=True)
   490     cls.add_method('GetRegisteredN', 
       
   491                    'uint32_t', 
       
   492                    [], 
       
   493                    is_static=True)
   399     ## type-id.h: ns3::Ptr<ns3::TraceSourceAccessor const> ns3::TypeId::GetTraceSourceAccessor(uint32_t i) const [member function]
   494     ## type-id.h: ns3::Ptr<ns3::TraceSourceAccessor const> ns3::TypeId::GetTraceSourceAccessor(uint32_t i) const [member function]
   400     cls.add_method('GetTraceSourceAccessor', 'ns3::Ptr< ns3::TraceSourceAccessor const >', [param('uint32_t', 'i')], is_const=True)
   495     cls.add_method('GetTraceSourceAccessor', 
       
   496                    'ns3::Ptr< ns3::TraceSourceAccessor const >', 
       
   497                    [param('uint32_t', 'i')], 
       
   498                    is_const=True)
   401     ## type-id.h: std::string ns3::TypeId::GetTraceSourceHelp(uint32_t i) const [member function]
   499     ## type-id.h: std::string ns3::TypeId::GetTraceSourceHelp(uint32_t i) const [member function]
   402     cls.add_method('GetTraceSourceHelp', 'std::string', [param('uint32_t', 'i')], is_const=True)
   500     cls.add_method('GetTraceSourceHelp', 
       
   501                    'std::string', 
       
   502                    [param('uint32_t', 'i')], 
       
   503                    is_const=True)
   403     ## type-id.h: uint32_t ns3::TypeId::GetTraceSourceN() const [member function]
   504     ## type-id.h: uint32_t ns3::TypeId::GetTraceSourceN() const [member function]
   404     cls.add_method('GetTraceSourceN', 'uint32_t', [], is_const=True)
   505     cls.add_method('GetTraceSourceN', 
       
   506                    'uint32_t', 
       
   507                    [], 
       
   508                    is_const=True)
   405     ## type-id.h: std::string ns3::TypeId::GetTraceSourceName(uint32_t i) const [member function]
   509     ## type-id.h: std::string ns3::TypeId::GetTraceSourceName(uint32_t i) const [member function]
   406     cls.add_method('GetTraceSourceName', 'std::string', [param('uint32_t', 'i')], is_const=True)
   510     cls.add_method('GetTraceSourceName', 
       
   511                    'std::string', 
       
   512                    [param('uint32_t', 'i')], 
       
   513                    is_const=True)
   407     ## type-id.h: uint16_t ns3::TypeId::GetUid() const [member function]
   514     ## type-id.h: uint16_t ns3::TypeId::GetUid() const [member function]
   408     cls.add_method('GetUid', 'uint16_t', [], is_const=True)
   515     cls.add_method('GetUid', 
       
   516                    'uint16_t', 
       
   517                    [], 
       
   518                    is_const=True)
   409     ## type-id.h: bool ns3::TypeId::HasConstructor() const [member function]
   519     ## type-id.h: bool ns3::TypeId::HasConstructor() const [member function]
   410     cls.add_method('HasConstructor', 'bool', [], is_const=True)
   520     cls.add_method('HasConstructor', 
       
   521                    'bool', 
       
   522                    [], 
       
   523                    is_const=True)
   411     ## type-id.h: bool ns3::TypeId::HasParent() const [member function]
   524     ## type-id.h: bool ns3::TypeId::HasParent() const [member function]
   412     cls.add_method('HasParent', 'bool', [], is_const=True)
   525     cls.add_method('HasParent', 
       
   526                    'bool', 
       
   527                    [], 
       
   528                    is_const=True)
   413     ## type-id.h: ns3::TypeId ns3::TypeId::HideFromDocumentation() [member function]
   529     ## type-id.h: ns3::TypeId ns3::TypeId::HideFromDocumentation() [member function]
   414     cls.add_method('HideFromDocumentation', 'ns3::TypeId', [])
   530     cls.add_method('HideFromDocumentation', 
       
   531                    'ns3::TypeId', 
       
   532                    [])
   415     ## type-id.h: bool ns3::TypeId::IsChildOf(ns3::TypeId other) const [member function]
   533     ## type-id.h: bool ns3::TypeId::IsChildOf(ns3::TypeId other) const [member function]
   416     cls.add_method('IsChildOf', 'bool', [param('ns3::TypeId', 'other')], is_const=True)
   534     cls.add_method('IsChildOf', 
       
   535                    'bool', 
       
   536                    [param('ns3::TypeId', 'other')], 
       
   537                    is_const=True)
   417     ## type-id.h: bool ns3::TypeId::LookupAttributeByName(std::string name, ns3::TypeId::AttributeInfo * info) const [member function]
   538     ## type-id.h: bool ns3::TypeId::LookupAttributeByName(std::string name, ns3::TypeId::AttributeInfo * info) const [member function]
   418     cls.add_method('LookupAttributeByName', 'bool', [param('std::string', 'name'), param('ns3::TypeId::AttributeInfo *', 'info', transfer_ownership=False)], is_const=True)
   539     cls.add_method('LookupAttributeByName', 
       
   540                    'bool', 
       
   541                    [param('std::string', 'name'), param('ns3::TypeId::AttributeInfo *', 'info', transfer_ownership=False)], 
       
   542                    is_const=True)
   419     ## type-id.h: static ns3::TypeId ns3::TypeId::LookupByName(std::string name) [member function]
   543     ## type-id.h: static ns3::TypeId ns3::TypeId::LookupByName(std::string name) [member function]
   420     cls.add_method('LookupByName', 'ns3::TypeId', [param('std::string', 'name')], is_static=True)
   544     cls.add_method('LookupByName', 
       
   545                    'ns3::TypeId', 
       
   546                    [param('std::string', 'name')], 
       
   547                    is_static=True)
   421     ## type-id.h: static bool ns3::TypeId::LookupByNameFailSafe(std::string name, ns3::TypeId * tid) [member function]
   548     ## type-id.h: static bool ns3::TypeId::LookupByNameFailSafe(std::string name, ns3::TypeId * tid) [member function]
   422     cls.add_method('LookupByNameFailSafe', 'bool', [param('std::string', 'name'), param('ns3::TypeId *', 'tid', transfer_ownership=False)], is_static=True)
   549     cls.add_method('LookupByNameFailSafe', 
       
   550                    'bool', 
       
   551                    [param('std::string', 'name'), param('ns3::TypeId *', 'tid', transfer_ownership=False)], 
       
   552                    is_static=True)
   423     ## type-id.h: ns3::Ptr<ns3::TraceSourceAccessor const> ns3::TypeId::LookupTraceSourceByName(std::string name) const [member function]
   553     ## type-id.h: ns3::Ptr<ns3::TraceSourceAccessor const> ns3::TypeId::LookupTraceSourceByName(std::string name) const [member function]
   424     cls.add_method('LookupTraceSourceByName', 'ns3::Ptr< ns3::TraceSourceAccessor const >', [param('std::string', 'name')], is_const=True)
   554     cls.add_method('LookupTraceSourceByName', 
       
   555                    'ns3::Ptr< ns3::TraceSourceAccessor const >', 
       
   556                    [param('std::string', 'name')], 
       
   557                    is_const=True)
   425     ## type-id.h: bool ns3::TypeId::MustHideFromDocumentation() const [member function]
   558     ## type-id.h: bool ns3::TypeId::MustHideFromDocumentation() const [member function]
   426     cls.add_method('MustHideFromDocumentation', 'bool', [], is_const=True)
   559     cls.add_method('MustHideFromDocumentation', 
       
   560                    'bool', 
       
   561                    [], 
       
   562                    is_const=True)
   427     ## type-id.h: ns3::TypeId ns3::TypeId::SetGroupName(std::string groupName) [member function]
   563     ## type-id.h: ns3::TypeId ns3::TypeId::SetGroupName(std::string groupName) [member function]
   428     cls.add_method('SetGroupName', 'ns3::TypeId', [param('std::string', 'groupName')])
   564     cls.add_method('SetGroupName', 
       
   565                    'ns3::TypeId', 
       
   566                    [param('std::string', 'groupName')])
   429     ## type-id.h: ns3::TypeId ns3::TypeId::SetParent(ns3::TypeId tid) [member function]
   567     ## type-id.h: ns3::TypeId ns3::TypeId::SetParent(ns3::TypeId tid) [member function]
   430     cls.add_method('SetParent', 'ns3::TypeId', [param('ns3::TypeId', 'tid')])
   568     cls.add_method('SetParent', 
       
   569                    'ns3::TypeId', 
       
   570                    [param('ns3::TypeId', 'tid')])
   431     ## type-id.h: void ns3::TypeId::SetUid(uint16_t tid) [member function]
   571     ## type-id.h: void ns3::TypeId::SetUid(uint16_t tid) [member function]
   432     cls.add_method('SetUid', 'void', [param('uint16_t', 'tid')])
   572     cls.add_method('SetUid', 
       
   573                    'void', 
       
   574                    [param('uint16_t', 'tid')])
   433     cls.add_output_stream_operator()
   575     cls.add_output_stream_operator()
   434     return
   576     return
   435 
   577 
   436 def register_Ns3TypeIdAttributeInfo_methods(root_module, cls):
   578 def register_Ns3TypeIdAttributeInfo_methods(root_module, cls):
   437     ## type-id.h: ns3::TypeId::AttributeInfo::accessor [variable]
   579     ## type-id.h: ns3::TypeId::AttributeInfo::accessor [variable]
   445     cls.add_constructor([])
   587     cls.add_constructor([])
   446     return
   588     return
   447 
   589 
   448 def register_Ns3SystemWallClockMs_methods(root_module, cls):
   590 def register_Ns3SystemWallClockMs_methods(root_module, cls):
   449     ## system-wall-clock-ms.h: ns3::SystemWallClockMs::SystemWallClockMs() [constructor]
   591     ## system-wall-clock-ms.h: ns3::SystemWallClockMs::SystemWallClockMs() [constructor]
   450     cls.add_constructor([], visibility='public')
   592     cls.add_constructor([])
   451     ## system-wall-clock-ms.h: void ns3::SystemWallClockMs::Start() [member function]
   593     ## system-wall-clock-ms.h: void ns3::SystemWallClockMs::Start() [member function]
   452     cls.add_method('Start', 'void', [])
   594     cls.add_method('Start', 
       
   595                    'void', 
       
   596                    [])
   453     ## system-wall-clock-ms.h: long long unsigned int ns3::SystemWallClockMs::End() [member function]
   597     ## system-wall-clock-ms.h: long long unsigned int ns3::SystemWallClockMs::End() [member function]
   454     cls.add_method('End', 'long long unsigned int', [])
   598     cls.add_method('End', 
       
   599                    'long long unsigned int', 
       
   600                    [])
   455     return
   601     return
   456 
   602 
   457 def register_Ns3CallbackImplBase_methods(root_module, cls):
   603 def register_Ns3CallbackImplBase_methods(root_module, cls):
   458     ## callback.h: ns3::CallbackImplBase::CallbackImplBase() [constructor]
   604     ## callback.h: ns3::CallbackImplBase::CallbackImplBase() [constructor]
   459     cls.add_constructor([], visibility='public')
   605     cls.add_constructor([])
   460     ## callback.h: bool ns3::CallbackImplBase::IsEqual(ns3::Ptr<ns3::CallbackImplBase const> other) const [member function]
   606     ## callback.h: bool ns3::CallbackImplBase::IsEqual(ns3::Ptr<ns3::CallbackImplBase const> other) const [member function]
   461     cls.add_method('IsEqual', 'bool', [param('ns3::Ptr< ns3::CallbackImplBase const >', 'other')], is_pure_virtual=True, is_const=True, is_virtual=True)
   607     cls.add_method('IsEqual', 
       
   608                    'bool', 
       
   609                    [param('ns3::Ptr< ns3::CallbackImplBase const >', 'other')], 
       
   610                    is_pure_virtual=True, is_const=True, is_virtual=True)
   462     return
   611     return
   463 
   612 
   464 def register_Ns3CriticalSection_methods(root_module, cls):
   613 def register_Ns3CriticalSection_methods(root_module, cls):
   465     ## system-mutex.h: ns3::CriticalSection::CriticalSection(ns3::SystemMutex & mutex) [constructor]
   614     ## system-mutex.h: ns3::CriticalSection::CriticalSection(ns3::SystemMutex & mutex) [constructor]
   466     cls.add_constructor([param('ns3::SystemMutex&', 'mutex')], visibility='public')
   615     cls.add_constructor([param('ns3::SystemMutex&', 'mutex')])
   467     return
   616     return
   468 
   617 
   469 def register_Ns3TraceSourceAccessor_methods(root_module, cls):
   618 def register_Ns3TraceSourceAccessor_methods(root_module, cls):
   470     ## trace-source-accessor.h: ns3::TraceSourceAccessor::TraceSourceAccessor() [constructor]
   619     ## trace-source-accessor.h: ns3::TraceSourceAccessor::TraceSourceAccessor() [constructor]
   471     cls.add_constructor([], visibility='public')
   620     cls.add_constructor([])
   472     ## trace-source-accessor.h: void ns3::TraceSourceAccessor::Ref() const [member function]
   621     ## trace-source-accessor.h: void ns3::TraceSourceAccessor::Ref() const [member function]
   473     cls.add_method('Ref', 'void', [], is_const=True)
   622     cls.add_method('Ref', 
       
   623                    'void', 
       
   624                    [], 
       
   625                    is_const=True)
   474     ## trace-source-accessor.h: void ns3::TraceSourceAccessor::Unref() const [member function]
   626     ## trace-source-accessor.h: void ns3::TraceSourceAccessor::Unref() const [member function]
   475     cls.add_method('Unref', 'void', [], is_const=True)
   627     cls.add_method('Unref', 
       
   628                    'void', 
       
   629                    [], 
       
   630                    is_const=True)
   476     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::ConnectWithoutContext(ns3::ObjectBase * obj, ns3::CallbackBase const & cb) const [member function]
   631     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::ConnectWithoutContext(ns3::ObjectBase * obj, ns3::CallbackBase const & cb) const [member function]
   477     cls.add_method('ConnectWithoutContext', 'bool', [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase&', 'cb', is_const=True)], is_pure_virtual=True, is_const=True, is_virtual=True)
   632     cls.add_method('ConnectWithoutContext', 
       
   633                    'bool', 
       
   634                    [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase&', 'cb', is_const=True)], 
       
   635                    is_pure_virtual=True, is_const=True, is_virtual=True)
   478     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::Connect(ns3::ObjectBase * obj, std::string context, ns3::CallbackBase const & cb) const [member function]
   636     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::Connect(ns3::ObjectBase * obj, std::string context, ns3::CallbackBase const & cb) const [member function]
   479     cls.add_method('Connect', 'bool', [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase&', 'cb', is_const=True)], is_pure_virtual=True, is_const=True, is_virtual=True)
   637     cls.add_method('Connect', 
       
   638                    'bool', 
       
   639                    [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase&', 'cb', is_const=True)], 
       
   640                    is_pure_virtual=True, is_const=True, is_virtual=True)
   480     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::DisconnectWithoutContext(ns3::ObjectBase * obj, ns3::CallbackBase const & cb) const [member function]
   641     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::DisconnectWithoutContext(ns3::ObjectBase * obj, ns3::CallbackBase const & cb) const [member function]
   481     cls.add_method('DisconnectWithoutContext', 'bool', [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase&', 'cb', is_const=True)], is_pure_virtual=True, is_const=True, is_virtual=True)
   642     cls.add_method('DisconnectWithoutContext', 
       
   643                    'bool', 
       
   644                    [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase&', 'cb', is_const=True)], 
       
   645                    is_pure_virtual=True, is_const=True, is_virtual=True)
   482     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::Disconnect(ns3::ObjectBase * obj, std::string context, ns3::CallbackBase const & cb) const [member function]
   646     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::Disconnect(ns3::ObjectBase * obj, std::string context, ns3::CallbackBase const & cb) const [member function]
   483     cls.add_method('Disconnect', 'bool', [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase&', 'cb', is_const=True)], is_pure_virtual=True, is_const=True, is_virtual=True)
   647     cls.add_method('Disconnect', 
       
   648                    'bool', 
       
   649                    [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase&', 'cb', is_const=True)], 
       
   650                    is_pure_virtual=True, is_const=True, is_virtual=True)
   484     return
   651     return
   485 
   652 
   486 def register_Ns3AttributeChecker_methods(root_module, cls):
   653 def register_Ns3AttributeChecker_methods(root_module, cls):
   487     ## attribute.h: ns3::AttributeChecker::AttributeChecker() [constructor]
   654     ## attribute.h: ns3::AttributeChecker::AttributeChecker() [constructor]
   488     cls.add_constructor([], visibility='public')
   655     cls.add_constructor([])
   489     ## attribute.h: bool ns3::AttributeChecker::Check(ns3::AttributeValue const & value) const [member function]
   656     ## attribute.h: bool ns3::AttributeChecker::Check(ns3::AttributeValue const & value) const [member function]
   490     cls.add_method('Check', 'bool', [param('ns3::AttributeValue&', 'value', is_const=True)], is_pure_virtual=True, is_const=True, is_virtual=True)
   657     cls.add_method('Check', 
       
   658                    'bool', 
       
   659                    [param('ns3::AttributeValue&', 'value', is_const=True)], 
       
   660                    is_pure_virtual=True, is_const=True, is_virtual=True)
   491     ## attribute.h: std::string ns3::AttributeChecker::GetValueTypeName() const [member function]
   661     ## attribute.h: std::string ns3::AttributeChecker::GetValueTypeName() const [member function]
   492     cls.add_method('GetValueTypeName', 'std::string', [], is_pure_virtual=True, is_const=True, is_virtual=True)
   662     cls.add_method('GetValueTypeName', 
       
   663                    'std::string', 
       
   664                    [], 
       
   665                    is_pure_virtual=True, is_const=True, is_virtual=True)
   493     ## attribute.h: bool ns3::AttributeChecker::HasUnderlyingTypeInformation() const [member function]
   666     ## attribute.h: bool ns3::AttributeChecker::HasUnderlyingTypeInformation() const [member function]
   494     cls.add_method('HasUnderlyingTypeInformation', 'bool', [], is_pure_virtual=True, is_const=True, is_virtual=True)
   667     cls.add_method('HasUnderlyingTypeInformation', 
       
   668                    'bool', 
       
   669                    [], 
       
   670                    is_pure_virtual=True, is_const=True, is_virtual=True)
   495     ## attribute.h: std::string ns3::AttributeChecker::GetUnderlyingTypeInformation() const [member function]
   671     ## attribute.h: std::string ns3::AttributeChecker::GetUnderlyingTypeInformation() const [member function]
   496     cls.add_method('GetUnderlyingTypeInformation', 'std::string', [], is_pure_virtual=True, is_const=True, is_virtual=True)
   672     cls.add_method('GetUnderlyingTypeInformation', 
       
   673                    'std::string', 
       
   674                    [], 
       
   675                    is_pure_virtual=True, is_const=True, is_virtual=True)
   497     ## attribute.h: ns3::Ptr<ns3::AttributeValue> ns3::AttributeChecker::Create() const [member function]
   676     ## attribute.h: ns3::Ptr<ns3::AttributeValue> ns3::AttributeChecker::Create() const [member function]
   498     cls.add_method('Create', 'ns3::Ptr< ns3::AttributeValue >', [], is_pure_virtual=True, is_const=True, is_virtual=True)
   677     cls.add_method('Create', 
       
   678                    'ns3::Ptr< ns3::AttributeValue >', 
       
   679                    [], 
       
   680                    is_pure_virtual=True, is_const=True, is_virtual=True)
   499     ## attribute.h: bool ns3::AttributeChecker::Copy(ns3::AttributeValue const & source, ns3::AttributeValue & destination) const [member function]
   681     ## attribute.h: bool ns3::AttributeChecker::Copy(ns3::AttributeValue const & source, ns3::AttributeValue & destination) const [member function]
   500     cls.add_method('Copy', 'bool', [param('ns3::AttributeValue&', 'source', is_const=True), param('ns3::AttributeValue&', 'destination')], is_pure_virtual=True, is_const=True, is_virtual=True)
   682     cls.add_method('Copy', 
       
   683                    'bool', 
       
   684                    [param('ns3::AttributeValue&', 'source', is_const=True), param('ns3::AttributeValue&', 'destination')], 
       
   685                    is_pure_virtual=True, is_const=True, is_virtual=True)
   501     return
   686     return
   502 
   687 
   503 def register_Ns3RandomVariableChecker_methods(root_module, cls):
   688 def register_Ns3RandomVariableChecker_methods(root_module, cls):
   504     cls.add_constructor([])
   689     cls.add_constructor([])
   505     return
   690     return
   506 
   691 
   507 def register_Ns3SystemMutex_methods(root_module, cls):
   692 def register_Ns3SystemMutex_methods(root_module, cls):
   508     ## system-mutex.h: ns3::SystemMutex::SystemMutex() [constructor]
   693     ## system-mutex.h: ns3::SystemMutex::SystemMutex() [constructor]
   509     cls.add_constructor([], visibility='public')
   694     cls.add_constructor([])
   510     ## system-mutex.h: void ns3::SystemMutex::Lock() [member function]
   695     ## system-mutex.h: void ns3::SystemMutex::Lock() [member function]
   511     cls.add_method('Lock', 'void', [])
   696     cls.add_method('Lock', 
       
   697                    'void', 
       
   698                    [])
   512     ## system-mutex.h: void ns3::SystemMutex::Unlock() [member function]
   699     ## system-mutex.h: void ns3::SystemMutex::Unlock() [member function]
   513     cls.add_method('Unlock', 'void', [])
   700     cls.add_method('Unlock', 
       
   701                    'void', 
       
   702                    [])
   514     return
   703     return
   515 
   704 
   516 def register_Ns3NormalVariable_methods(root_module, cls):
   705 def register_Ns3NormalVariable_methods(root_module, cls):
   517     ## random-variable.h: ns3::NormalVariable::NormalVariable() [constructor]
   706     ## random-variable.h: ns3::NormalVariable::NormalVariable() [constructor]
   518     cls.add_constructor([], visibility='public')
   707     cls.add_constructor([])
   519     ## random-variable.h: ns3::NormalVariable::NormalVariable(double m, double v) [constructor]
   708     ## random-variable.h: ns3::NormalVariable::NormalVariable(double m, double v) [constructor]
   520     cls.add_constructor([param('double', 'm'), param('double', 'v')], visibility='public')
   709     cls.add_constructor([param('double', 'm'), param('double', 'v')])
   521     ## random-variable.h: ns3::NormalVariable::NormalVariable(double m, double v, double b) [constructor]
   710     ## random-variable.h: ns3::NormalVariable::NormalVariable(double m, double v, double b) [constructor]
   522     cls.add_constructor([param('double', 'm'), param('double', 'v'), param('double', 'b')], visibility='public')
   711     cls.add_constructor([param('double', 'm'), param('double', 'v'), param('double', 'b')])
   523     ## random-variable.h: static double ns3::NormalVariable::GetSingleValue(double m, double v) [member function]
   712     ## random-variable.h: static double ns3::NormalVariable::GetSingleValue(double m, double v) [member function]
   524     cls.add_method('GetSingleValue', 'double', [param('double', 'm'), param('double', 'v')], is_static=True)
   713     cls.add_method('GetSingleValue', 
       
   714                    'double', 
       
   715                    [param('double', 'm'), param('double', 'v')], 
       
   716                    is_static=True)
   525     ## random-variable.h: static double ns3::NormalVariable::GetSingleValue(double m, double v, double b) [member function]
   717     ## random-variable.h: static double ns3::NormalVariable::GetSingleValue(double m, double v, double b) [member function]
   526     cls.add_method('GetSingleValue', 'double', [param('double', 'm'), param('double', 'v'), param('double', 'b')], is_static=True)
   718     cls.add_method('GetSingleValue', 
       
   719                    'double', 
       
   720                    [param('double', 'm'), param('double', 'v'), param('double', 'b')], 
       
   721                    is_static=True)
   527     return
   722     return
   528 
   723 
   529 def register_Ns3ObjectFactory_methods(root_module, cls):
   724 def register_Ns3ObjectFactory_methods(root_module, cls):
   530     ## object-factory.h: ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [copy constructor]
   725     ## object-factory.h: ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [copy constructor]
   531     cls.add_constructor([param('ns3::ObjectFactory&', 'arg0', is_const=True)], visibility='public')
   726     cls.add_constructor([param('ns3::ObjectFactory&', 'arg0', is_const=True)])
   532     ## object-factory.h: ns3::ObjectFactory::ObjectFactory() [constructor]
   727     ## object-factory.h: ns3::ObjectFactory::ObjectFactory() [constructor]
   533     cls.add_constructor([], visibility='public')
   728     cls.add_constructor([])
   534     ## object-factory.h: ns3::Ptr<ns3::Object> ns3::ObjectFactory::Create() const [member function]
   729     ## object-factory.h: ns3::Ptr<ns3::Object> ns3::ObjectFactory::Create() const [member function]
   535     cls.add_method('Create', 'ns3::Ptr< ns3::Object >', [], is_const=True)
   730     cls.add_method('Create', 
       
   731                    'ns3::Ptr< ns3::Object >', 
       
   732                    [], 
       
   733                    is_const=True)
   536     ## object-factory.h: ns3::TypeId ns3::ObjectFactory::GetTypeId() const [member function]
   734     ## object-factory.h: ns3::TypeId ns3::ObjectFactory::GetTypeId() const [member function]
   537     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_const=True)
   735     cls.add_method('GetTypeId', 
       
   736                    'ns3::TypeId', 
       
   737                    [], 
       
   738                    is_const=True)
   538     ## object-factory.h: void ns3::ObjectFactory::Set(std::string name, ns3::AttributeValue const & value) [member function]
   739     ## object-factory.h: void ns3::ObjectFactory::Set(std::string name, ns3::AttributeValue const & value) [member function]
   539     cls.add_method('Set', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
   740     cls.add_method('Set', 
       
   741                    'void', 
       
   742                    [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
   540     ## object-factory.h: void ns3::ObjectFactory::SetTypeId(ns3::TypeId tid) [member function]
   743     ## object-factory.h: void ns3::ObjectFactory::SetTypeId(ns3::TypeId tid) [member function]
   541     cls.add_method('SetTypeId', 'void', [param('ns3::TypeId', 'tid')])
   744     cls.add_method('SetTypeId', 
       
   745                    'void', 
       
   746                    [param('ns3::TypeId', 'tid')])
   542     ## object-factory.h: void ns3::ObjectFactory::SetTypeId(char const * tid) [member function]
   747     ## object-factory.h: void ns3::ObjectFactory::SetTypeId(char const * tid) [member function]
   543     cls.add_method('SetTypeId', 'void', [param('char *', 'tid', transfer_ownership=False, is_const=True)])
   748     cls.add_method('SetTypeId', 
       
   749                    'void', 
       
   750                    [param('char *', 'tid', transfer_ownership=False, is_const=True)])
   544     ## object-factory.h: void ns3::ObjectFactory::SetTypeId(std::string tid) [member function]
   751     ## object-factory.h: void ns3::ObjectFactory::SetTypeId(std::string tid) [member function]
   545     cls.add_method('SetTypeId', 'void', [param('std::string', 'tid')])
   752     cls.add_method('SetTypeId', 
       
   753                    'void', 
       
   754                    [param('std::string', 'tid')])
   546     cls.add_output_stream_operator()
   755     cls.add_output_stream_operator()
   547     return
   756     return
   548 
   757 
   549 def register_Ns3AttributeAccessor_methods(root_module, cls):
   758 def register_Ns3AttributeAccessor_methods(root_module, cls):
   550     ## attribute.h: ns3::AttributeAccessor::AttributeAccessor() [constructor]
   759     ## attribute.h: ns3::AttributeAccessor::AttributeAccessor() [constructor]
   551     cls.add_constructor([], visibility='public')
   760     cls.add_constructor([])
   552     ## attribute.h: bool ns3::AttributeAccessor::Set(ns3::ObjectBase * object, ns3::AttributeValue const & value) const [member function]
   761     ## attribute.h: bool ns3::AttributeAccessor::Set(ns3::ObjectBase * object, ns3::AttributeValue const & value) const [member function]
   553     cls.add_method('Set', 'bool', [param('ns3::ObjectBase *', 'object', transfer_ownership=False), param('ns3::AttributeValue&', 'value', is_const=True)], is_pure_virtual=True, is_const=True, is_virtual=True)
   762     cls.add_method('Set', 
       
   763                    'bool', 
       
   764                    [param('ns3::ObjectBase *', 'object', transfer_ownership=False), param('ns3::AttributeValue&', 'value', is_const=True)], 
       
   765                    is_pure_virtual=True, is_const=True, is_virtual=True)
   554     ## attribute.h: bool ns3::AttributeAccessor::Get(ns3::ObjectBase const * object, ns3::AttributeValue & attribute) const [member function]
   766     ## attribute.h: bool ns3::AttributeAccessor::Get(ns3::ObjectBase const * object, ns3::AttributeValue & attribute) const [member function]
   555     cls.add_method('Get', 'bool', [param('ns3::ObjectBase *', 'object', transfer_ownership=False, is_const=True), param('ns3::AttributeValue&', 'attribute')], is_pure_virtual=True, is_const=True, is_virtual=True)
   767     cls.add_method('Get', 
       
   768                    'bool', 
       
   769                    [param('ns3::ObjectBase *', 'object', transfer_ownership=False, is_const=True), param('ns3::AttributeValue&', 'attribute')], 
       
   770                    is_pure_virtual=True, is_const=True, is_virtual=True)
   556     ## attribute.h: bool ns3::AttributeAccessor::HasGetter() const [member function]
   771     ## attribute.h: bool ns3::AttributeAccessor::HasGetter() const [member function]
   557     cls.add_method('HasGetter', 'bool', [], is_pure_virtual=True, is_const=True, is_virtual=True)
   772     cls.add_method('HasGetter', 
       
   773                    'bool', 
       
   774                    [], 
       
   775                    is_pure_virtual=True, is_const=True, is_virtual=True)
   558     ## attribute.h: bool ns3::AttributeAccessor::HasSetter() const [member function]
   776     ## attribute.h: bool ns3::AttributeAccessor::HasSetter() const [member function]
   559     cls.add_method('HasSetter', 'bool', [], is_pure_virtual=True, is_const=True, is_virtual=True)
   777     cls.add_method('HasSetter', 
       
   778                    'bool', 
       
   779                    [], 
       
   780                    is_pure_virtual=True, is_const=True, is_virtual=True)
   560     return
   781     return
   561 
   782 
   562 def register_Ns3ParetoVariable_methods(root_module, cls):
   783 def register_Ns3ParetoVariable_methods(root_module, cls):
   563     ## random-variable.h: ns3::ParetoVariable::ParetoVariable() [constructor]
   784     ## random-variable.h: ns3::ParetoVariable::ParetoVariable() [constructor]
   564     cls.add_constructor([], visibility='public')
   785     cls.add_constructor([])
   565     ## random-variable.h: ns3::ParetoVariable::ParetoVariable(double m) [constructor]
   786     ## random-variable.h: ns3::ParetoVariable::ParetoVariable(double m) [constructor]
   566     cls.add_constructor([param('double', 'm')], visibility='public')
   787     cls.add_constructor([param('double', 'm')])
   567     ## random-variable.h: ns3::ParetoVariable::ParetoVariable(double m, double s) [constructor]
   788     ## random-variable.h: ns3::ParetoVariable::ParetoVariable(double m, double s) [constructor]
   568     cls.add_constructor([param('double', 'm'), param('double', 's')], visibility='public')
   789     cls.add_constructor([param('double', 'm'), param('double', 's')])
   569     ## random-variable.h: ns3::ParetoVariable::ParetoVariable(double m, double s, double b) [constructor]
   790     ## random-variable.h: ns3::ParetoVariable::ParetoVariable(double m, double s, double b) [constructor]
   570     cls.add_constructor([param('double', 'm'), param('double', 's'), param('double', 'b')], visibility='public')
   791     cls.add_constructor([param('double', 'm'), param('double', 's'), param('double', 'b')])
   571     ## random-variable.h: static double ns3::ParetoVariable::GetSingleValue(double m, double s, double b=0) [member function]
   792     ## random-variable.h: static double ns3::ParetoVariable::GetSingleValue(double m, double s, double b=0) [member function]
   572     cls.add_method('GetSingleValue', 'double', [param('double', 'm'), param('double', 's'), param('double', 'b', default_value='0')], is_static=True)
   793     cls.add_method('GetSingleValue', 
       
   794                    'double', 
       
   795                    [param('double', 'm'), param('double', 's'), param('double', 'b', default_value='0')], 
       
   796                    is_static=True)
   573     return
   797     return
   574 
   798 
   575 def register_Ns3ConstantVariable_methods(root_module, cls):
   799 def register_Ns3ConstantVariable_methods(root_module, cls):
   576     ## random-variable.h: ns3::ConstantVariable::ConstantVariable() [constructor]
   800     ## random-variable.h: ns3::ConstantVariable::ConstantVariable() [constructor]
   577     cls.add_constructor([], visibility='public')
   801     cls.add_constructor([])
   578     ## random-variable.h: ns3::ConstantVariable::ConstantVariable(double c) [constructor]
   802     ## random-variable.h: ns3::ConstantVariable::ConstantVariable(double c) [constructor]
   579     cls.add_constructor([param('double', 'c')], visibility='public')
   803     cls.add_constructor([param('double', 'c')])
   580     ## random-variable.h: void ns3::ConstantVariable::SetConstant(double c) [member function]
   804     ## random-variable.h: void ns3::ConstantVariable::SetConstant(double c) [member function]
   581     cls.add_method('SetConstant', 'void', [param('double', 'c')])
   805     cls.add_method('SetConstant', 
       
   806                    'void', 
       
   807                    [param('double', 'c')])
   582     return
   808     return
   583 
   809 
   584 def register_Ns3SystemThread_methods(root_module, cls):
   810 def register_Ns3SystemThread_methods(root_module, cls):
   585     ## system-thread.h: ns3::SystemThread::SystemThread(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [constructor]
   811     ## system-thread.h: ns3::SystemThread::SystemThread(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [constructor]
   586     cls.add_constructor([param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')], visibility='public')
   812     cls.add_constructor([param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')])
   587     ## system-thread.h: void ns3::SystemThread::Ref() const [member function]
   813     ## system-thread.h: void ns3::SystemThread::Ref() const [member function]
   588     cls.add_method('Ref', 'void', [], is_const=True)
   814     cls.add_method('Ref', 
       
   815                    'void', 
       
   816                    [], 
       
   817                    is_const=True)
   589     ## system-thread.h: void ns3::SystemThread::Unref() const [member function]
   818     ## system-thread.h: void ns3::SystemThread::Unref() const [member function]
   590     cls.add_method('Unref', 'void', [], is_const=True)
   819     cls.add_method('Unref', 
       
   820                    'void', 
       
   821                    [], 
       
   822                    is_const=True)
   591     ## system-thread.h: void ns3::SystemThread::Start() [member function]
   823     ## system-thread.h: void ns3::SystemThread::Start() [member function]
   592     cls.add_method('Start', 'void', [])
   824     cls.add_method('Start', 
       
   825                    'void', 
       
   826                    [])
   593     ## system-thread.h: void ns3::SystemThread::Join() [member function]
   827     ## system-thread.h: void ns3::SystemThread::Join() [member function]
   594     cls.add_method('Join', 'void', [])
   828     cls.add_method('Join', 
       
   829                    'void', 
       
   830                    [])
   595     return
   831     return
   596 
   832 
   597 def register_Ns3EmpiricalVariable_methods(root_module, cls):
   833 def register_Ns3EmpiricalVariable_methods(root_module, cls):
   598     ## random-variable.h: ns3::EmpiricalVariable::EmpiricalVariable() [constructor]
   834     ## random-variable.h: ns3::EmpiricalVariable::EmpiricalVariable() [constructor]
   599     cls.add_constructor([], visibility='public')
   835     cls.add_constructor([])
   600     ## random-variable.h: void ns3::EmpiricalVariable::CDF(double v, double c) [member function]
   836     ## random-variable.h: void ns3::EmpiricalVariable::CDF(double v, double c) [member function]
   601     cls.add_method('CDF', 'void', [param('double', 'v'), param('double', 'c')])
   837     cls.add_method('CDF', 
       
   838                    'void', 
       
   839                    [param('double', 'v'), param('double', 'c')])
   602     return
   840     return
   603 
   841 
   604 def register_Ns3EnumChecker_methods(root_module, cls):
   842 def register_Ns3EnumChecker_methods(root_module, cls):
   605     ## enum.h: ns3::EnumChecker::EnumChecker() [constructor]
   843     ## enum.h: ns3::EnumChecker::EnumChecker() [constructor]
   606     cls.add_constructor([], visibility='public')
   844     cls.add_constructor([])
   607     ## enum.h: void ns3::EnumChecker::AddDefault(int v, std::string name) [member function]
   845     ## enum.h: void ns3::EnumChecker::AddDefault(int v, std::string name) [member function]
   608     cls.add_method('AddDefault', 'void', [param('int', 'v'), param('std::string', 'name')])
   846     cls.add_method('AddDefault', 
       
   847                    'void', 
       
   848                    [param('int', 'v'), param('std::string', 'name')])
   609     ## enum.h: void ns3::EnumChecker::Add(int v, std::string name) [member function]
   849     ## enum.h: void ns3::EnumChecker::Add(int v, std::string name) [member function]
   610     cls.add_method('Add', 'void', [param('int', 'v'), param('std::string', 'name')])
   850     cls.add_method('Add', 
       
   851                    'void', 
       
   852                    [param('int', 'v'), param('std::string', 'name')])
   611     ## enum.h: bool ns3::EnumChecker::Check(ns3::AttributeValue const & value) const [member function]
   853     ## enum.h: bool ns3::EnumChecker::Check(ns3::AttributeValue const & value) const [member function]
   612     cls.add_method('Check', 'bool', [param('ns3::AttributeValue&', 'value', is_const=True)], is_const=True, is_virtual=True)
   854     cls.add_method('Check', 
       
   855                    'bool', 
       
   856                    [param('ns3::AttributeValue&', 'value', is_const=True)], 
       
   857                    is_const=True, is_virtual=True)
   613     ## enum.h: std::string ns3::EnumChecker::GetValueTypeName() const [member function]
   858     ## enum.h: std::string ns3::EnumChecker::GetValueTypeName() const [member function]
   614     cls.add_method('GetValueTypeName', 'std::string', [], is_const=True, is_virtual=True)
   859     cls.add_method('GetValueTypeName', 
       
   860                    'std::string', 
       
   861                    [], 
       
   862                    is_const=True, is_virtual=True)
   615     ## enum.h: bool ns3::EnumChecker::HasUnderlyingTypeInformation() const [member function]
   863     ## enum.h: bool ns3::EnumChecker::HasUnderlyingTypeInformation() const [member function]
   616     cls.add_method('HasUnderlyingTypeInformation', 'bool', [], is_const=True, is_virtual=True)
   864     cls.add_method('HasUnderlyingTypeInformation', 
       
   865                    'bool', 
       
   866                    [], 
       
   867                    is_const=True, is_virtual=True)
   617     ## enum.h: std::string ns3::EnumChecker::GetUnderlyingTypeInformation() const [member function]
   868     ## enum.h: std::string ns3::EnumChecker::GetUnderlyingTypeInformation() const [member function]
   618     cls.add_method('GetUnderlyingTypeInformation', 'std::string', [], is_const=True, is_virtual=True)
   869     cls.add_method('GetUnderlyingTypeInformation', 
       
   870                    'std::string', 
       
   871                    [], 
       
   872                    is_const=True, is_virtual=True)
   619     ## enum.h: ns3::Ptr<ns3::AttributeValue> ns3::EnumChecker::Create() const [member function]
   873     ## enum.h: ns3::Ptr<ns3::AttributeValue> ns3::EnumChecker::Create() const [member function]
   620     cls.add_method('Create', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
   874     cls.add_method('Create', 
       
   875                    'ns3::Ptr< ns3::AttributeValue >', 
       
   876                    [], 
       
   877                    is_const=True, is_virtual=True)
   621     ## enum.h: bool ns3::EnumChecker::Copy(ns3::AttributeValue const & src, ns3::AttributeValue & dst) const [member function]
   878     ## enum.h: bool ns3::EnumChecker::Copy(ns3::AttributeValue const & src, ns3::AttributeValue & dst) const [member function]
   622     cls.add_method('Copy', 'bool', [param('ns3::AttributeValue&', 'src', is_const=True), param('ns3::AttributeValue&', 'dst')], is_const=True, is_virtual=True)
   879     cls.add_method('Copy', 
       
   880                    'bool', 
       
   881                    [param('ns3::AttributeValue&', 'src', is_const=True), param('ns3::AttributeValue&', 'dst')], 
       
   882                    is_const=True, is_virtual=True)
   623     return
   883     return
   624 
   884 
   625 def register_Ns3Empty_methods(root_module, cls):
   885 def register_Ns3Empty_methods(root_module, cls):
   626     cls.add_constructor([])
   886     cls.add_constructor([])
   627     return
   887     return
   628 
   888 
   629 def register_Ns3ObjectBase_methods(root_module, cls):
   889 def register_Ns3ObjectBase_methods(root_module, cls):
   630     ## object-base.h: ns3::ObjectBase::ObjectBase() [constructor]
   890     ## object-base.h: ns3::ObjectBase::ObjectBase() [constructor]
   631     cls.add_constructor([], visibility='public')
   891     cls.add_constructor([])
   632     ## object-base.h: ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [copy constructor]
   892     ## object-base.h: ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [copy constructor]
   633     cls.add_constructor([param('ns3::ObjectBase&', 'arg0', is_const=True)], visibility='public')
   893     cls.add_constructor([param('ns3::ObjectBase&', 'arg0', is_const=True)])
   634     ## object-base.h: static ns3::TypeId ns3::ObjectBase::GetTypeId() [member function]
   894     ## object-base.h: static ns3::TypeId ns3::ObjectBase::GetTypeId() [member function]
   635     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
   895     cls.add_method('GetTypeId', 
       
   896                    'ns3::TypeId', 
       
   897                    [], 
       
   898                    is_static=True)
   636     ## object-base.h: ns3::TypeId ns3::ObjectBase::GetInstanceTypeId() const [member function]
   899     ## object-base.h: ns3::TypeId ns3::ObjectBase::GetInstanceTypeId() const [member function]
   637     cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_pure_virtual=True, is_const=True, is_virtual=True)
   900     cls.add_method('GetInstanceTypeId', 
       
   901                    'ns3::TypeId', 
       
   902                    [], 
       
   903                    is_pure_virtual=True, is_const=True, is_virtual=True)
   638     ## object-base.h: void ns3::ObjectBase::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function]
   904     ## object-base.h: void ns3::ObjectBase::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function]
   639     cls.add_method('SetAttribute', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
   905     cls.add_method('SetAttribute', 
       
   906                    'void', 
       
   907                    [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
   640     ## object-base.h: bool ns3::ObjectBase::SetAttributeFailSafe(std::string name, ns3::AttributeValue const & value) [member function]
   908     ## object-base.h: bool ns3::ObjectBase::SetAttributeFailSafe(std::string name, ns3::AttributeValue const & value) [member function]
   641     cls.add_method('SetAttributeFailSafe', 'bool', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
   909     cls.add_method('SetAttributeFailSafe', 
       
   910                    'bool', 
       
   911                    [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
   642     ## object-base.h: void ns3::ObjectBase::GetAttribute(std::string name, ns3::AttributeValue & value) const [member function]
   912     ## object-base.h: void ns3::ObjectBase::GetAttribute(std::string name, ns3::AttributeValue & value) const [member function]
   643     cls.add_method('GetAttribute', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value')], is_const=True)
   913     cls.add_method('GetAttribute', 
       
   914                    'void', 
       
   915                    [param('std::string', 'name'), param('ns3::AttributeValue&', 'value')], 
       
   916                    is_const=True)
   644     ## object-base.h: bool ns3::ObjectBase::GetAttributeFailSafe(std::string name, ns3::AttributeValue & attribute) const [member function]
   917     ## object-base.h: bool ns3::ObjectBase::GetAttributeFailSafe(std::string name, ns3::AttributeValue & attribute) const [member function]
   645     cls.add_method('GetAttributeFailSafe', 'bool', [param('std::string', 'name'), param('ns3::AttributeValue&', 'attribute')], is_const=True)
   918     cls.add_method('GetAttributeFailSafe', 
       
   919                    'bool', 
       
   920                    [param('std::string', 'name'), param('ns3::AttributeValue&', 'attribute')], 
       
   921                    is_const=True)
   646     ## object-base.h: bool ns3::ObjectBase::TraceConnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function]
   922     ## object-base.h: bool ns3::ObjectBase::TraceConnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function]
   647     cls.add_method('TraceConnect', 'bool', [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase&', 'cb', is_const=True)])
   923     cls.add_method('TraceConnect', 
       
   924                    'bool', 
       
   925                    [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase&', 'cb', is_const=True)])
   648     ## object-base.h: bool ns3::ObjectBase::TraceConnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]
   926     ## object-base.h: bool ns3::ObjectBase::TraceConnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]
   649     cls.add_method('TraceConnectWithoutContext', 'bool', [param('std::string', 'name'), param('ns3::CallbackBase&', 'cb', is_const=True)])
   927     cls.add_method('TraceConnectWithoutContext', 
       
   928                    'bool', 
       
   929                    [param('std::string', 'name'), param('ns3::CallbackBase&', 'cb', is_const=True)])
   650     ## object-base.h: bool ns3::ObjectBase::TraceDisconnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function]
   930     ## object-base.h: bool ns3::ObjectBase::TraceDisconnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function]
   651     cls.add_method('TraceDisconnect', 'bool', [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase&', 'cb', is_const=True)])
   931     cls.add_method('TraceDisconnect', 
       
   932                    'bool', 
       
   933                    [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase&', 'cb', is_const=True)])
   652     ## object-base.h: bool ns3::ObjectBase::TraceDisconnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]
   934     ## object-base.h: bool ns3::ObjectBase::TraceDisconnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]
   653     cls.add_method('TraceDisconnectWithoutContext', 'bool', [param('std::string', 'name'), param('ns3::CallbackBase&', 'cb', is_const=True)])
   935     cls.add_method('TraceDisconnectWithoutContext', 
       
   936                    'bool', 
       
   937                    [param('std::string', 'name'), param('ns3::CallbackBase&', 'cb', is_const=True)])
   654     ## object-base.h: void ns3::ObjectBase::NotifyConstructionCompleted() [member function]
   938     ## object-base.h: void ns3::ObjectBase::NotifyConstructionCompleted() [member function]
   655     cls.add_method('NotifyConstructionCompleted', 'void', [], visibility='protected', is_virtual=True)
   939     cls.add_method('NotifyConstructionCompleted', 
       
   940                    'void', 
       
   941                    [], 
       
   942                    visibility='protected', is_virtual=True)
   656     ## object-base.h: void ns3::ObjectBase::ConstructSelf(ns3::AttributeList const & attributes) [member function]
   943     ## object-base.h: void ns3::ObjectBase::ConstructSelf(ns3::AttributeList const & attributes) [member function]
   657     cls.add_method('ConstructSelf', 'void', [param('ns3::AttributeList&', 'attributes', is_const=True)], visibility='protected')
   944     cls.add_method('ConstructSelf', 
       
   945                    'void', 
       
   946                    [param('ns3::AttributeList&', 'attributes', is_const=True)], 
       
   947                    visibility='protected')
   658     return
   948     return
   659 
   949 
   660 def register_Ns3CommandLine_methods(root_module, cls):
   950 def register_Ns3CommandLine_methods(root_module, cls):
   661     cls.add_constructor([])
   951     cls.add_constructor([])
   662     return
   952     return
   689     cls.add_constructor([])
   979     cls.add_constructor([])
   690     return
   980     return
   691 
   981 
   692 def register_Ns3RngStream_methods(root_module, cls):
   982 def register_Ns3RngStream_methods(root_module, cls):
   693     ## rng-stream.h: ns3::RngStream::RngStream() [constructor]
   983     ## rng-stream.h: ns3::RngStream::RngStream() [constructor]
   694     cls.add_constructor([], visibility='public')
   984     cls.add_constructor([])
   695     ## rng-stream.h: ns3::RngStream::RngStream(ns3::RngStream const & arg0) [copy constructor]
   985     ## rng-stream.h: ns3::RngStream::RngStream(ns3::RngStream const & arg0) [copy constructor]
   696     cls.add_constructor([param('ns3::RngStream&', 'arg0', is_const=True)], visibility='public')
   986     cls.add_constructor([param('ns3::RngStream&', 'arg0', is_const=True)])
   697     ## rng-stream.h: void ns3::RngStream::InitializeStream() [member function]
   987     ## rng-stream.h: void ns3::RngStream::InitializeStream() [member function]
   698     cls.add_method('InitializeStream', 'void', [])
   988     cls.add_method('InitializeStream', 
       
   989                    'void', 
       
   990                    [])
   699     ## rng-stream.h: void ns3::RngStream::ResetStartStream() [member function]
   991     ## rng-stream.h: void ns3::RngStream::ResetStartStream() [member function]
   700     cls.add_method('ResetStartStream', 'void', [])
   992     cls.add_method('ResetStartStream', 
       
   993                    'void', 
       
   994                    [])
   701     ## rng-stream.h: void ns3::RngStream::ResetStartSubstream() [member function]
   995     ## rng-stream.h: void ns3::RngStream::ResetStartSubstream() [member function]
   702     cls.add_method('ResetStartSubstream', 'void', [])
   996     cls.add_method('ResetStartSubstream', 
       
   997                    'void', 
       
   998                    [])
   703     ## rng-stream.h: void ns3::RngStream::ResetNextSubstream() [member function]
   999     ## rng-stream.h: void ns3::RngStream::ResetNextSubstream() [member function]
   704     cls.add_method('ResetNextSubstream', 'void', [])
  1000     cls.add_method('ResetNextSubstream', 
       
  1001                    'void', 
       
  1002                    [])
   705     ## rng-stream.h: void ns3::RngStream::ResetNthSubstream(uint32_t N) [member function]
  1003     ## rng-stream.h: void ns3::RngStream::ResetNthSubstream(uint32_t N) [member function]
   706     cls.add_method('ResetNthSubstream', 'void', [param('uint32_t', 'N')])
  1004     cls.add_method('ResetNthSubstream', 
       
  1005                    'void', 
       
  1006                    [param('uint32_t', 'N')])
   707     ## rng-stream.h: void ns3::RngStream::SetAntithetic(bool a) [member function]
  1007     ## rng-stream.h: void ns3::RngStream::SetAntithetic(bool a) [member function]
   708     cls.add_method('SetAntithetic', 'void', [param('bool', 'a')])
  1008     cls.add_method('SetAntithetic', 
       
  1009                    'void', 
       
  1010                    [param('bool', 'a')])
   709     ## rng-stream.h: void ns3::RngStream::IncreasedPrecis(bool incp) [member function]
  1011     ## rng-stream.h: void ns3::RngStream::IncreasedPrecis(bool incp) [member function]
   710     cls.add_method('IncreasedPrecis', 'void', [param('bool', 'incp')])
  1012     cls.add_method('IncreasedPrecis', 
       
  1013                    'void', 
       
  1014                    [param('bool', 'incp')])
   711     ## rng-stream.h: bool ns3::RngStream::SetSeeds(uint32_t const * seed) [member function]
  1015     ## rng-stream.h: bool ns3::RngStream::SetSeeds(uint32_t const * seed) [member function]
   712     cls.add_method('SetSeeds', 'bool', [param('uint32_t *', 'seed', transfer_ownership=False, is_const=True)])
  1016     cls.add_method('SetSeeds', 
       
  1017                    'bool', 
       
  1018                    [param('uint32_t *', 'seed', transfer_ownership=False, is_const=True)])
   713     ## rng-stream.h: void ns3::RngStream::AdvanceState(int32_t e, int32_t c) [member function]
  1019     ## rng-stream.h: void ns3::RngStream::AdvanceState(int32_t e, int32_t c) [member function]
   714     cls.add_method('AdvanceState', 'void', [param('int32_t', 'e'), param('int32_t', 'c')])
  1020     cls.add_method('AdvanceState', 
       
  1021                    'void', 
       
  1022                    [param('int32_t', 'e'), param('int32_t', 'c')])
   715     ## rng-stream.h: void ns3::RngStream::GetState(uint32_t * seed) const [member function]
  1023     ## rng-stream.h: void ns3::RngStream::GetState(uint32_t * seed) const [member function]
   716     cls.add_method('GetState', 'void', [param('uint32_t *', 'seed')], is_const=True)
  1024     cls.add_method('GetState', 
       
  1025                    'void', 
       
  1026                    [param('uint32_t *', 'seed')], 
       
  1027                    is_const=True)
   717     ## rng-stream.h: double ns3::RngStream::RandU01() [member function]
  1028     ## rng-stream.h: double ns3::RngStream::RandU01() [member function]
   718     cls.add_method('RandU01', 'double', [])
  1029     cls.add_method('RandU01', 
       
  1030                    'double', 
       
  1031                    [])
   719     ## rng-stream.h: int32_t ns3::RngStream::RandInt(int32_t i, int32_t j) [member function]
  1032     ## rng-stream.h: int32_t ns3::RngStream::RandInt(int32_t i, int32_t j) [member function]
   720     cls.add_method('RandInt', 'int32_t', [param('int32_t', 'i'), param('int32_t', 'j')])
  1033     cls.add_method('RandInt', 
       
  1034                    'int32_t', 
       
  1035                    [param('int32_t', 'i'), param('int32_t', 'j')])
   721     ## rng-stream.h: static bool ns3::RngStream::SetPackageSeed(uint32_t const * seed) [member function]
  1036     ## rng-stream.h: static bool ns3::RngStream::SetPackageSeed(uint32_t const * seed) [member function]
   722     cls.add_method('SetPackageSeed', 'bool', [param('uint32_t *', 'seed', transfer_ownership=False, is_const=True)], is_static=True)
  1037     cls.add_method('SetPackageSeed', 
       
  1038                    'bool', 
       
  1039                    [param('uint32_t *', 'seed', transfer_ownership=False, is_const=True)], 
       
  1040                    is_static=True)
   723     ## rng-stream.h: static bool ns3::RngStream::CheckSeed(uint32_t const * seed) [member function]
  1041     ## rng-stream.h: static bool ns3::RngStream::CheckSeed(uint32_t const * seed) [member function]
   724     cls.add_method('CheckSeed', 'bool', [param('uint32_t *', 'seed', transfer_ownership=False, is_const=True)], is_static=True)
  1042     cls.add_method('CheckSeed', 
       
  1043                    'bool', 
       
  1044                    [param('uint32_t *', 'seed', transfer_ownership=False, is_const=True)], 
       
  1045                    is_static=True)
   725     return
  1046     return
   726 
  1047 
   727 def register_Ns3LogNormalVariable_methods(root_module, cls):
  1048 def register_Ns3LogNormalVariable_methods(root_module, cls):
   728     ## random-variable.h: ns3::LogNormalVariable::LogNormalVariable(double mu, double sigma) [constructor]
  1049     ## random-variable.h: ns3::LogNormalVariable::LogNormalVariable(double mu, double sigma) [constructor]
   729     cls.add_constructor([param('double', 'mu'), param('double', 'sigma')], visibility='public')
  1050     cls.add_constructor([param('double', 'mu'), param('double', 'sigma')])
   730     ## random-variable.h: static double ns3::LogNormalVariable::GetSingleValue(double mu, double sigma) [member function]
  1051     ## random-variable.h: static double ns3::LogNormalVariable::GetSingleValue(double mu, double sigma) [member function]
   731     cls.add_method('GetSingleValue', 'double', [param('double', 'mu'), param('double', 'sigma')], is_static=True)
  1052     cls.add_method('GetSingleValue', 
       
  1053                    'double', 
       
  1054                    [param('double', 'mu'), param('double', 'sigma')], 
       
  1055                    is_static=True)
   732     return
  1056     return
   733 
  1057 
   734 def register_Ns3IntEmpiricalVariable_methods(root_module, cls):
  1058 def register_Ns3IntEmpiricalVariable_methods(root_module, cls):
   735     ## random-variable.h: ns3::IntEmpiricalVariable::IntEmpiricalVariable() [constructor]
  1059     ## random-variable.h: ns3::IntEmpiricalVariable::IntEmpiricalVariable() [constructor]
   736     cls.add_constructor([], visibility='public')
  1060     cls.add_constructor([])
   737     return
  1061     return
   738 
  1062 
   739 def register_Ns3PointerChecker_methods(root_module, cls):
  1063 def register_Ns3PointerChecker_methods(root_module, cls):
   740     ## pointer.h: ns3::TypeId ns3::PointerChecker::GetPointeeTypeId() const [member function]
  1064     ## pointer.h: ns3::TypeId ns3::PointerChecker::GetPointeeTypeId() const [member function]
   741     cls.add_method('GetPointeeTypeId', 'ns3::TypeId', [], is_pure_virtual=True, is_const=True, is_virtual=True)
  1065     cls.add_method('GetPointeeTypeId', 
       
  1066                    'ns3::TypeId', 
       
  1067                    [], 
       
  1068                    is_pure_virtual=True, is_const=True, is_virtual=True)
   742     cls.add_constructor([])
  1069     cls.add_constructor([])
   743     return
  1070     return
   744 
  1071 
   745 def register_Ns3WeibullVariable_methods(root_module, cls):
  1072 def register_Ns3WeibullVariable_methods(root_module, cls):
   746     ## random-variable.h: ns3::WeibullVariable::WeibullVariable() [constructor]
  1073     ## random-variable.h: ns3::WeibullVariable::WeibullVariable() [constructor]
   747     cls.add_constructor([], visibility='public')
  1074     cls.add_constructor([])
   748     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(double m) [constructor]
  1075     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(double m) [constructor]
   749     cls.add_constructor([param('double', 'm')], visibility='public')
  1076     cls.add_constructor([param('double', 'm')])
   750     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(double m, double s) [constructor]
  1077     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(double m, double s) [constructor]
   751     cls.add_constructor([param('double', 'm'), param('double', 's')], visibility='public')
  1078     cls.add_constructor([param('double', 'm'), param('double', 's')])
   752     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(double m, double s, double b) [constructor]
  1079     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(double m, double s, double b) [constructor]
   753     cls.add_constructor([param('double', 'm'), param('double', 's'), param('double', 'b')], visibility='public')
  1080     cls.add_constructor([param('double', 'm'), param('double', 's'), param('double', 'b')])
   754     ## random-variable.h: static double ns3::WeibullVariable::GetSingleValue(double m, double s, double b=0) [member function]
  1081     ## random-variable.h: static double ns3::WeibullVariable::GetSingleValue(double m, double s, double b=0) [member function]
   755     cls.add_method('GetSingleValue', 'double', [param('double', 'm'), param('double', 's'), param('double', 'b', default_value='0')], is_static=True)
  1082     cls.add_method('GetSingleValue', 
       
  1083                    'double', 
       
  1084                    [param('double', 'm'), param('double', 's'), param('double', 'b', default_value='0')], 
       
  1085                    is_static=True)
   756     return
  1086     return
   757 
  1087 
   758 def register_Ns3CallbackBase_methods(root_module, cls):
  1088 def register_Ns3CallbackBase_methods(root_module, cls):
   759     ## callback.h: ns3::CallbackBase::CallbackBase() [constructor]
  1089     ## callback.h: ns3::CallbackBase::CallbackBase() [constructor]
   760     cls.add_constructor([], visibility='public')
  1090     cls.add_constructor([])
   761     ## callback.h: ns3::Ptr<ns3::CallbackImplBase> ns3::CallbackBase::GetImpl() const [member function]
  1091     ## callback.h: ns3::Ptr<ns3::CallbackImplBase> ns3::CallbackBase::GetImpl() const [member function]
   762     cls.add_method('GetImpl', 'ns3::Ptr< ns3::CallbackImplBase >', [], is_const=True)
  1092     cls.add_method('GetImpl', 
       
  1093                    'ns3::Ptr< ns3::CallbackImplBase >', 
       
  1094                    [], 
       
  1095                    is_const=True)
   763     ## callback.h: ns3::CallbackBase::CallbackBase(ns3::Ptr<ns3::CallbackImplBase> impl) [constructor]
  1096     ## callback.h: ns3::CallbackBase::CallbackBase(ns3::Ptr<ns3::CallbackImplBase> impl) [constructor]
   764     cls.add_constructor([param('ns3::Ptr< ns3::CallbackImplBase >', 'impl')], visibility='protected')
  1097     cls.add_constructor([param('ns3::Ptr< ns3::CallbackImplBase >', 'impl')], 
       
  1098                         visibility='protected')
   765     return
  1099     return
   766 
  1100 
   767 def register_Ns3ExponentialVariable_methods(root_module, cls):
  1101 def register_Ns3ExponentialVariable_methods(root_module, cls):
   768     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable() [constructor]
  1102     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable() [constructor]
   769     cls.add_constructor([], visibility='public')
  1103     cls.add_constructor([])
   770     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable(double m) [constructor]
  1104     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable(double m) [constructor]
   771     cls.add_constructor([param('double', 'm')], visibility='public')
  1105     cls.add_constructor([param('double', 'm')])
   772     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable(double m, double b) [constructor]
  1106     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable(double m, double b) [constructor]
   773     cls.add_constructor([param('double', 'm'), param('double', 'b')], visibility='public')
  1107     cls.add_constructor([param('double', 'm'), param('double', 'b')])
   774     ## random-variable.h: static double ns3::ExponentialVariable::GetSingleValue(double m, double b=0) [member function]
  1108     ## random-variable.h: static double ns3::ExponentialVariable::GetSingleValue(double m, double b=0) [member function]
   775     cls.add_method('GetSingleValue', 'double', [param('double', 'm'), param('double', 'b', default_value='0')], is_static=True)
  1109     cls.add_method('GetSingleValue', 
       
  1110                    'double', 
       
  1111                    [param('double', 'm'), param('double', 'b', default_value='0')], 
       
  1112                    is_static=True)
   776     return
  1113     return
   777 
  1114 
   778 def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Ns3Mac48Address_Ns3Empty_Ns3Empty_methods(root_module, cls):
  1115 def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Ns3Mac48Address_Ns3Empty_Ns3Empty_methods(root_module, cls):
   779     ## traced-callback.h: ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Mac48Address, ns3::empty, ns3::empty>::TracedCallback() [constructor]
  1116     ## traced-callback.h: ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Mac48Address, ns3::empty, ns3::empty>::TracedCallback() [constructor]
   780     cls.add_constructor([], visibility='public')
  1117     cls.add_constructor([])
   781     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Mac48Address, ns3::empty, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
  1118     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Mac48Address, ns3::empty, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
   782     cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
  1119     cls.add_method('ConnectWithoutContext', 
       
  1120                    'void', 
       
  1121                    [param('ns3::CallbackBase&', 'callback', is_const=True)])
   783     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Mac48Address, ns3::empty, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
  1122     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Mac48Address, ns3::empty, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
   784     cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
  1123     cls.add_method('Connect', 
       
  1124                    'void', 
       
  1125                    [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
   785     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Mac48Address, ns3::empty, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
  1126     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Mac48Address, ns3::empty, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
   786     cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
  1127     cls.add_method('DisconnectWithoutContext', 
       
  1128                    'void', 
       
  1129                    [param('ns3::CallbackBase&', 'callback', is_const=True)])
   787     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Mac48Address, ns3::empty, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
  1130     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Mac48Address, ns3::empty, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
   788     cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
  1131     cls.add_method('Disconnect', 
       
  1132                    'void', 
       
  1133                    [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
   789     return
  1134     return
   790 
  1135 
   791 def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls):
  1136 def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls):
   792     ## traced-callback.h: ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::empty, ns3::empty, ns3::empty>::TracedCallback() [constructor]
  1137     ## traced-callback.h: ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::empty, ns3::empty, ns3::empty>::TracedCallback() [constructor]
   793     cls.add_constructor([], visibility='public')
  1138     cls.add_constructor([])
   794     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::empty, ns3::empty, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
  1139     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::empty, ns3::empty, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
   795     cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
  1140     cls.add_method('ConnectWithoutContext', 
       
  1141                    'void', 
       
  1142                    [param('ns3::CallbackBase&', 'callback', is_const=True)])
   796     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::empty, ns3::empty, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
  1143     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::empty, ns3::empty, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
   797     cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
  1144     cls.add_method('Connect', 
       
  1145                    'void', 
       
  1146                    [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
   798     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::empty, ns3::empty, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
  1147     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::empty, ns3::empty, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
   799     cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
  1148     cls.add_method('DisconnectWithoutContext', 
       
  1149                    'void', 
       
  1150                    [param('ns3::CallbackBase&', 'callback', is_const=True)])
   800     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::empty, ns3::empty, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
  1151     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::empty, ns3::empty, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
   801     cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
  1152     cls.add_method('Disconnect', 
       
  1153                    'void', 
       
  1154                    [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
   802     return
  1155     return
   803 
  1156 
   804 def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Ns3Address_const__amp___Ns3Empty_Ns3Empty_methods(root_module, cls):
  1157 def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Ns3Address_const__amp___Ns3Empty_Ns3Empty_methods(root_module, cls):
   805     ## traced-callback.h: ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Address const&, ns3::empty, ns3::empty>::TracedCallback() [constructor]
  1158     ## traced-callback.h: ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Address const&, ns3::empty, ns3::empty>::TracedCallback() [constructor]
   806     cls.add_constructor([], visibility='public')
  1159     cls.add_constructor([])
   807     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Address const&, ns3::empty, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
  1160     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Address const&, ns3::empty, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
   808     cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
  1161     cls.add_method('ConnectWithoutContext', 
       
  1162                    'void', 
       
  1163                    [param('ns3::CallbackBase&', 'callback', is_const=True)])
   809     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Address const&, ns3::empty, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
  1164     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Address const&, ns3::empty, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
   810     cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
  1165     cls.add_method('Connect', 
       
  1166                    'void', 
       
  1167                    [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
   811     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Address const&, ns3::empty, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
  1168     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Address const&, ns3::empty, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
   812     cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
  1169     cls.add_method('DisconnectWithoutContext', 
       
  1170                    'void', 
       
  1171                    [param('ns3::CallbackBase&', 'callback', is_const=True)])
   813     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Address const&, ns3::empty, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
  1172     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::Address const&, ns3::empty, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
   814     cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
  1173     cls.add_method('Disconnect', 
       
  1174                    'void', 
       
  1175                    [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
   815     return
  1176     return
   816 
  1177 
   817 def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Unsigned_int_Ns3Empty_Ns3Empty_methods(root_module, cls):
  1178 def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Unsigned_int_Ns3Empty_Ns3Empty_methods(root_module, cls):
   818     ## traced-callback.h: ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, unsigned int, ns3::empty, ns3::empty>::TracedCallback() [constructor]
  1179     ## traced-callback.h: ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, unsigned int, ns3::empty, ns3::empty>::TracedCallback() [constructor]
   819     cls.add_constructor([], visibility='public')
  1180     cls.add_constructor([])
   820     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, unsigned int, ns3::empty, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
  1181     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, unsigned int, ns3::empty, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
   821     cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
  1182     cls.add_method('ConnectWithoutContext', 
       
  1183                    'void', 
       
  1184                    [param('ns3::CallbackBase&', 'callback', is_const=True)])
   822     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, unsigned int, ns3::empty, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
  1185     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, unsigned int, ns3::empty, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
   823     cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
  1186     cls.add_method('Connect', 
       
  1187                    'void', 
       
  1188                    [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
   824     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, unsigned int, ns3::empty, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
  1189     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, unsigned int, ns3::empty, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
   825     cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
  1190     cls.add_method('DisconnectWithoutContext', 
       
  1191                    'void', 
       
  1192                    [param('ns3::CallbackBase&', 'callback', is_const=True)])
   826     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, unsigned int, ns3::empty, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
  1193     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, unsigned int, ns3::empty, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
   827     cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
  1194     cls.add_method('Disconnect', 
       
  1195                    'void', 
       
  1196                    [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
   828     return
  1197     return
   829 
  1198 
   830 def register_Ns3TracedCallback__Ns3Ptr__lt__ns3MobilityModel_const__gt___Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls):
  1199 def register_Ns3TracedCallback__Ns3Ptr__lt__ns3MobilityModel_const__gt___Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls):
   831     ## traced-callback.h: ns3::TracedCallback<ns3::Ptr<ns3::MobilityModel const>, ns3::empty, ns3::empty, ns3::empty>::TracedCallback() [constructor]
  1200     ## traced-callback.h: ns3::TracedCallback<ns3::Ptr<ns3::MobilityModel const>, ns3::empty, ns3::empty, ns3::empty>::TracedCallback() [constructor]
   832     cls.add_constructor([], visibility='public')
  1201     cls.add_constructor([])
   833     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::MobilityModel const>, ns3::empty, ns3::empty, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
  1202     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::MobilityModel const>, ns3::empty, ns3::empty, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
   834     cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
  1203     cls.add_method('ConnectWithoutContext', 
       
  1204                    'void', 
       
  1205                    [param('ns3::CallbackBase&', 'callback', is_const=True)])
   835     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::MobilityModel const>, ns3::empty, ns3::empty, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
  1206     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::MobilityModel const>, ns3::empty, ns3::empty, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
   836     cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
  1207     cls.add_method('Connect', 
       
  1208                    'void', 
       
  1209                    [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
   837     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::MobilityModel const>, ns3::empty, ns3::empty, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
  1210     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::MobilityModel const>, ns3::empty, ns3::empty, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
   838     cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
  1211     cls.add_method('DisconnectWithoutContext', 
       
  1212                    'void', 
       
  1213                    [param('ns3::CallbackBase&', 'callback', is_const=True)])
   839     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::MobilityModel const>, ns3::empty, ns3::empty, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
  1214     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::MobilityModel const>, ns3::empty, ns3::empty, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
   840     cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
  1215     cls.add_method('Disconnect', 
       
  1216                    'void', 
       
  1217                    [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
   841     return
  1218     return
   842 
  1219 
   843 def register_Ns3TracedCallback__Ns3TimeUnit__lt__1__gt___Ns3TimeUnit__lt__1__gt___Ns3WifiPhyState_Ns3Empty_methods(root_module, cls):
  1220 def register_Ns3TracedCallback__Ns3TimeUnit__lt__1__gt___Ns3TimeUnit__lt__1__gt___Ns3WifiPhyState_Ns3Empty_methods(root_module, cls):
   844     ## traced-callback.h: ns3::TracedCallback<ns3::TimeUnit<1>, ns3::TimeUnit<1>, ns3::WifiPhy::State, ns3::empty>::TracedCallback() [constructor]
  1221     ## traced-callback.h: ns3::TracedCallback<ns3::TimeUnit<1>, ns3::TimeUnit<1>, ns3::WifiPhy::State, ns3::empty>::TracedCallback() [constructor]
   845     cls.add_constructor([], visibility='public')
  1222     cls.add_constructor([])
   846     ## traced-callback.h: void ns3::TracedCallback<ns3::TimeUnit<1>, ns3::TimeUnit<1>, ns3::WifiPhy::State, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
  1223     ## traced-callback.h: void ns3::TracedCallback<ns3::TimeUnit<1>, ns3::TimeUnit<1>, ns3::WifiPhy::State, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
   847     cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
  1224     cls.add_method('ConnectWithoutContext', 
       
  1225                    'void', 
       
  1226                    [param('ns3::CallbackBase&', 'callback', is_const=True)])
   848     ## traced-callback.h: void ns3::TracedCallback<ns3::TimeUnit<1>, ns3::TimeUnit<1>, ns3::WifiPhy::State, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
  1227     ## traced-callback.h: void ns3::TracedCallback<ns3::TimeUnit<1>, ns3::TimeUnit<1>, ns3::WifiPhy::State, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
   849     cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
  1228     cls.add_method('Connect', 
       
  1229                    'void', 
       
  1230                    [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
   850     ## traced-callback.h: void ns3::TracedCallback<ns3::TimeUnit<1>, ns3::TimeUnit<1>, ns3::WifiPhy::State, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
  1231     ## traced-callback.h: void ns3::TracedCallback<ns3::TimeUnit<1>, ns3::TimeUnit<1>, ns3::WifiPhy::State, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
   851     cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
  1232     cls.add_method('DisconnectWithoutContext', 
       
  1233                    'void', 
       
  1234                    [param('ns3::CallbackBase&', 'callback', is_const=True)])
   852     ## traced-callback.h: void ns3::TracedCallback<ns3::TimeUnit<1>, ns3::TimeUnit<1>, ns3::WifiPhy::State, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
  1235     ## traced-callback.h: void ns3::TracedCallback<ns3::TimeUnit<1>, ns3::TimeUnit<1>, ns3::WifiPhy::State, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
   853     cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
  1236     cls.add_method('Disconnect', 
       
  1237                    'void', 
       
  1238                    [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
   854     return
  1239     return
   855 
  1240 
   856 def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Ns3WifiMode_Ns3WifiPreamble_Unsigned_char_methods(root_module, cls):
  1241 def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Ns3WifiMode_Ns3WifiPreamble_Unsigned_char_methods(root_module, cls):
   857     ## traced-callback.h: ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::WifiMode, ns3::WifiPreamble, unsigned char>::TracedCallback() [constructor]
  1242     ## traced-callback.h: ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::WifiMode, ns3::WifiPreamble, unsigned char>::TracedCallback() [constructor]
   858     cls.add_constructor([], visibility='public')
  1243     cls.add_constructor([])
   859     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::WifiMode, ns3::WifiPreamble, unsigned char>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
  1244     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::WifiMode, ns3::WifiPreamble, unsigned char>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
   860     cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
  1245     cls.add_method('ConnectWithoutContext', 
       
  1246                    'void', 
       
  1247                    [param('ns3::CallbackBase&', 'callback', is_const=True)])
   861     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::WifiMode, ns3::WifiPreamble, unsigned char>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
  1248     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::WifiMode, ns3::WifiPreamble, unsigned char>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
   862     cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
  1249     cls.add_method('Connect', 
       
  1250                    'void', 
       
  1251                    [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
   863     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::WifiMode, ns3::WifiPreamble, unsigned char>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
  1252     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::WifiMode, ns3::WifiPreamble, unsigned char>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
   864     cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
  1253     cls.add_method('DisconnectWithoutContext', 
       
  1254                    'void', 
       
  1255                    [param('ns3::CallbackBase&', 'callback', is_const=True)])
   865     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::WifiMode, ns3::WifiPreamble, unsigned char>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
  1256     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, ns3::WifiMode, ns3::WifiPreamble, unsigned char>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
   866     cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
  1257     cls.add_method('Disconnect', 
       
  1258                    'void', 
       
  1259                    [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
   867     return
  1260     return
   868 
  1261 
   869 def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Double_Ns3Empty_Ns3Empty_methods(root_module, cls):
  1262 def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Double_Ns3Empty_Ns3Empty_methods(root_module, cls):
   870     ## traced-callback.h: ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::empty, ns3::empty>::TracedCallback() [constructor]
  1263     ## traced-callback.h: ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::empty, ns3::empty>::TracedCallback() [constructor]
   871     cls.add_constructor([], visibility='public')
  1264     cls.add_constructor([])
   872     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::empty, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
  1265     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::empty, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
   873     cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
  1266     cls.add_method('ConnectWithoutContext', 
       
  1267                    'void', 
       
  1268                    [param('ns3::CallbackBase&', 'callback', is_const=True)])
   874     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::empty, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
  1269     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::empty, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
   875     cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
  1270     cls.add_method('Connect', 
       
  1271                    'void', 
       
  1272                    [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
   876     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::empty, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
  1273     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::empty, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
   877     cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
  1274     cls.add_method('DisconnectWithoutContext', 
       
  1275                    'void', 
       
  1276                    [param('ns3::CallbackBase&', 'callback', is_const=True)])
   878     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::empty, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
  1277     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::empty, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
   879     cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
  1278     cls.add_method('Disconnect', 
       
  1279                    'void', 
       
  1280                    [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
   880     return
  1281     return
   881 
  1282 
   882 def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Double_Ns3WifiMode_Ns3WifiPreamble_methods(root_module, cls):
  1283 def register_Ns3TracedCallback__Ns3Ptr__lt__ns3Packet_const__gt___Double_Ns3WifiMode_Ns3WifiPreamble_methods(root_module, cls):
   883     ## traced-callback.h: ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::WifiMode, ns3::WifiPreamble>::TracedCallback() [constructor]
  1284     ## traced-callback.h: ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::WifiMode, ns3::WifiPreamble>::TracedCallback() [constructor]
   884     cls.add_constructor([], visibility='public')
  1285     cls.add_constructor([])
   885     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::WifiMode, ns3::WifiPreamble>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
  1286     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::WifiMode, ns3::WifiPreamble>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
   886     cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
  1287     cls.add_method('ConnectWithoutContext', 
       
  1288                    'void', 
       
  1289                    [param('ns3::CallbackBase&', 'callback', is_const=True)])
   887     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::WifiMode, ns3::WifiPreamble>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
  1290     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::WifiMode, ns3::WifiPreamble>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
   888     cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
  1291     cls.add_method('Connect', 
       
  1292                    'void', 
       
  1293                    [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
   889     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::WifiMode, ns3::WifiPreamble>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
  1294     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::WifiMode, ns3::WifiPreamble>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
   890     cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
  1295     cls.add_method('DisconnectWithoutContext', 
       
  1296                    'void', 
       
  1297                    [param('ns3::CallbackBase&', 'callback', is_const=True)])
   891     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::WifiMode, ns3::WifiPreamble>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
  1298     ## traced-callback.h: void ns3::TracedCallback<ns3::Ptr<ns3::Packet const>, double, ns3::WifiMode, ns3::WifiPreamble>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
   892     cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
  1299     cls.add_method('Disconnect', 
       
  1300                    'void', 
       
  1301                    [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
   893     return
  1302     return
   894 
  1303 
   895 def register_Ns3TracedCallback__Unsigned_int_Unsigned_int_Ns3Empty_Ns3Empty_methods(root_module, cls):
  1304 def register_Ns3TracedCallback__Unsigned_int_Unsigned_int_Ns3Empty_Ns3Empty_methods(root_module, cls):
   896     ## traced-callback.h: ns3::TracedCallback<unsigned int, unsigned int, ns3::empty, ns3::empty>::TracedCallback() [constructor]
  1305     ## traced-callback.h: ns3::TracedCallback<unsigned int, unsigned int, ns3::empty, ns3::empty>::TracedCallback() [constructor]
   897     cls.add_constructor([], visibility='public')
  1306     cls.add_constructor([])
   898     ## traced-callback.h: void ns3::TracedCallback<unsigned int, unsigned int, ns3::empty, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
  1307     ## traced-callback.h: void ns3::TracedCallback<unsigned int, unsigned int, ns3::empty, ns3::empty>::ConnectWithoutContext(ns3::CallbackBase const & callback) [member function]
   899     cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
  1308     cls.add_method('ConnectWithoutContext', 
       
  1309                    'void', 
       
  1310                    [param('ns3::CallbackBase&', 'callback', is_const=True)])
   900     ## traced-callback.h: void ns3::TracedCallback<unsigned int, unsigned int, ns3::empty, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
  1311     ## traced-callback.h: void ns3::TracedCallback<unsigned int, unsigned int, ns3::empty, ns3::empty>::Connect(ns3::CallbackBase const & callback, std::string path) [member function]
   901     cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
  1312     cls.add_method('Connect', 
       
  1313                    'void', 
       
  1314                    [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
   902     ## traced-callback.h: void ns3::TracedCallback<unsigned int, unsigned int, ns3::empty, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
  1315     ## traced-callback.h: void ns3::TracedCallback<unsigned int, unsigned int, ns3::empty, ns3::empty>::DisconnectWithoutContext(ns3::CallbackBase const & callback) [member function]
   903     cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True)])
  1316     cls.add_method('DisconnectWithoutContext', 
       
  1317                    'void', 
       
  1318                    [param('ns3::CallbackBase&', 'callback', is_const=True)])
   904     ## traced-callback.h: void ns3::TracedCallback<unsigned int, unsigned int, ns3::empty, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
  1319     ## traced-callback.h: void ns3::TracedCallback<unsigned int, unsigned int, ns3::empty, ns3::empty>::Disconnect(ns3::CallbackBase const & callback, std::string path) [member function]
   905     cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
  1320     cls.add_method('Disconnect', 
       
  1321                    'void', 
       
  1322                    [param('ns3::CallbackBase&', 'callback', is_const=True), param('std::string', 'path')])
   906     return
  1323     return
   907 
  1324 
   908 def register_Ns3DeterministicVariable_methods(root_module, cls):
  1325 def register_Ns3DeterministicVariable_methods(root_module, cls):
   909     ## random-variable.h: ns3::DeterministicVariable::DeterministicVariable(double * d, uint32_t c) [constructor]
  1326     ## random-variable.h: ns3::DeterministicVariable::DeterministicVariable(double * d, uint32_t c) [constructor]
   910     cls.add_constructor([param('double *', 'd'), param('uint32_t', 'c')], visibility='public')
  1327     cls.add_constructor([param('double *', 'd'), param('uint32_t', 'c')])
   911     return
  1328     return
   912 
  1329 
   913 def register_Ns3AttributeList_methods(root_module, cls):
  1330 def register_Ns3AttributeList_methods(root_module, cls):
   914     ## attribute-list.h: ns3::AttributeList::AttributeList() [constructor]
  1331     ## attribute-list.h: ns3::AttributeList::AttributeList() [constructor]
   915     cls.add_constructor([], visibility='public')
  1332     cls.add_constructor([])
   916     ## attribute-list.h: ns3::AttributeList::AttributeList(ns3::AttributeList const & o) [copy constructor]
  1333     ## attribute-list.h: ns3::AttributeList::AttributeList(ns3::AttributeList const & o) [copy constructor]
   917     cls.add_constructor([param('ns3::AttributeList&', 'o', is_const=True)], visibility='public')
  1334     cls.add_constructor([param('ns3::AttributeList&', 'o', is_const=True)])
   918     ## attribute-list.h: void ns3::AttributeList::Set(std::string name, ns3::AttributeValue const & value) [member function]
  1335     ## attribute-list.h: void ns3::AttributeList::Set(std::string name, ns3::AttributeValue const & value) [member function]
   919     cls.add_method('Set', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
  1336     cls.add_method('Set', 
       
  1337                    'void', 
       
  1338                    [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
   920     ## attribute-list.h: bool ns3::AttributeList::SetFailSafe(std::string name, ns3::AttributeValue const & value) [member function]
  1339     ## attribute-list.h: bool ns3::AttributeList::SetFailSafe(std::string name, ns3::AttributeValue const & value) [member function]
   921     cls.add_method('SetFailSafe', 'bool', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
  1340     cls.add_method('SetFailSafe', 
       
  1341                    'bool', 
       
  1342                    [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
   922     ## attribute-list.h: void ns3::AttributeList::SetWithTid(ns3::TypeId tid, std::string name, ns3::AttributeValue const & value) [member function]
  1343     ## attribute-list.h: void ns3::AttributeList::SetWithTid(ns3::TypeId tid, std::string name, ns3::AttributeValue const & value) [member function]
   923     cls.add_method('SetWithTid', 'void', [param('ns3::TypeId', 'tid'), param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
  1344     cls.add_method('SetWithTid', 
       
  1345                    'void', 
       
  1346                    [param('ns3::TypeId', 'tid'), param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
   924     ## attribute-list.h: void ns3::AttributeList::Reset() [member function]
  1347     ## attribute-list.h: void ns3::AttributeList::Reset() [member function]
   925     cls.add_method('Reset', 'void', [])
  1348     cls.add_method('Reset', 
       
  1349                    'void', 
       
  1350                    [])
   926     ## attribute-list.h: static ns3::AttributeList * ns3::AttributeList::GetGlobal() [member function]
  1351     ## attribute-list.h: static ns3::AttributeList * ns3::AttributeList::GetGlobal() [member function]
   927     cls.add_method('GetGlobal', 'ns3::AttributeList *', [], is_static=True)
  1352     cls.add_method('GetGlobal', 
       
  1353                    'ns3::AttributeList *', 
       
  1354                    [], 
       
  1355                    is_static=True)
   928     ## attribute-list.h: std::string ns3::AttributeList::SerializeToString() const [member function]
  1356     ## attribute-list.h: std::string ns3::AttributeList::SerializeToString() const [member function]
   929     cls.add_method('SerializeToString', 'std::string', [], is_const=True)
  1357     cls.add_method('SerializeToString', 
       
  1358                    'std::string', 
       
  1359                    [], 
       
  1360                    is_const=True)
   930     ## attribute-list.h: bool ns3::AttributeList::DeserializeFromString(std::string value) [member function]
  1361     ## attribute-list.h: bool ns3::AttributeList::DeserializeFromString(std::string value) [member function]
   931     cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value')])
  1362     cls.add_method('DeserializeFromString', 
       
  1363                    'bool', 
       
  1364                    [param('std::string', 'value')])
   932     return
  1365     return
   933 
  1366 
   934 def register_Ns3AttributeValue_methods(root_module, cls):
  1367 def register_Ns3AttributeValue_methods(root_module, cls):
   935     ## attribute.h: ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [copy constructor]
  1368     ## attribute.h: ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [copy constructor]
   936     cls.add_constructor([param('ns3::AttributeValue&', 'arg0', is_const=True)], visibility='public')
  1369     cls.add_constructor([param('ns3::AttributeValue&', 'arg0', is_const=True)])
   937     ## attribute.h: ns3::AttributeValue::AttributeValue() [constructor]
  1370     ## attribute.h: ns3::AttributeValue::AttributeValue() [constructor]
   938     cls.add_constructor([], visibility='public')
  1371     cls.add_constructor([])
   939     ## attribute.h: ns3::Ptr<ns3::AttributeValue> ns3::AttributeValue::Copy() const [member function]
  1372     ## attribute.h: ns3::Ptr<ns3::AttributeValue> ns3::AttributeValue::Copy() const [member function]
   940     cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_pure_virtual=True, is_const=True, is_virtual=True)
  1373     cls.add_method('Copy', 
       
  1374                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1375                    [], 
       
  1376                    is_pure_virtual=True, is_const=True, is_virtual=True)
   941     ## attribute.h: std::string ns3::AttributeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1377     ## attribute.h: std::string ns3::AttributeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
   942     cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_pure_virtual=True, is_const=True, is_virtual=True)
  1378     cls.add_method('SerializeToString', 
       
  1379                    'std::string', 
       
  1380                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1381                    is_pure_virtual=True, is_const=True, is_virtual=True)
   943     ## attribute.h: bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1382     ## attribute.h: bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   944     cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_pure_virtual=True, is_virtual=True)
  1383     cls.add_method('DeserializeFromString', 
       
  1384                    'bool', 
       
  1385                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1386                    is_pure_virtual=True, is_virtual=True)
   945     return
  1387     return
   946 
  1388 
   947 def register_Ns3UniformVariable_methods(root_module, cls):
  1389 def register_Ns3UniformVariable_methods(root_module, cls):
   948     ## random-variable.h: ns3::UniformVariable::UniformVariable() [constructor]
  1390     ## random-variable.h: ns3::UniformVariable::UniformVariable() [constructor]
   949     cls.add_constructor([], visibility='public')
  1391     cls.add_constructor([])
   950     ## random-variable.h: ns3::UniformVariable::UniformVariable(double s, double l) [constructor]
  1392     ## random-variable.h: ns3::UniformVariable::UniformVariable(double s, double l) [constructor]
   951     cls.add_constructor([param('double', 's'), param('double', 'l')], visibility='public')
  1393     cls.add_constructor([param('double', 's'), param('double', 'l')])
   952     ## random-variable.h: static double ns3::UniformVariable::GetSingleValue(double s, double l) [member function]
  1394     ## random-variable.h: static double ns3::UniformVariable::GetSingleValue(double s, double l) [member function]
   953     cls.add_method('GetSingleValue', 'double', [param('double', 's'), param('double', 'l')], is_static=True)
  1395     cls.add_method('GetSingleValue', 
       
  1396                    'double', 
       
  1397                    [param('double', 's'), param('double', 'l')], 
       
  1398                    is_static=True)
   954     return
  1399     return
   955 
  1400 
   956 def register_Ns3Object_methods(root_module, cls):
  1401 def register_Ns3Object_methods(root_module, cls):
   957     ## object.h: static ns3::TypeId ns3::Object::GetTypeId() [member function]
  1402     ## object.h: static ns3::TypeId ns3::Object::GetTypeId() [member function]
   958     cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
  1403     cls.add_method('GetTypeId', 
       
  1404                    'ns3::TypeId', 
       
  1405                    [], 
       
  1406                    is_static=True)
   959     ## object.h: ns3::Object::Object() [constructor]
  1407     ## object.h: ns3::Object::Object() [constructor]
   960     cls.add_constructor([], visibility='public')
  1408     cls.add_constructor([])
   961     ## object.h: ns3::TypeId ns3::Object::GetInstanceTypeId() const [member function]
  1409     ## object.h: ns3::TypeId ns3::Object::GetInstanceTypeId() const [member function]
   962     cls.add_method('GetInstanceTypeId', 'ns3::TypeId', [], is_const=True, is_virtual=True)
  1410     cls.add_method('GetInstanceTypeId', 
       
  1411                    'ns3::TypeId', 
       
  1412                    [], 
       
  1413                    is_const=True, is_virtual=True)
   963     ## object.h: ns3::Ptr<ns3::Object> ns3::Object::GetObject(ns3::TypeId tid) const [member function]
  1414     ## object.h: ns3::Ptr<ns3::Object> ns3::Object::GetObject(ns3::TypeId tid) const [member function]
   964     cls.add_method('GetObject', 'ns3::Ptr< ns3::Object >', [param('ns3::TypeId', 'tid')], is_const=True, template_parameters=['ns3::Object'], custom_template_method_name='GetObject')
  1415     cls.add_method('GetObject', 
       
  1416                    'ns3::Ptr< ns3::Object >', 
       
  1417                    [param('ns3::TypeId', 'tid')], 
       
  1418                    is_const=True, template_parameters=['ns3::Object'], custom_template_method_name='GetObject')
   965     ## object.h: void ns3::Object::Dispose() [member function]
  1419     ## object.h: void ns3::Object::Dispose() [member function]
   966     cls.add_method('Dispose', 'void', [])
  1420     cls.add_method('Dispose', 
       
  1421                    'void', 
       
  1422                    [])
   967     ## object.h: void ns3::Object::AggregateObject(ns3::Ptr<ns3::Object> other) [member function]
  1423     ## object.h: void ns3::Object::AggregateObject(ns3::Ptr<ns3::Object> other) [member function]
   968     cls.add_method('AggregateObject', 'void', [param('ns3::Ptr< ns3::Object >', 'other')])
  1424     cls.add_method('AggregateObject', 
       
  1425                    'void', 
       
  1426                    [param('ns3::Ptr< ns3::Object >', 'other')])
   969     ## object.h: ns3::Object::AggregateIterator ns3::Object::GetAggregateIterator() const [member function]
  1427     ## object.h: ns3::Object::AggregateIterator ns3::Object::GetAggregateIterator() const [member function]
   970     cls.add_method('GetAggregateIterator', 'ns3::Object::AggregateIterator', [], is_const=True)
  1428     cls.add_method('GetAggregateIterator', 
       
  1429                    'ns3::Object::AggregateIterator', 
       
  1430                    [], 
       
  1431                    is_const=True)
   971     ## object.h: void ns3::Object::DoDispose() [member function]
  1432     ## object.h: void ns3::Object::DoDispose() [member function]
   972     cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True)
  1433     cls.add_method('DoDispose', 
       
  1434                    'void', 
       
  1435                    [], 
       
  1436                    visibility='protected', is_virtual=True)
   973     ## object.h: ns3::Object::Object(ns3::Object const & o) [copy constructor]
  1437     ## object.h: ns3::Object::Object(ns3::Object const & o) [copy constructor]
   974     cls.add_constructor([param('ns3::Object&', 'o', is_const=True)], visibility='protected')
  1438     cls.add_constructor([param('ns3::Object&', 'o', is_const=True)], 
       
  1439                         visibility='protected')
   975     return
  1440     return
   976 
  1441 
   977 def register_Ns3ObjectAggregateIterator_methods(root_module, cls):
  1442 def register_Ns3ObjectAggregateIterator_methods(root_module, cls):
   978     ## object.h: ns3::Object::AggregateIterator::AggregateIterator() [constructor]
  1443     ## object.h: ns3::Object::AggregateIterator::AggregateIterator() [constructor]
   979     cls.add_constructor([], visibility='public')
  1444     cls.add_constructor([])
   980     ## object.h: bool ns3::Object::AggregateIterator::HasNext() const [member function]
  1445     ## object.h: bool ns3::Object::AggregateIterator::HasNext() const [member function]
   981     cls.add_method('HasNext', 'bool', [], is_const=True)
  1446     cls.add_method('HasNext', 
       
  1447                    'bool', 
       
  1448                    [], 
       
  1449                    is_const=True)
   982     ## object.h: ns3::Ptr<ns3::Object const> ns3::Object::AggregateIterator::Next() [member function]
  1450     ## object.h: ns3::Ptr<ns3::Object const> ns3::Object::AggregateIterator::Next() [member function]
   983     cls.add_method('Next', 'ns3::Ptr< ns3::Object const >', [])
  1451     cls.add_method('Next', 
       
  1452                    'ns3::Ptr< ns3::Object const >', 
       
  1453                    [])
   984     return
  1454     return
   985 
  1455 
   986 def register_Ns3SystemCondition_methods(root_module, cls):
  1456 def register_Ns3SystemCondition_methods(root_module, cls):
   987     ## system-condition.h: ns3::SystemCondition::SystemCondition() [constructor]
  1457     ## system-condition.h: ns3::SystemCondition::SystemCondition() [constructor]
   988     cls.add_constructor([], visibility='public')
  1458     cls.add_constructor([])
   989     ## system-condition.h: void ns3::SystemCondition::SetCondition(bool condition) [member function]
  1459     ## system-condition.h: void ns3::SystemCondition::SetCondition(bool condition) [member function]
   990     cls.add_method('SetCondition', 'void', [param('bool', 'condition')])
  1460     cls.add_method('SetCondition', 
       
  1461                    'void', 
       
  1462                    [param('bool', 'condition')])
   991     ## system-condition.h: bool ns3::SystemCondition::GetCondition() [member function]
  1463     ## system-condition.h: bool ns3::SystemCondition::GetCondition() [member function]
   992     cls.add_method('GetCondition', 'bool', [])
  1464     cls.add_method('GetCondition', 
       
  1465                    'bool', 
       
  1466                    [])
   993     ## system-condition.h: void ns3::SystemCondition::Signal() [member function]
  1467     ## system-condition.h: void ns3::SystemCondition::Signal() [member function]
   994     cls.add_method('Signal', 'void', [])
  1468     cls.add_method('Signal', 
       
  1469                    'void', 
       
  1470                    [])
   995     ## system-condition.h: void ns3::SystemCondition::Broadcast() [member function]
  1471     ## system-condition.h: void ns3::SystemCondition::Broadcast() [member function]
   996     cls.add_method('Broadcast', 'void', [])
  1472     cls.add_method('Broadcast', 
       
  1473                    'void', 
       
  1474                    [])
   997     ## system-condition.h: void ns3::SystemCondition::Wait() [member function]
  1475     ## system-condition.h: void ns3::SystemCondition::Wait() [member function]
   998     cls.add_method('Wait', 'void', [])
  1476     cls.add_method('Wait', 
       
  1477                    'void', 
       
  1478                    [])
   999     ## system-condition.h: bool ns3::SystemCondition::TimedWait(uint64_t ns) [member function]
  1479     ## system-condition.h: bool ns3::SystemCondition::TimedWait(uint64_t ns) [member function]
  1000     cls.add_method('TimedWait', 'bool', [param('uint64_t', 'ns')])
  1480     cls.add_method('TimedWait', 
       
  1481                    'bool', 
       
  1482                    [param('uint64_t', 'ns')])
  1001     return
  1483     return
  1002 
  1484 
  1003 def register_Ns3SequentialVariable_methods(root_module, cls):
  1485 def register_Ns3SequentialVariable_methods(root_module, cls):
  1004     ## random-variable.h: ns3::SequentialVariable::SequentialVariable(double f, double l, double i=1, uint32_t c=1) [constructor]
  1486     ## random-variable.h: ns3::SequentialVariable::SequentialVariable(double f, double l, double i=1, uint32_t c=1) [constructor]
  1005     cls.add_constructor([param('double', 'f'), param('double', 'l'), param('double', 'i', default_value='1'), param('uint32_t', 'c', default_value='1')], visibility='public')
  1487     cls.add_constructor([param('double', 'f'), param('double', 'l'), param('double', 'i', default_value='1'), param('uint32_t', 'c', default_value='1')])
  1006     ## random-variable.h: ns3::SequentialVariable::SequentialVariable(double f, double l, ns3::RandomVariable const & i, uint32_t c=1) [constructor]
  1488     ## random-variable.h: ns3::SequentialVariable::SequentialVariable(double f, double l, ns3::RandomVariable const & i, uint32_t c=1) [constructor]
  1007     cls.add_constructor([param('double', 'f'), param('double', 'l'), param('ns3::RandomVariable&', 'i', is_const=True), param('uint32_t', 'c', default_value='1')], visibility='public')
  1489     cls.add_constructor([param('double', 'f'), param('double', 'l'), param('ns3::RandomVariable&', 'i', is_const=True), param('uint32_t', 'c', default_value='1')])
  1008     return
  1490     return
  1009 
  1491 
  1010 def register_Ns3ObjectVectorChecker_methods(root_module, cls):
  1492 def register_Ns3ObjectVectorChecker_methods(root_module, cls):
  1011     ## object-vector.h: ns3::TypeId ns3::ObjectVectorChecker::GetItemTypeId() const [member function]
  1493     ## object-vector.h: ns3::TypeId ns3::ObjectVectorChecker::GetItemTypeId() const [member function]
  1012     cls.add_method('GetItemTypeId', 'ns3::TypeId', [], is_pure_virtual=True, is_const=True, is_virtual=True)
  1494     cls.add_method('GetItemTypeId', 
       
  1495                    'ns3::TypeId', 
       
  1496                    [], 
       
  1497                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1013     cls.add_constructor([])
  1498     cls.add_constructor([])
  1014     return
  1499     return
  1015 
  1500 
  1016 def register_Ns3StringChecker_methods(root_module, cls):
  1501 def register_Ns3StringChecker_methods(root_module, cls):
  1017     cls.add_constructor([])
  1502     cls.add_constructor([])
  1018     return
  1503     return
  1019 
  1504 
  1020 def register_Ns3ObjectVectorValue_methods(root_module, cls):
  1505 def register_Ns3ObjectVectorValue_methods(root_module, cls):
  1021     ## object-vector.h: ns3::ObjectVectorValue::ObjectVectorValue() [constructor]
  1506     ## object-vector.h: ns3::ObjectVectorValue::ObjectVectorValue() [constructor]
  1022     cls.add_constructor([], visibility='public')
  1507     cls.add_constructor([])
  1023     ## object-vector.h: __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Object>*,std::vector<ns3::Ptr<ns3::Object>, std::allocator<ns3::Ptr<ns3::Object> > > > ns3::ObjectVectorValue::Begin() const [member function]
  1508     ## object-vector.h: __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Object>*,std::vector<ns3::Ptr<ns3::Object>, std::allocator<ns3::Ptr<ns3::Object> > > > ns3::ObjectVectorValue::Begin() const [member function]
  1024     cls.add_method('Begin', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Object >, std::vector< ns3::Ptr< ns3::Object >, std::allocator< ns3::Ptr< ns3::Object > > > >', [], is_const=True)
  1509     cls.add_method('Begin', 
       
  1510                    '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Object >, std::vector< ns3::Ptr< ns3::Object >, std::allocator< ns3::Ptr< ns3::Object > > > >', 
       
  1511                    [], 
       
  1512                    is_const=True)
  1025     ## object-vector.h: __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Object>*,std::vector<ns3::Ptr<ns3::Object>, std::allocator<ns3::Ptr<ns3::Object> > > > ns3::ObjectVectorValue::End() const [member function]
  1513     ## object-vector.h: __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Object>*,std::vector<ns3::Ptr<ns3::Object>, std::allocator<ns3::Ptr<ns3::Object> > > > ns3::ObjectVectorValue::End() const [member function]
  1026     cls.add_method('End', '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Object >, std::vector< ns3::Ptr< ns3::Object >, std::allocator< ns3::Ptr< ns3::Object > > > >', [], is_const=True)
  1514     cls.add_method('End', 
       
  1515                    '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Object >, std::vector< ns3::Ptr< ns3::Object >, std::allocator< ns3::Ptr< ns3::Object > > > >', 
       
  1516                    [], 
       
  1517                    is_const=True)
  1027     ## object-vector.h: uint32_t ns3::ObjectVectorValue::GetN() const [member function]
  1518     ## object-vector.h: uint32_t ns3::ObjectVectorValue::GetN() const [member function]
  1028     cls.add_method('GetN', 'uint32_t', [], is_const=True)
  1519     cls.add_method('GetN', 
       
  1520                    'uint32_t', 
       
  1521                    [], 
       
  1522                    is_const=True)
  1029     ## object-vector.h: ns3::Ptr<ns3::Object> ns3::ObjectVectorValue::Get(uint32_t i) const [member function]
  1523     ## object-vector.h: ns3::Ptr<ns3::Object> ns3::ObjectVectorValue::Get(uint32_t i) const [member function]
  1030     cls.add_method('Get', 'ns3::Ptr< ns3::Object >', [param('uint32_t', 'i')], is_const=True)
  1524     cls.add_method('Get', 
       
  1525                    'ns3::Ptr< ns3::Object >', 
       
  1526                    [param('uint32_t', 'i')], 
       
  1527                    is_const=True)
  1031     ## object-vector.h: ns3::Ptr<ns3::AttributeValue> ns3::ObjectVectorValue::Copy() const [member function]
  1528     ## object-vector.h: ns3::Ptr<ns3::AttributeValue> ns3::ObjectVectorValue::Copy() const [member function]
  1032     cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
  1529     cls.add_method('Copy', 
       
  1530                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1531                    [], 
       
  1532                    is_const=True, is_virtual=True)
  1033     ## object-vector.h: std::string ns3::ObjectVectorValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1533     ## object-vector.h: std::string ns3::ObjectVectorValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1034     cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True)
  1534     cls.add_method('SerializeToString', 
       
  1535                    'std::string', 
       
  1536                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1537                    is_const=True, is_virtual=True)
  1035     ## object-vector.h: bool ns3::ObjectVectorValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1538     ## object-vector.h: bool ns3::ObjectVectorValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1036     cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True)
  1539     cls.add_method('DeserializeFromString', 
       
  1540                    'bool', 
       
  1541                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1542                    is_virtual=True)
  1037     return
  1543     return
  1038 
  1544 
  1039 def register_Ns3BooleanChecker_methods(root_module, cls):
  1545 def register_Ns3BooleanChecker_methods(root_module, cls):
  1040     cls.add_constructor([])
  1546     cls.add_constructor([])
  1041     return
  1547     return
  1042 
  1548 
  1043 def register_Ns3UintegerValue_methods(root_module, cls):
  1549 def register_Ns3UintegerValue_methods(root_module, cls):
  1044     ## uinteger.h: ns3::UintegerValue::UintegerValue() [constructor]
  1550     ## uinteger.h: ns3::UintegerValue::UintegerValue() [constructor]
  1045     cls.add_constructor([], visibility='public')
  1551     cls.add_constructor([])
  1046     ## uinteger.h: ns3::UintegerValue::UintegerValue(uint64_t const & value) [constructor]
  1552     ## uinteger.h: ns3::UintegerValue::UintegerValue(uint64_t const & value) [constructor]
  1047     cls.add_constructor([param('uint64_t&', 'value', is_const=True)], visibility='public')
  1553     cls.add_constructor([param('uint64_t&', 'value', is_const=True)])
  1048     ## uinteger.h: void ns3::UintegerValue::Set(uint64_t const & value) [member function]
  1554     ## uinteger.h: void ns3::UintegerValue::Set(uint64_t const & value) [member function]
  1049     cls.add_method('Set', 'void', [param('uint64_t&', 'value', is_const=True)])
  1555     cls.add_method('Set', 
       
  1556                    'void', 
       
  1557                    [param('uint64_t&', 'value', is_const=True)])
  1050     ## uinteger.h: uint64_t ns3::UintegerValue::Get() const [member function]
  1558     ## uinteger.h: uint64_t ns3::UintegerValue::Get() const [member function]
  1051     cls.add_method('Get', 'uint64_t', [], is_const=True)
  1559     cls.add_method('Get', 
       
  1560                    'uint64_t', 
       
  1561                    [], 
       
  1562                    is_const=True)
  1052     ## uinteger.h: ns3::Ptr<ns3::AttributeValue> ns3::UintegerValue::Copy() const [member function]
  1563     ## uinteger.h: ns3::Ptr<ns3::AttributeValue> ns3::UintegerValue::Copy() const [member function]
  1053     cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
  1564     cls.add_method('Copy', 
       
  1565                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1566                    [], 
       
  1567                    is_const=True, is_virtual=True)
  1054     ## uinteger.h: std::string ns3::UintegerValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1568     ## uinteger.h: std::string ns3::UintegerValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1055     cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True)
  1569     cls.add_method('SerializeToString', 
       
  1570                    'std::string', 
       
  1571                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1572                    is_const=True, is_virtual=True)
  1056     ## uinteger.h: bool ns3::UintegerValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1573     ## uinteger.h: bool ns3::UintegerValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1057     cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True)
  1574     cls.add_method('DeserializeFromString', 
       
  1575                    'bool', 
       
  1576                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1577                    is_virtual=True)
  1058     return
  1578     return
  1059 
  1579 
  1060 def register_Ns3ObjectVectorAccessor_methods(root_module, cls):
  1580 def register_Ns3ObjectVectorAccessor_methods(root_module, cls):
  1061     ## object-vector.h: bool ns3::ObjectVectorAccessor::Set(ns3::ObjectBase * object, ns3::AttributeValue const & value) const [member function]
  1581     ## object-vector.h: bool ns3::ObjectVectorAccessor::Set(ns3::ObjectBase * object, ns3::AttributeValue const & value) const [member function]
  1062     cls.add_method('Set', 'bool', [param('ns3::ObjectBase *', 'object'), param('ns3::AttributeValue&', 'value', is_const=True)], is_const=True, is_virtual=True)
  1582     cls.add_method('Set', 
       
  1583                    'bool', 
       
  1584                    [param('ns3::ObjectBase *', 'object'), param('ns3::AttributeValue&', 'value', is_const=True)], 
       
  1585                    is_const=True, is_virtual=True)
  1063     ## object-vector.h: bool ns3::ObjectVectorAccessor::Get(ns3::ObjectBase const * object, ns3::AttributeValue & value) const [member function]
  1586     ## object-vector.h: bool ns3::ObjectVectorAccessor::Get(ns3::ObjectBase const * object, ns3::AttributeValue & value) const [member function]
  1064     cls.add_method('Get', 'bool', [param('ns3::ObjectBase *', 'object', transfer_ownership=False, is_const=True), param('ns3::AttributeValue&', 'value')], is_const=True, is_virtual=True)
  1587     cls.add_method('Get', 
       
  1588                    'bool', 
       
  1589                    [param('ns3::ObjectBase *', 'object', transfer_ownership=False, is_const=True), param('ns3::AttributeValue&', 'value')], 
       
  1590                    is_const=True, is_virtual=True)
  1065     ## object-vector.h: bool ns3::ObjectVectorAccessor::HasGetter() const [member function]
  1591     ## object-vector.h: bool ns3::ObjectVectorAccessor::HasGetter() const [member function]
  1066     cls.add_method('HasGetter', 'bool', [], is_const=True, is_virtual=True)
  1592     cls.add_method('HasGetter', 
       
  1593                    'bool', 
       
  1594                    [], 
       
  1595                    is_const=True, is_virtual=True)
  1067     ## object-vector.h: bool ns3::ObjectVectorAccessor::HasSetter() const [member function]
  1596     ## object-vector.h: bool ns3::ObjectVectorAccessor::HasSetter() const [member function]
  1068     cls.add_method('HasSetter', 'bool', [], is_const=True, is_virtual=True)
  1597     cls.add_method('HasSetter', 
       
  1598                    'bool', 
       
  1599                    [], 
       
  1600                    is_const=True, is_virtual=True)
  1069     ## object-vector.h: bool ns3::ObjectVectorAccessor::DoGetN(ns3::ObjectBase const * object, uint32_t * n) const [member function]
  1601     ## object-vector.h: bool ns3::ObjectVectorAccessor::DoGetN(ns3::ObjectBase const * object, uint32_t * n) const [member function]
  1070     cls.add_method('DoGetN', 'bool', [param('ns3::ObjectBase *', 'object', transfer_ownership=False, is_const=True), param('uint32_t *', 'n')], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1602     cls.add_method('DoGetN', 
       
  1603                    'bool', 
       
  1604                    [param('ns3::ObjectBase *', 'object', transfer_ownership=False, is_const=True), param('uint32_t *', 'n')], 
       
  1605                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1071     ## object-vector.h: ns3::Ptr<ns3::Object> ns3::ObjectVectorAccessor::DoGet(ns3::ObjectBase const * object, uint32_t i) const [member function]
  1606     ## object-vector.h: ns3::Ptr<ns3::Object> ns3::ObjectVectorAccessor::DoGet(ns3::ObjectBase const * object, uint32_t i) const [member function]
  1072     cls.add_method('DoGet', 'ns3::Ptr< ns3::Object >', [param('ns3::ObjectBase *', 'object', transfer_ownership=False, is_const=True), param('uint32_t', 'i')], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1607     cls.add_method('DoGet', 
       
  1608                    'ns3::Ptr< ns3::Object >', 
       
  1609                    [param('ns3::ObjectBase *', 'object', transfer_ownership=False, is_const=True), param('uint32_t', 'i')], 
       
  1610                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1073     cls.add_constructor([])
  1611     cls.add_constructor([])
  1074     return
  1612     return
  1075 
  1613 
  1076 def register_Ns3PointerValue_methods(root_module, cls):
  1614 def register_Ns3PointerValue_methods(root_module, cls):
  1077     ## pointer.h: ns3::PointerValue::PointerValue(ns3::PointerValue const & arg0) [copy constructor]
  1615     ## pointer.h: ns3::PointerValue::PointerValue(ns3::PointerValue const & arg0) [copy constructor]
  1078     cls.add_constructor([param('ns3::PointerValue&', 'arg0', is_const=True)], visibility='public')
  1616     cls.add_constructor([param('ns3::PointerValue&', 'arg0', is_const=True)])
  1079     ## pointer.h: ns3::PointerValue::PointerValue() [constructor]
  1617     ## pointer.h: ns3::PointerValue::PointerValue() [constructor]
  1080     cls.add_constructor([], visibility='public')
  1618     cls.add_constructor([])
  1081     ## pointer.h: ns3::PointerValue::PointerValue(ns3::Ptr<ns3::Object> object) [constructor]
  1619     ## pointer.h: ns3::PointerValue::PointerValue(ns3::Ptr<ns3::Object> object) [constructor]
  1082     cls.add_constructor([param('ns3::Ptr< ns3::Object >', 'object')], visibility='public')
  1620     cls.add_constructor([param('ns3::Ptr< ns3::Object >', 'object')])
  1083     ## pointer.h: void ns3::PointerValue::SetObject(ns3::Ptr<ns3::Object> object) [member function]
  1621     ## pointer.h: void ns3::PointerValue::SetObject(ns3::Ptr<ns3::Object> object) [member function]
  1084     cls.add_method('SetObject', 'void', [param('ns3::Ptr< ns3::Object >', 'object')])
  1622     cls.add_method('SetObject', 
       
  1623                    'void', 
       
  1624                    [param('ns3::Ptr< ns3::Object >', 'object')])
  1085     ## pointer.h: ns3::Ptr<ns3::Object> ns3::PointerValue::GetObject() const [member function]
  1625     ## pointer.h: ns3::Ptr<ns3::Object> ns3::PointerValue::GetObject() const [member function]
  1086     cls.add_method('GetObject', 'ns3::Ptr< ns3::Object >', [], is_const=True)
  1626     cls.add_method('GetObject', 
       
  1627                    'ns3::Ptr< ns3::Object >', 
       
  1628                    [], 
       
  1629                    is_const=True)
  1087     ## pointer.h: ns3::Ptr<ns3::AttributeValue> ns3::PointerValue::Copy() const [member function]
  1630     ## pointer.h: ns3::Ptr<ns3::AttributeValue> ns3::PointerValue::Copy() const [member function]
  1088     cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
  1631     cls.add_method('Copy', 
       
  1632                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1633                    [], 
       
  1634                    is_const=True, is_virtual=True)
  1089     ## pointer.h: std::string ns3::PointerValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1635     ## pointer.h: std::string ns3::PointerValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1090     cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True)
  1636     cls.add_method('SerializeToString', 
       
  1637                    'std::string', 
       
  1638                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1639                    is_const=True, is_virtual=True)
  1091     ## pointer.h: bool ns3::PointerValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1640     ## pointer.h: bool ns3::PointerValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1092     cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True)
  1641     cls.add_method('DeserializeFromString', 
       
  1642                    'bool', 
       
  1643                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1644                    is_virtual=True)
  1093     return
  1645     return
  1094 
  1646 
  1095 def register_Ns3ObjectFactoryChecker_methods(root_module, cls):
  1647 def register_Ns3ObjectFactoryChecker_methods(root_module, cls):
  1096     cls.add_constructor([])
  1648     cls.add_constructor([])
  1097     return
  1649     return
  1100     cls.add_constructor([])
  1652     cls.add_constructor([])
  1101     return
  1653     return
  1102 
  1654 
  1103 def register_Ns3DoubleValue_methods(root_module, cls):
  1655 def register_Ns3DoubleValue_methods(root_module, cls):
  1104     ## double.h: ns3::DoubleValue::DoubleValue() [constructor]
  1656     ## double.h: ns3::DoubleValue::DoubleValue() [constructor]
  1105     cls.add_constructor([], visibility='public')
  1657     cls.add_constructor([])
  1106     ## double.h: ns3::DoubleValue::DoubleValue(double const & value) [constructor]
  1658     ## double.h: ns3::DoubleValue::DoubleValue(double const & value) [constructor]
  1107     cls.add_constructor([param('double&', 'value', is_const=True)], visibility='public')
  1659     cls.add_constructor([param('double&', 'value', is_const=True)])
  1108     ## double.h: void ns3::DoubleValue::Set(double const & value) [member function]
  1660     ## double.h: void ns3::DoubleValue::Set(double const & value) [member function]
  1109     cls.add_method('Set', 'void', [param('double&', 'value', is_const=True)])
  1661     cls.add_method('Set', 
       
  1662                    'void', 
       
  1663                    [param('double&', 'value', is_const=True)])
  1110     ## double.h: double ns3::DoubleValue::Get() const [member function]
  1664     ## double.h: double ns3::DoubleValue::Get() const [member function]
  1111     cls.add_method('Get', 'double', [], is_const=True)
  1665     cls.add_method('Get', 
       
  1666                    'double', 
       
  1667                    [], 
       
  1668                    is_const=True)
  1112     ## double.h: ns3::Ptr<ns3::AttributeValue> ns3::DoubleValue::Copy() const [member function]
  1669     ## double.h: ns3::Ptr<ns3::AttributeValue> ns3::DoubleValue::Copy() const [member function]
  1113     cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
  1670     cls.add_method('Copy', 
       
  1671                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1672                    [], 
       
  1673                    is_const=True, is_virtual=True)
  1114     ## double.h: std::string ns3::DoubleValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1674     ## double.h: std::string ns3::DoubleValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1115     cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True)
  1675     cls.add_method('SerializeToString', 
       
  1676                    'std::string', 
       
  1677                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1678                    is_const=True, is_virtual=True)
  1116     ## double.h: bool ns3::DoubleValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1679     ## double.h: bool ns3::DoubleValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1117     cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True)
  1680     cls.add_method('DeserializeFromString', 
       
  1681                    'bool', 
       
  1682                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1683                    is_virtual=True)
  1118     return
  1684     return
  1119 
  1685 
  1120 def register_Ns3TypeIdValue_methods(root_module, cls):
  1686 def register_Ns3TypeIdValue_methods(root_module, cls):
  1121     ## type-id.h: ns3::TypeIdValue::TypeIdValue() [constructor]
  1687     ## type-id.h: ns3::TypeIdValue::TypeIdValue() [constructor]
  1122     cls.add_constructor([], visibility='public')
  1688     cls.add_constructor([])
  1123     ## type-id.h: ns3::TypeIdValue::TypeIdValue(ns3::TypeId const & value) [constructor]
  1689     ## type-id.h: ns3::TypeIdValue::TypeIdValue(ns3::TypeId const & value) [constructor]
  1124     cls.add_constructor([param('ns3::TypeId&', 'value', is_const=True)], visibility='public')
  1690     cls.add_constructor([param('ns3::TypeId&', 'value', is_const=True)])
  1125     ## type-id.h: void ns3::TypeIdValue::Set(ns3::TypeId const & value) [member function]
  1691     ## type-id.h: void ns3::TypeIdValue::Set(ns3::TypeId const & value) [member function]
  1126     cls.add_method('Set', 'void', [param('ns3::TypeId&', 'value', is_const=True)])
  1692     cls.add_method('Set', 
       
  1693                    'void', 
       
  1694                    [param('ns3::TypeId&', 'value', is_const=True)])
  1127     ## type-id.h: ns3::TypeId ns3::TypeIdValue::Get() const [member function]
  1695     ## type-id.h: ns3::TypeId ns3::TypeIdValue::Get() const [member function]
  1128     cls.add_method('Get', 'ns3::TypeId', [], is_const=True)
  1696     cls.add_method('Get', 
       
  1697                    'ns3::TypeId', 
       
  1698                    [], 
       
  1699                    is_const=True)
  1129     ## type-id.h: ns3::Ptr<ns3::AttributeValue> ns3::TypeIdValue::Copy() const [member function]
  1700     ## type-id.h: ns3::Ptr<ns3::AttributeValue> ns3::TypeIdValue::Copy() const [member function]
  1130     cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
  1701     cls.add_method('Copy', 
       
  1702                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1703                    [], 
       
  1704                    is_const=True, is_virtual=True)
  1131     ## type-id.h: std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1705     ## type-id.h: std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1132     cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True)
  1706     cls.add_method('SerializeToString', 
       
  1707                    'std::string', 
       
  1708                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1709                    is_const=True, is_virtual=True)
  1133     ## type-id.h: bool ns3::TypeIdValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1710     ## type-id.h: bool ns3::TypeIdValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1134     cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True)
  1711     cls.add_method('DeserializeFromString', 
       
  1712                    'bool', 
       
  1713                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1714                    is_virtual=True)
  1135     return
  1715     return
  1136 
  1716 
  1137 def register_Ns3EnumValue_methods(root_module, cls):
  1717 def register_Ns3EnumValue_methods(root_module, cls):
  1138     ## enum.h: ns3::EnumValue::EnumValue() [constructor]
  1718     ## enum.h: ns3::EnumValue::EnumValue() [constructor]
  1139     cls.add_constructor([], visibility='public')
  1719     cls.add_constructor([])
  1140     ## enum.h: ns3::EnumValue::EnumValue(int v) [constructor]
  1720     ## enum.h: ns3::EnumValue::EnumValue(int v) [constructor]
  1141     cls.add_constructor([param('int', 'v')], visibility='public')
  1721     cls.add_constructor([param('int', 'v')])
  1142     ## enum.h: void ns3::EnumValue::Set(int v) [member function]
  1722     ## enum.h: void ns3::EnumValue::Set(int v) [member function]
  1143     cls.add_method('Set', 'void', [param('int', 'v')])
  1723     cls.add_method('Set', 
       
  1724                    'void', 
       
  1725                    [param('int', 'v')])
  1144     ## enum.h: int ns3::EnumValue::Get() const [member function]
  1726     ## enum.h: int ns3::EnumValue::Get() const [member function]
  1145     cls.add_method('Get', 'int', [], is_const=True)
  1727     cls.add_method('Get', 
       
  1728                    'int', 
       
  1729                    [], 
       
  1730                    is_const=True)
  1146     ## enum.h: ns3::Ptr<ns3::AttributeValue> ns3::EnumValue::Copy() const [member function]
  1731     ## enum.h: ns3::Ptr<ns3::AttributeValue> ns3::EnumValue::Copy() const [member function]
  1147     cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
  1732     cls.add_method('Copy', 
       
  1733                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1734                    [], 
       
  1735                    is_const=True, is_virtual=True)
  1148     ## enum.h: std::string ns3::EnumValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1736     ## enum.h: std::string ns3::EnumValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1149     cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True)
  1737     cls.add_method('SerializeToString', 
       
  1738                    'std::string', 
       
  1739                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1740                    is_const=True, is_virtual=True)
  1150     ## enum.h: bool ns3::EnumValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1741     ## enum.h: bool ns3::EnumValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1151     cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True)
  1742     cls.add_method('DeserializeFromString', 
       
  1743                    'bool', 
       
  1744                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1745                    is_virtual=True)
  1152     return
  1746     return
  1153 
  1747 
  1154 def register_Ns3RandomVariableValue_methods(root_module, cls):
  1748 def register_Ns3RandomVariableValue_methods(root_module, cls):
  1155     ## random-variable.h: ns3::RandomVariableValue::RandomVariableValue() [constructor]
  1749     ## random-variable.h: ns3::RandomVariableValue::RandomVariableValue() [constructor]
  1156     cls.add_constructor([], visibility='public')
  1750     cls.add_constructor([])
  1157     ## random-variable.h: ns3::RandomVariableValue::RandomVariableValue(ns3::RandomVariable const & value) [constructor]
  1751     ## random-variable.h: ns3::RandomVariableValue::RandomVariableValue(ns3::RandomVariable const & value) [constructor]
  1158     cls.add_constructor([param('ns3::RandomVariable&', 'value', is_const=True)], visibility='public')
  1752     cls.add_constructor([param('ns3::RandomVariable&', 'value', is_const=True)])
  1159     ## random-variable.h: void ns3::RandomVariableValue::Set(ns3::RandomVariable const & value) [member function]
  1753     ## random-variable.h: void ns3::RandomVariableValue::Set(ns3::RandomVariable const & value) [member function]
  1160     cls.add_method('Set', 'void', [param('ns3::RandomVariable&', 'value', is_const=True)])
  1754     cls.add_method('Set', 
       
  1755                    'void', 
       
  1756                    [param('ns3::RandomVariable&', 'value', is_const=True)])
  1161     ## random-variable.h: ns3::RandomVariable ns3::RandomVariableValue::Get() const [member function]
  1757     ## random-variable.h: ns3::RandomVariable ns3::RandomVariableValue::Get() const [member function]
  1162     cls.add_method('Get', 'ns3::RandomVariable', [], is_const=True)
  1758     cls.add_method('Get', 
       
  1759                    'ns3::RandomVariable', 
       
  1760                    [], 
       
  1761                    is_const=True)
  1163     ## random-variable.h: ns3::Ptr<ns3::AttributeValue> ns3::RandomVariableValue::Copy() const [member function]
  1762     ## random-variable.h: ns3::Ptr<ns3::AttributeValue> ns3::RandomVariableValue::Copy() const [member function]
  1164     cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
  1763     cls.add_method('Copy', 
       
  1764                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1765                    [], 
       
  1766                    is_const=True, is_virtual=True)
  1165     ## random-variable.h: std::string ns3::RandomVariableValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1767     ## random-variable.h: std::string ns3::RandomVariableValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1166     cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True)
  1768     cls.add_method('SerializeToString', 
       
  1769                    'std::string', 
       
  1770                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1771                    is_const=True, is_virtual=True)
  1167     ## random-variable.h: bool ns3::RandomVariableValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1772     ## random-variable.h: bool ns3::RandomVariableValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1168     cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True)
  1773     cls.add_method('DeserializeFromString', 
       
  1774                    'bool', 
       
  1775                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1776                    is_virtual=True)
  1169     return
  1777     return
  1170 
  1778 
  1171 def register_Ns3ObjectFactoryValue_methods(root_module, cls):
  1779 def register_Ns3ObjectFactoryValue_methods(root_module, cls):
  1172     ## object-factory.h: ns3::ObjectFactoryValue::ObjectFactoryValue() [constructor]
  1780     ## object-factory.h: ns3::ObjectFactoryValue::ObjectFactoryValue() [constructor]
  1173     cls.add_constructor([], visibility='public')
  1781     cls.add_constructor([])
  1174     ## object-factory.h: ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactory const & value) [constructor]
  1782     ## object-factory.h: ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactory const & value) [constructor]
  1175     cls.add_constructor([param('ns3::ObjectFactory&', 'value', is_const=True)], visibility='public')
  1783     cls.add_constructor([param('ns3::ObjectFactory&', 'value', is_const=True)])
  1176     ## object-factory.h: void ns3::ObjectFactoryValue::Set(ns3::ObjectFactory const & value) [member function]
  1784     ## object-factory.h: void ns3::ObjectFactoryValue::Set(ns3::ObjectFactory const & value) [member function]
  1177     cls.add_method('Set', 'void', [param('ns3::ObjectFactory&', 'value', is_const=True)])
  1785     cls.add_method('Set', 
       
  1786                    'void', 
       
  1787                    [param('ns3::ObjectFactory&', 'value', is_const=True)])
  1178     ## object-factory.h: ns3::ObjectFactory ns3::ObjectFactoryValue::Get() const [member function]
  1788     ## object-factory.h: ns3::ObjectFactory ns3::ObjectFactoryValue::Get() const [member function]
  1179     cls.add_method('Get', 'ns3::ObjectFactory', [], is_const=True)
  1789     cls.add_method('Get', 
       
  1790                    'ns3::ObjectFactory', 
       
  1791                    [], 
       
  1792                    is_const=True)
  1180     ## object-factory.h: ns3::Ptr<ns3::AttributeValue> ns3::ObjectFactoryValue::Copy() const [member function]
  1793     ## object-factory.h: ns3::Ptr<ns3::AttributeValue> ns3::ObjectFactoryValue::Copy() const [member function]
  1181     cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
  1794     cls.add_method('Copy', 
       
  1795                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1796                    [], 
       
  1797                    is_const=True, is_virtual=True)
  1182     ## object-factory.h: std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1798     ## object-factory.h: std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1183     cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True)
  1799     cls.add_method('SerializeToString', 
       
  1800                    'std::string', 
       
  1801                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1802                    is_const=True, is_virtual=True)
  1184     ## object-factory.h: bool ns3::ObjectFactoryValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1803     ## object-factory.h: bool ns3::ObjectFactoryValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1185     cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True)
  1804     cls.add_method('DeserializeFromString', 
       
  1805                    'bool', 
       
  1806                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1807                    is_virtual=True)
  1186     return
  1808     return
  1187 
  1809 
  1188 def register_Ns3IntegerValue_methods(root_module, cls):
  1810 def register_Ns3IntegerValue_methods(root_module, cls):
  1189     ## integer.h: ns3::IntegerValue::IntegerValue() [constructor]
  1811     ## integer.h: ns3::IntegerValue::IntegerValue() [constructor]
  1190     cls.add_constructor([], visibility='public')
  1812     cls.add_constructor([])
  1191     ## integer.h: ns3::IntegerValue::IntegerValue(int64_t const & value) [constructor]
  1813     ## integer.h: ns3::IntegerValue::IntegerValue(int64_t const & value) [constructor]
  1192     cls.add_constructor([param('int64_t&', 'value', is_const=True)], visibility='public')
  1814     cls.add_constructor([param('int64_t&', 'value', is_const=True)])
  1193     ## integer.h: void ns3::IntegerValue::Set(int64_t const & value) [member function]
  1815     ## integer.h: void ns3::IntegerValue::Set(int64_t const & value) [member function]
  1194     cls.add_method('Set', 'void', [param('int64_t&', 'value', is_const=True)])
  1816     cls.add_method('Set', 
       
  1817                    'void', 
       
  1818                    [param('int64_t&', 'value', is_const=True)])
  1195     ## integer.h: int64_t ns3::IntegerValue::Get() const [member function]
  1819     ## integer.h: int64_t ns3::IntegerValue::Get() const [member function]
  1196     cls.add_method('Get', 'int64_t', [], is_const=True)
  1820     cls.add_method('Get', 
       
  1821                    'int64_t', 
       
  1822                    [], 
       
  1823                    is_const=True)
  1197     ## integer.h: ns3::Ptr<ns3::AttributeValue> ns3::IntegerValue::Copy() const [member function]
  1824     ## integer.h: ns3::Ptr<ns3::AttributeValue> ns3::IntegerValue::Copy() const [member function]
  1198     cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
  1825     cls.add_method('Copy', 
       
  1826                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1827                    [], 
       
  1828                    is_const=True, is_virtual=True)
  1199     ## integer.h: std::string ns3::IntegerValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1829     ## integer.h: std::string ns3::IntegerValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1200     cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True)
  1830     cls.add_method('SerializeToString', 
       
  1831                    'std::string', 
       
  1832                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1833                    is_const=True, is_virtual=True)
  1201     ## integer.h: bool ns3::IntegerValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1834     ## integer.h: bool ns3::IntegerValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1202     cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True)
  1835     cls.add_method('DeserializeFromString', 
       
  1836                    'bool', 
       
  1837                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1838                    is_virtual=True)
  1203     return
  1839     return
  1204 
  1840 
  1205 def register_Ns3BooleanValue_methods(root_module, cls):
  1841 def register_Ns3BooleanValue_methods(root_module, cls):
  1206     ## boolean.h: ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [copy constructor]
  1842     ## boolean.h: ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [copy constructor]
  1207     cls.add_constructor([param('ns3::BooleanValue&', 'arg0', is_const=True)], visibility='public')
  1843     cls.add_constructor([param('ns3::BooleanValue&', 'arg0', is_const=True)])
  1208     ## boolean.h: ns3::BooleanValue::BooleanValue() [constructor]
  1844     ## boolean.h: ns3::BooleanValue::BooleanValue() [constructor]
  1209     cls.add_constructor([], visibility='public')
  1845     cls.add_constructor([])
  1210     ## boolean.h: ns3::BooleanValue::BooleanValue(bool value) [constructor]
  1846     ## boolean.h: ns3::BooleanValue::BooleanValue(bool value) [constructor]
  1211     cls.add_constructor([param('bool', 'value')], visibility='public')
  1847     cls.add_constructor([param('bool', 'value')])
  1212     ## boolean.h: ns3::Ptr<ns3::AttributeValue> ns3::BooleanValue::Copy() const [member function]
  1848     ## boolean.h: ns3::Ptr<ns3::AttributeValue> ns3::BooleanValue::Copy() const [member function]
  1213     cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
  1849     cls.add_method('Copy', 
       
  1850                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1851                    [], 
       
  1852                    is_const=True, is_virtual=True)
  1214     ## boolean.h: bool ns3::BooleanValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1853     ## boolean.h: bool ns3::BooleanValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1215     cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True)
  1854     cls.add_method('DeserializeFromString', 
       
  1855                    'bool', 
       
  1856                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1857                    is_virtual=True)
  1216     ## boolean.h: bool ns3::BooleanValue::Get() const [member function]
  1858     ## boolean.h: bool ns3::BooleanValue::Get() const [member function]
  1217     cls.add_method('Get', 'bool', [], is_const=True)
  1859     cls.add_method('Get', 
       
  1860                    'bool', 
       
  1861                    [], 
       
  1862                    is_const=True)
  1218     ## boolean.h: std::string ns3::BooleanValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1863     ## boolean.h: std::string ns3::BooleanValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1219     cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True)
  1864     cls.add_method('SerializeToString', 
       
  1865                    'std::string', 
       
  1866                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1867                    is_const=True, is_virtual=True)
  1220     ## boolean.h: void ns3::BooleanValue::Set(bool value) [member function]
  1868     ## boolean.h: void ns3::BooleanValue::Set(bool value) [member function]
  1221     cls.add_method('Set', 'void', [param('bool', 'value')])
  1869     cls.add_method('Set', 
       
  1870                    'void', 
       
  1871                    [param('bool', 'value')])
  1222     cls.add_output_stream_operator()
  1872     cls.add_output_stream_operator()
  1223     return
  1873     return
  1224 
  1874 
  1225 def register_Ns3StringValue_methods(root_module, cls):
  1875 def register_Ns3StringValue_methods(root_module, cls):
  1226     ## string.h: ns3::StringValue::StringValue() [constructor]
  1876     ## string.h: ns3::StringValue::StringValue() [constructor]
  1227     cls.add_constructor([], visibility='public')
  1877     cls.add_constructor([])
  1228     ## string.h: ns3::StringValue::StringValue(std::string const & value) [constructor]
  1878     ## string.h: ns3::StringValue::StringValue(std::string const & value) [constructor]
  1229     cls.add_constructor([param('std::string&', 'value', is_const=True)], visibility='public')
  1879     cls.add_constructor([param('std::string&', 'value', is_const=True)])
  1230     ## string.h: void ns3::StringValue::Set(std::string const & value) [member function]
  1880     ## string.h: void ns3::StringValue::Set(std::string const & value) [member function]
  1231     cls.add_method('Set', 'void', [param('std::string&', 'value', is_const=True)])
  1881     cls.add_method('Set', 
       
  1882                    'void', 
       
  1883                    [param('std::string&', 'value', is_const=True)])
  1232     ## string.h: std::string ns3::StringValue::Get() const [member function]
  1884     ## string.h: std::string ns3::StringValue::Get() const [member function]
  1233     cls.add_method('Get', 'std::string', [], is_const=True)
  1885     cls.add_method('Get', 
       
  1886                    'std::string', 
       
  1887                    [], 
       
  1888                    is_const=True)
  1234     ## string.h: ns3::Ptr<ns3::AttributeValue> ns3::StringValue::Copy() const [member function]
  1889     ## string.h: ns3::Ptr<ns3::AttributeValue> ns3::StringValue::Copy() const [member function]
  1235     cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)
  1890     cls.add_method('Copy', 
       
  1891                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1892                    [], 
       
  1893                    is_const=True, is_virtual=True)
  1236     ## string.h: std::string ns3::StringValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1894     ## string.h: std::string ns3::StringValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1237     cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True)
  1895     cls.add_method('SerializeToString', 
       
  1896                    'std::string', 
       
  1897                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1898                    is_const=True, is_virtual=True)
  1238     ## string.h: bool ns3::StringValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1899     ## string.h: bool ns3::StringValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1239     cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True)
  1900     cls.add_method('DeserializeFromString', 
       
  1901                    'bool', 
       
  1902                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1903                    is_virtual=True)
  1240     return
  1904     return
  1241 
  1905 
  1242 def register_Ns3EmptyAttributeValue_methods(root_module, cls):
  1906 def register_Ns3EmptyAttributeValue_methods(root_module, cls):
  1243     ## attribute.h: ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [copy constructor]
  1907     ## attribute.h: ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [copy constructor]
  1244     cls.add_constructor([param('ns3::EmptyAttributeValue&', 'arg0', is_const=True)], visibility='public')
  1908     cls.add_constructor([param('ns3::EmptyAttributeValue&', 'arg0', is_const=True)])
  1245     ## attribute.h: ns3::EmptyAttributeValue::EmptyAttributeValue() [constructor]
  1909     ## attribute.h: ns3::EmptyAttributeValue::EmptyAttributeValue() [constructor]
  1246     cls.add_constructor([], visibility='public')
  1910     cls.add_constructor([])
  1247     ## attribute.h: ns3::Ptr<ns3::AttributeValue> ns3::EmptyAttributeValue::Copy() const [member function]
  1911     ## attribute.h: ns3::Ptr<ns3::AttributeValue> ns3::EmptyAttributeValue::Copy() const [member function]
  1248     cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, visibility='private', is_virtual=True)
  1912     cls.add_method('Copy', 
       
  1913                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1914                    [], 
       
  1915                    is_const=True, visibility='private', is_virtual=True)
  1249     ## attribute.h: std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1916     ## attribute.h: std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1250     cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, visibility='private', is_virtual=True)
  1917     cls.add_method('SerializeToString', 
       
  1918                    'std::string', 
       
  1919                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1920                    is_const=True, visibility='private', is_virtual=True)
  1251     ## attribute.h: bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1921     ## attribute.h: bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1252     cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], visibility='private', is_virtual=True)
  1922     cls.add_method('DeserializeFromString', 
       
  1923                    'bool', 
       
  1924                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1925                    visibility='private', is_virtual=True)
  1253     return
  1926     return
  1254 
  1927 
  1255 def register_Ns3TracedValue__Unsigned_int_methods(root_module, cls):
  1928 def register_Ns3TracedValue__Unsigned_int_methods(root_module, cls):
  1256     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue() [constructor]
  1929     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue() [constructor]
  1257     cls.add_constructor([], visibility='public')
  1930     cls.add_constructor([])
  1258     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::TracedValue<unsigned int> const & o) [copy constructor]
  1931     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::TracedValue<unsigned int> const & o) [copy constructor]
  1259     cls.add_constructor([param('ns3::TracedValue< unsigned int >&', 'o', is_const=True)], visibility='public')
  1932     cls.add_constructor([param('ns3::TracedValue< unsigned int >&', 'o', is_const=True)])
  1260     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(unsigned int const & v) [constructor]
  1933     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(unsigned int const & v) [constructor]
  1261     cls.add_constructor([param('unsigned int&', 'v', is_const=True)], visibility='public')
  1934     cls.add_constructor([param('unsigned int&', 'v', is_const=True)])
  1262     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::IntegerValue const & value) [constructor]
  1935     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::IntegerValue const & value) [constructor]
  1263     cls.add_constructor([param('ns3::IntegerValue&', 'value', is_const=True)], visibility='public')
  1936     cls.add_constructor([param('ns3::IntegerValue&', 'value', is_const=True)])
  1264     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::UintegerValue const & value) [constructor]
  1937     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::UintegerValue const & value) [constructor]
  1265     cls.add_constructor([param('ns3::UintegerValue&', 'value', is_const=True)], visibility='public')
  1938     cls.add_constructor([param('ns3::UintegerValue&', 'value', is_const=True)])
  1266     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::BooleanValue const & value) [constructor]
  1939     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::BooleanValue const & value) [constructor]
  1267     cls.add_constructor([param('ns3::BooleanValue&', 'value', is_const=True)], visibility='public')
  1940     cls.add_constructor([param('ns3::BooleanValue&', 'value', is_const=True)])
  1268     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::EnumValue const & value) [constructor]
  1941     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::EnumValue const & value) [constructor]
  1269     cls.add_constructor([param('ns3::EnumValue&', 'value', is_const=True)], visibility='public')
  1942     cls.add_constructor([param('ns3::EnumValue&', 'value', is_const=True)])
  1270     ## traced-value.h: void ns3::TracedValue<unsigned int>::ConnectWithoutContext(ns3::CallbackBase const & cb) [member function]
  1943     ## traced-value.h: void ns3::TracedValue<unsigned int>::ConnectWithoutContext(ns3::CallbackBase const & cb) [member function]
  1271     cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'cb', is_const=True)])
  1944     cls.add_method('ConnectWithoutContext', 
       
  1945                    'void', 
       
  1946                    [param('ns3::CallbackBase&', 'cb', is_const=True)])
  1272     ## traced-value.h: void ns3::TracedValue<unsigned int>::Connect(ns3::CallbackBase const & cb, std::string path) [member function]
  1947     ## traced-value.h: void ns3::TracedValue<unsigned int>::Connect(ns3::CallbackBase const & cb, std::string path) [member function]
  1273     cls.add_method('Connect', 'void', [param('ns3::CallbackBase&', 'cb', is_const=True), param('std::string', 'path')])
  1948     cls.add_method('Connect', 
       
  1949                    'void', 
       
  1950                    [param('ns3::CallbackBase&', 'cb', is_const=True), param('std::string', 'path')])
  1274     ## traced-value.h: void ns3::TracedValue<unsigned int>::DisconnectWithoutContext(ns3::CallbackBase const & cb) [member function]
  1951     ## traced-value.h: void ns3::TracedValue<unsigned int>::DisconnectWithoutContext(ns3::CallbackBase const & cb) [member function]
  1275     cls.add_method('DisconnectWithoutContext', 'void', [param('ns3::CallbackBase&', 'cb', is_const=True)])
  1952     cls.add_method('DisconnectWithoutContext', 
       
  1953                    'void', 
       
  1954                    [param('ns3::CallbackBase&', 'cb', is_const=True)])
  1276     ## traced-value.h: void ns3::TracedValue<unsigned int>::Disconnect(ns3::CallbackBase const & cb, std::string path) [member function]
  1955     ## traced-value.h: void ns3::TracedValue<unsigned int>::Disconnect(ns3::CallbackBase const & cb, std::string path) [member function]
  1277     cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase&', 'cb', is_const=True), param('std::string', 'path')])
  1956     cls.add_method('Disconnect', 
       
  1957                    'void', 
       
  1958                    [param('ns3::CallbackBase&', 'cb', is_const=True), param('std::string', 'path')])
  1278     ## traced-value.h: void ns3::TracedValue<unsigned int>::Set(unsigned int const & v) [member function]
  1959     ## traced-value.h: void ns3::TracedValue<unsigned int>::Set(unsigned int const & v) [member function]
  1279     cls.add_method('Set', 'void', [param('unsigned int&', 'v', is_const=True)])
  1960     cls.add_method('Set', 
       
  1961                    'void', 
       
  1962                    [param('unsigned int&', 'v', is_const=True)])
  1280     ## traced-value.h: unsigned int ns3::TracedValue<unsigned int>::Get() const [member function]
  1963     ## traced-value.h: unsigned int ns3::TracedValue<unsigned int>::Get() const [member function]
  1281     cls.add_method('Get', 'unsigned int', [], is_const=True)
  1964     cls.add_method('Get', 
       
  1965                    'unsigned int', 
       
  1966                    [], 
       
  1967                    is_const=True)
  1282     return
  1968     return
  1283 
  1969 
  1284 def register_functions(root_module):
  1970 def register_functions(root_module):
  1285     module = root_module
  1971     module = root_module
  1286     ## boolean.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeBooleanChecker() [free function]
  1972     ## boolean.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeBooleanChecker() [free function]
  1287     module.add_function('MakeBooleanChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [])
  1973     module.add_function('MakeBooleanChecker', 
       
  1974                         'ns3::Ptr< ns3::AttributeChecker const >', 
       
  1975                         [])
  1288     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  1976     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  1289     module.add_function('TypeNameGet', 'std::string', [], template_parameters=['double'])
  1977     module.add_function('TypeNameGet', 
       
  1978                         'std::string', 
       
  1979                         [], 
       
  1980                         template_parameters=['double'])
  1290     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  1981     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  1291     module.add_function('TypeNameGet', 'std::string', [], template_parameters=['float'])
  1982     module.add_function('TypeNameGet', 
       
  1983                         'std::string', 
       
  1984                         [], 
       
  1985                         template_parameters=['float'])
  1292     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  1986     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  1293     module.add_function('TypeNameGet', 'std::string', [], template_parameters=['long'])
  1987     module.add_function('TypeNameGet', 
       
  1988                         'std::string', 
       
  1989                         [], 
       
  1990                         template_parameters=['long'])
  1294     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  1991     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  1295     module.add_function('TypeNameGet', 'std::string', [], template_parameters=['int'])
  1992     module.add_function('TypeNameGet', 
       
  1993                         'std::string', 
       
  1994                         [], 
       
  1995                         template_parameters=['int'])
  1296     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  1996     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  1297     module.add_function('TypeNameGet', 'std::string', [], template_parameters=['short'])
  1997     module.add_function('TypeNameGet', 
       
  1998                         'std::string', 
       
  1999                         [], 
       
  2000                         template_parameters=['short'])
  1298     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  2001     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  1299     module.add_function('TypeNameGet', 'std::string', [], template_parameters=['signed char'])
  2002     module.add_function('TypeNameGet', 
       
  2003                         'std::string', 
       
  2004                         [], 
       
  2005                         template_parameters=['signed char'])
  1300     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  2006     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  1301     module.add_function('TypeNameGet', 'std::string', [], template_parameters=['unsigned long'])
  2007     module.add_function('TypeNameGet', 
       
  2008                         'std::string', 
       
  2009                         [], 
       
  2010                         template_parameters=['unsigned long'])
  1302     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  2011     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  1303     module.add_function('TypeNameGet', 'std::string', [], template_parameters=['unsigned int'])
  2012     module.add_function('TypeNameGet', 
       
  2013                         'std::string', 
       
  2014                         [], 
       
  2015                         template_parameters=['unsigned int'])
  1304     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  2016     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  1305     module.add_function('TypeNameGet', 'std::string', [], template_parameters=['unsigned short'])
  2017     module.add_function('TypeNameGet', 
       
  2018                         'std::string', 
       
  2019                         [], 
       
  2020                         template_parameters=['unsigned short'])
  1306     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  2021     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  1307     module.add_function('TypeNameGet', 'std::string', [], template_parameters=['unsigned char'])
  2022     module.add_function('TypeNameGet', 
       
  2023                         'std::string', 
       
  2024                         [], 
       
  2025                         template_parameters=['unsigned char'])
  1308     ## string.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeStringChecker() [free function]
  2026     ## string.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeStringChecker() [free function]
  1309     module.add_function('MakeStringChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [])
  2027     module.add_function('MakeStringChecker', 
       
  2028                         'ns3::Ptr< ns3::AttributeChecker const >', 
       
  2029                         [])
  1310     ## enum.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeEnumChecker(int v1, std::string n1, int v2=0, std::string n2="", int v3=0, std::string n3="", int v4=0, std::string n4="", int v5=0, std::string n5="", int v6=0, std::string n6="", int v7=0, std::string n7="", int v8=0, std::string n8="", int v9=0, std::string n9="", int v10=0, std::string n10="", int v11=0, std::string n11="", int v12=0, std::string n12="") [free function]
  2030     ## enum.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeEnumChecker(int v1, std::string n1, int v2=0, std::string n2="", int v3=0, std::string n3="", int v4=0, std::string n4="", int v5=0, std::string n5="", int v6=0, std::string n6="", int v7=0, std::string n7="", int v8=0, std::string n8="", int v9=0, std::string n9="", int v10=0, std::string n10="", int v11=0, std::string n11="", int v12=0, std::string n12="") [free function]
  1311     module.add_function('MakeEnumChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [param('int', 'v1'), param('std::string', 'n1'), param('int', 'v2', default_value='0'), param('std::string', 'n2', default_value='""'), param('int', 'v3', default_value='0'), param('std::string', 'n3', default_value='""'), param('int', 'v4', default_value='0'), param('std::string', 'n4', default_value='""'), param('int', 'v5', default_value='0'), param('std::string', 'n5', default_value='""'), param('int', 'v6', default_value='0'), param('std::string', 'n6', default_value='""'), param('int', 'v7', default_value='0'), param('std::string', 'n7', default_value='""'), param('int', 'v8', default_value='0'), param('std::string', 'n8', default_value='""'), param('int', 'v9', default_value='0'), param('std::string', 'n9', default_value='""'), param('int', 'v10', default_value='0'), param('std::string', 'n10', default_value='""'), param('int', 'v11', default_value='0'), param('std::string', 'n11', default_value='""'), param('int', 'v12', default_value='0'), param('std::string', 'n12', default_value='""')])
  2031     module.add_function('MakeEnumChecker', 
       
  2032                         'ns3::Ptr< ns3::AttributeChecker const >', 
       
  2033                         [param('int', 'v1'), param('std::string', 'n1'), param('int', 'v2', default_value='0'), param('std::string', 'n2', default_value='""'), param('int', 'v3', default_value='0'), param('std::string', 'n3', default_value='""'), param('int', 'v4', default_value='0'), param('std::string', 'n4', default_value='""'), param('int', 'v5', default_value='0'), param('std::string', 'n5', default_value='""'), param('int', 'v6', default_value='0'), param('std::string', 'n6', default_value='""'), param('int', 'v7', default_value='0'), param('std::string', 'n7', default_value='""'), param('int', 'v8', default_value='0'), param('std::string', 'n8', default_value='""'), param('int', 'v9', default_value='0'), param('std::string', 'n9', default_value='""'), param('int', 'v10', default_value='0'), param('std::string', 'n10', default_value='""'), param('int', 'v11', default_value='0'), param('std::string', 'n11', default_value='""'), param('int', 'v12', default_value='0'), param('std::string', 'n12', default_value='""')])
  1312     ## type-id.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeTypeIdChecker() [free function]
  2034     ## type-id.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeTypeIdChecker() [free function]
  1313     module.add_function('MakeTypeIdChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [])
  2035     module.add_function('MakeTypeIdChecker', 
       
  2036                         'ns3::Ptr< ns3::AttributeChecker const >', 
       
  2037                         [])
  1314     ## ptr.h: extern ns3::Ptr<ns3::PointerValue> ns3::Create() [free function]
  2038     ## ptr.h: extern ns3::Ptr<ns3::PointerValue> ns3::Create() [free function]
  1315     module.add_function('Create', 'ns3::Ptr< ns3::PointerValue >', [], template_parameters=['ns3::PointerValue'])
  2039     module.add_function('Create', 
       
  2040                         'ns3::Ptr< ns3::PointerValue >', 
       
  2041                         [], 
       
  2042                         template_parameters=['ns3::PointerValue'])
  1316     ## ptr.h: extern ns3::Ptr<ns3::ObjectVectorValue> ns3::Create() [free function]
  2043     ## ptr.h: extern ns3::Ptr<ns3::ObjectVectorValue> ns3::Create() [free function]
  1317     module.add_function('Create', 'ns3::Ptr< ns3::ObjectVectorValue >', [], template_parameters=['ns3::ObjectVectorValue'])
  2044     module.add_function('Create', 
       
  2045                         'ns3::Ptr< ns3::ObjectVectorValue >', 
       
  2046                         [], 
       
  2047                         template_parameters=['ns3::ObjectVectorValue'])
  1318     ## object-factory.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeObjectFactoryChecker() [free function]
  2048     ## object-factory.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeObjectFactoryChecker() [free function]
  1319     module.add_function('MakeObjectFactoryChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [])
  2049     module.add_function('MakeObjectFactoryChecker', 
       
  2050                         'ns3::Ptr< ns3::AttributeChecker const >', 
       
  2051                         [])
  1320     ## breakpoint.h: extern void ns3::BreakpointFallback() [free function]
  2052     ## breakpoint.h: extern void ns3::BreakpointFallback() [free function]
  1321     module.add_function('BreakpointFallback', 'void', [])
  2053     module.add_function('BreakpointFallback', 
       
  2054                         'void', 
       
  2055                         [])
  1322     ## random-variable.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeRandomVariableChecker() [free function]
  2056     ## random-variable.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeRandomVariableChecker() [free function]
  1323     module.add_function('MakeRandomVariableChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [])
  2057     module.add_function('MakeRandomVariableChecker', 
       
  2058                         'ns3::Ptr< ns3::AttributeChecker const >', 
       
  2059                         [])
  1324     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
  2060     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
  1325     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
  2061     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
  1326     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
  2062     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
  1327     register_functions_ns3_olsr(module.get_submodule('olsr'), root_module)
  2063     register_functions_ns3_olsr(module.get_submodule('olsr'), root_module)
  1328     return
  2064     return
  1329 
  2065 
  1330 def register_functions_ns3_internal(module, root_module):
  2066 def register_functions_ns3_internal(module, root_module):
  1331     ## uinteger.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::internal::MakeUintegerChecker(uint64_t min, uint64_t max, std::string name) [free function]
  2067     ## uinteger.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::internal::MakeUintegerChecker(uint64_t min, uint64_t max, std::string name) [free function]
  1332     module.add_function('MakeUintegerChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [param('uint64_t', 'min'), param('uint64_t', 'max'), param('std::string', 'name')])
  2068     module.add_function('MakeUintegerChecker', 
       
  2069                         'ns3::Ptr< ns3::AttributeChecker const >', 
       
  2070                         [param('uint64_t', 'min'), param('uint64_t', 'max'), param('std::string', 'name')])
  1333     ## integer.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::internal::MakeIntegerChecker(int64_t min, int64_t max, std::string name) [free function]
  2071     ## integer.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::internal::MakeIntegerChecker(int64_t min, int64_t max, std::string name) [free function]
  1334     module.add_function('MakeIntegerChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [param('int64_t', 'min'), param('int64_t', 'max'), param('std::string', 'name')])
  2072     module.add_function('MakeIntegerChecker', 
       
  2073                         'ns3::Ptr< ns3::AttributeChecker const >', 
       
  2074                         [param('int64_t', 'min'), param('int64_t', 'max'), param('std::string', 'name')])
  1335     ## double.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::internal::MakeDoubleChecker(double min, double max, std::string name) [free function]
  2075     ## double.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::internal::MakeDoubleChecker(double min, double max, std::string name) [free function]
  1336     module.add_function('MakeDoubleChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [param('double', 'min'), param('double', 'max'), param('std::string', 'name')])
  2076     module.add_function('MakeDoubleChecker', 
       
  2077                         'ns3::Ptr< ns3::AttributeChecker const >', 
       
  2078                         [param('double', 'min'), param('double', 'max'), param('std::string', 'name')])
  1337     return
  2079     return
  1338 
  2080 
  1339 def register_functions_ns3_TimeStepPrecision(module, root_module):
  2081 def register_functions_ns3_TimeStepPrecision(module, root_module):
  1340     return
  2082     return
  1341 
  2083 
  1342 def register_functions_ns3_Config(module, root_module):
  2084 def register_functions_ns3_Config(module, root_module):
  1343     ## config.h: extern bool ns3::Config::SetDefaultFailSafe(std::string name, ns3::AttributeValue const & value) [free function]
  2085     ## config.h: extern bool ns3::Config::SetDefaultFailSafe(std::string name, ns3::AttributeValue const & value) [free function]
  1344     module.add_function('SetDefaultFailSafe', 'bool', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
  2086     module.add_function('SetDefaultFailSafe', 
       
  2087                         'bool', 
       
  2088                         [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
  1345     ## config.h: extern void ns3::Config::DisconnectWithoutContext(std::string path, ns3::CallbackBase const & cb) [free function]
  2089     ## config.h: extern void ns3::Config::DisconnectWithoutContext(std::string path, ns3::CallbackBase const & cb) [free function]
  1346     module.add_function('DisconnectWithoutContext', 'void', [param('std::string', 'path'), param('ns3::CallbackBase&', 'cb', is_const=True)])
  2090     module.add_function('DisconnectWithoutContext', 
       
  2091                         'void', 
       
  2092                         [param('std::string', 'path'), param('ns3::CallbackBase&', 'cb', is_const=True)])
  1347     ## config.h: extern void ns3::Config::SetDefault(std::string name, ns3::AttributeValue const & value) [free function]
  2093     ## config.h: extern void ns3::Config::SetDefault(std::string name, ns3::AttributeValue const & value) [free function]
  1348     module.add_function('SetDefault', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
  2094     module.add_function('SetDefault', 
       
  2095                         'void', 
       
  2096                         [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
  1349     ## config.h: extern void ns3::Config::Connect(std::string path, ns3::CallbackBase const & cb) [free function]
  2097     ## config.h: extern void ns3::Config::Connect(std::string path, ns3::CallbackBase const & cb) [free function]
  1350     module.add_function('Connect', 'void', [param('std::string', 'path'), param('ns3::CallbackBase&', 'cb', is_const=True)])
  2098     module.add_function('Connect', 
       
  2099                         'void', 
       
  2100                         [param('std::string', 'path'), param('ns3::CallbackBase&', 'cb', is_const=True)])
  1351     ## config.h: extern ns3::Ptr<ns3::Object> ns3::Config::GetRootNamespaceObject(uint32_t i) [free function]
  2101     ## config.h: extern ns3::Ptr<ns3::Object> ns3::Config::GetRootNamespaceObject(uint32_t i) [free function]
  1352     module.add_function('GetRootNamespaceObject', 'ns3::Ptr< ns3::Object >', [param('uint32_t', 'i')])
  2102     module.add_function('GetRootNamespaceObject', 
       
  2103                         'ns3::Ptr< ns3::Object >', 
       
  2104                         [param('uint32_t', 'i')])
  1353     ## config.h: extern void ns3::Config::ConnectWithoutContext(std::string path, ns3::CallbackBase const & cb) [free function]
  2105     ## config.h: extern void ns3::Config::ConnectWithoutContext(std::string path, ns3::CallbackBase const & cb) [free function]
  1354     module.add_function('ConnectWithoutContext', 'void', [param('std::string', 'path'), param('ns3::CallbackBase&', 'cb', is_const=True)])
  2106     module.add_function('ConnectWithoutContext', 
       
  2107                         'void', 
       
  2108                         [param('std::string', 'path'), param('ns3::CallbackBase&', 'cb', is_const=True)])
  1355     ## config.h: extern void ns3::Config::UnregisterRootNamespaceObject(ns3::Ptr<ns3::Object> obj) [free function]
  2109     ## config.h: extern void ns3::Config::UnregisterRootNamespaceObject(ns3::Ptr<ns3::Object> obj) [free function]
  1356     module.add_function('UnregisterRootNamespaceObject', 'void', [param('ns3::Ptr< ns3::Object >', 'obj')])
  2110     module.add_function('UnregisterRootNamespaceObject', 
       
  2111                         'void', 
       
  2112                         [param('ns3::Ptr< ns3::Object >', 'obj')])
  1357     ## config.h: extern bool ns3::Config::SetGlobalFailSafe(std::string name, ns3::AttributeValue const & value) [free function]
  2113     ## config.h: extern bool ns3::Config::SetGlobalFailSafe(std::string name, ns3::AttributeValue const & value) [free function]
  1358     module.add_function('SetGlobalFailSafe', 'bool', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
  2114     module.add_function('SetGlobalFailSafe', 
       
  2115                         'bool', 
       
  2116                         [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
  1359     ## config.h: extern uint32_t ns3::Config::GetRootNamespaceObjectN() [free function]
  2117     ## config.h: extern uint32_t ns3::Config::GetRootNamespaceObjectN() [free function]
  1360     module.add_function('GetRootNamespaceObjectN', 'uint32_t', [])
  2118     module.add_function('GetRootNamespaceObjectN', 
       
  2119                         'uint32_t', 
       
  2120                         [])
  1361     ## config.h: extern void ns3::Config::Set(std::string path, ns3::AttributeValue const & value) [free function]
  2121     ## config.h: extern void ns3::Config::Set(std::string path, ns3::AttributeValue const & value) [free function]
  1362     module.add_function('Set', 'void', [param('std::string', 'path'), param('ns3::AttributeValue&', 'value', is_const=True)])
  2122     module.add_function('Set', 
       
  2123                         'void', 
       
  2124                         [param('std::string', 'path'), param('ns3::AttributeValue&', 'value', is_const=True)])
  1363     ## config.h: extern void ns3::Config::SetGlobal(std::string name, ns3::AttributeValue const & value) [free function]
  2125     ## config.h: extern void ns3::Config::SetGlobal(std::string name, ns3::AttributeValue const & value) [free function]
  1364     module.add_function('SetGlobal', 'void', [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
  2126     module.add_function('SetGlobal', 
       
  2127                         'void', 
       
  2128                         [param('std::string', 'name'), param('ns3::AttributeValue&', 'value', is_const=True)])
  1365     ## config.h: extern void ns3::Config::RegisterRootNamespaceObject(ns3::Ptr<ns3::Object> obj) [free function]
  2129     ## config.h: extern void ns3::Config::RegisterRootNamespaceObject(ns3::Ptr<ns3::Object> obj) [free function]
  1366     module.add_function('RegisterRootNamespaceObject', 'void', [param('ns3::Ptr< ns3::Object >', 'obj')])
  2130     module.add_function('RegisterRootNamespaceObject', 
       
  2131                         'void', 
       
  2132                         [param('ns3::Ptr< ns3::Object >', 'obj')])
  1367     ## config.h: extern void ns3::Config::Disconnect(std::string path, ns3::CallbackBase const & cb) [free function]
  2133     ## config.h: extern void ns3::Config::Disconnect(std::string path, ns3::CallbackBase const & cb) [free function]
  1368     module.add_function('Disconnect', 'void', [param('std::string', 'path'), param('ns3::CallbackBase&', 'cb', is_const=True)])
  2134     module.add_function('Disconnect', 
       
  2135                         'void', 
       
  2136                         [param('std::string', 'path'), param('ns3::CallbackBase&', 'cb', is_const=True)])
  1369     return
  2137     return
  1370 
  2138 
  1371 def register_functions_ns3_olsr(module, root_module):
  2139 def register_functions_ns3_olsr(module, root_module):
  1372     return
  2140     return
  1373 
  2141