bindings/python/ns3_module_core.py
author Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
Sat, 04 Jul 2009 08:15:48 +0200
changeset 4654 2eaebe77d66b
parent 4589 c9374dcfd09a
permissions -rw-r--r--
Added tag ns-3.5 for changeset c975274c9707
     1 from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandlers
     2 
     3 def register_types(module):
     4     root_module = module.get_root()
     5     
     6     ## log.h: ns3::LogLevel [enumeration]
     7     module.add_enum('LogLevel', ['LOG_NONE', 'LOG_ERROR', 'LOG_LEVEL_ERROR', 'LOG_WARN', 'LOG_LEVEL_WARN', 'LOG_DEBUG', 'LOG_LEVEL_DEBUG', 'LOG_INFO', 'LOG_LEVEL_INFO', 'LOG_FUNCTION', 'LOG_LEVEL_FUNCTION', 'LOG_LOGIC', 'LOG_LEVEL_LOGIC', 'LOG_ALL', 'LOG_LEVEL_ALL', 'LOG_PREFIX_FUNC', 'LOG_PREFIX_TIME'])
     8     ## attribute-list.h: ns3::AttributeList [class]
     9     module.add_class('AttributeList')
    10     ## callback.h: ns3::CallbackBase [class]
    11     module.add_class('CallbackBase')
    12     ## callback.h: ns3::CallbackImplBase [class]
    13     module.add_class('CallbackImplBase', allow_subclassing=True, memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
    14     ## command-line.h: ns3::CommandLine [class]
    15     module.add_class('CommandLine', allow_subclassing=True)
    16     ## system-mutex.h: ns3::CriticalSection [class]
    17     module.add_class('CriticalSection')
    18     ## global-value.h: ns3::GlobalValue [class]
    19     module.add_class('GlobalValue')
    20     ## int-to-type.h: ns3::IntToType<0> [struct]
    21     module.add_class('IntToType', template_parameters=['0'])
    22     ## int-to-type.h: ns3::IntToType<0>::v_e [enumeration]
    23     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 0 >'])
    24     ## int-to-type.h: ns3::IntToType<1> [struct]
    25     module.add_class('IntToType', template_parameters=['1'])
    26     ## int-to-type.h: ns3::IntToType<1>::v_e [enumeration]
    27     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 1 >'])
    28     ## int-to-type.h: ns3::IntToType<2> [struct]
    29     module.add_class('IntToType', template_parameters=['2'])
    30     ## int-to-type.h: ns3::IntToType<2>::v_e [enumeration]
    31     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 2 >'])
    32     ## int-to-type.h: ns3::IntToType<3> [struct]
    33     module.add_class('IntToType', template_parameters=['3'])
    34     ## int-to-type.h: ns3::IntToType<3>::v_e [enumeration]
    35     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 3 >'])
    36     ## int-to-type.h: ns3::IntToType<4> [struct]
    37     module.add_class('IntToType', template_parameters=['4'])
    38     ## int-to-type.h: ns3::IntToType<4>::v_e [enumeration]
    39     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 4 >'])
    40     ## int-to-type.h: ns3::IntToType<5> [struct]
    41     module.add_class('IntToType', template_parameters=['5'])
    42     ## int-to-type.h: ns3::IntToType<5>::v_e [enumeration]
    43     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 5 >'])
    44     ## int-to-type.h: ns3::IntToType<6> [struct]
    45     module.add_class('IntToType', template_parameters=['6'])
    46     ## int-to-type.h: ns3::IntToType<6>::v_e [enumeration]
    47     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 6 >'])
    48     ## names.h: ns3::Names [class]
    49     module.add_class('Names')
    50     ## object-base.h: ns3::ObjectBase [class]
    51     module.add_class('ObjectBase', allow_subclassing=True)
    52     ## object-factory.h: ns3::ObjectFactory [class]
    53     module.add_class('ObjectFactory')
    54     ## random-variable.h: ns3::RandomVariable [class]
    55     module.add_class('RandomVariable')
    56     ## ref-count-base.h: ns3::RefCountBase [class]
    57     module.add_class('RefCountBase', automatic_type_narrowing=True, memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
    58     ## rng-stream.h: ns3::RngStream [class]
    59     module.add_class('RngStream')
    60     ## random-variable.h: ns3::SeedManager [class]
    61     module.add_class('SeedManager')
    62     ## random-variable.h: ns3::SequentialVariable [class]
    63     module.add_class('SequentialVariable', parent=root_module['ns3::RandomVariable'])
    64     ## system-condition.h: ns3::SystemCondition [class]
    65     module.add_class('SystemCondition')
    66     ## system-mutex.h: ns3::SystemMutex [class]
    67     module.add_class('SystemMutex')
    68     ## system-thread.h: ns3::SystemThread [class]
    69     module.add_class('SystemThread')
    70     ## system-wall-clock-ms.h: ns3::SystemWallClockMs [class]
    71     module.add_class('SystemWallClockMs')
    72     ## trace-source-accessor.h: ns3::TraceSourceAccessor [class]
    73     module.add_class('TraceSourceAccessor', allow_subclassing=True)
    74     ## random-variable.h: ns3::TriangularVariable [class]
    75     module.add_class('TriangularVariable', parent=root_module['ns3::RandomVariable'])
    76     ## type-id.h: ns3::TypeId [class]
    77     module.add_class('TypeId')
    78     ## type-id.h: ns3::TypeId::AttributeFlag [enumeration]
    79     module.add_enum('AttributeFlag', ['ATTR_GET', 'ATTR_SET', 'ATTR_CONSTRUCT', 'ATTR_SGC'], outer_class=root_module['ns3::TypeId'])
    80     ## type-id.h: ns3::TypeId::AttributeInfo [struct]
    81     module.add_class('AttributeInfo', outer_class=root_module['ns3::TypeId'])
    82     ## random-variable.h: ns3::UniformVariable [class]
    83     module.add_class('UniformVariable', parent=root_module['ns3::RandomVariable'])
    84     ## attribute-list.h: ns3::UnsafeAttributeList [class]
    85     module.add_class('UnsafeAttributeList')
    86     ## random-variable.h: ns3::WeibullVariable [class]
    87     module.add_class('WeibullVariable', parent=root_module['ns3::RandomVariable'])
    88     ## random-variable.h: ns3::ZipfVariable [class]
    89     module.add_class('ZipfVariable', parent=root_module['ns3::RandomVariable'])
    90     ## empty.h: ns3::empty [class]
    91     module.add_class('empty')
    92     ## attribute.h: ns3::AttributeAccessor [class]
    93     module.add_class('AttributeAccessor', parent=root_module['ns3::RefCountBase'])
    94     ## attribute.h: ns3::AttributeChecker [class]
    95     module.add_class('AttributeChecker', allow_subclassing=False, automatic_type_narrowing=True, parent=root_module['ns3::RefCountBase'])
    96     ## attribute.h: ns3::AttributeValue [class]
    97     module.add_class('AttributeValue', allow_subclassing=False, automatic_type_narrowing=True, parent=root_module['ns3::RefCountBase'])
    98     ## boolean.h: ns3::BooleanChecker [class]
    99     module.add_class('BooleanChecker', parent=root_module['ns3::AttributeChecker'])
   100     ## boolean.h: ns3::BooleanValue [class]
   101     module.add_class('BooleanValue', parent=root_module['ns3::AttributeValue'])
   102     ## callback.h: ns3::CallbackChecker [class]
   103     module.add_class('CallbackChecker', parent=root_module['ns3::AttributeChecker'])
   104     ## callback.h: ns3::CallbackValue [class]
   105     module.add_class('CallbackValue', parent=root_module['ns3::AttributeValue'])
   106     ## random-variable.h: ns3::ConstantVariable [class]
   107     module.add_class('ConstantVariable', parent=root_module['ns3::RandomVariable'])
   108     ## random-variable.h: ns3::DeterministicVariable [class]
   109     module.add_class('DeterministicVariable', parent=root_module['ns3::RandomVariable'])
   110     ## double.h: ns3::DoubleValue [class]
   111     module.add_class('DoubleValue', parent=root_module['ns3::AttributeValue'])
   112     ## random-variable.h: ns3::EmpiricalVariable [class]
   113     module.add_class('EmpiricalVariable', parent=root_module['ns3::RandomVariable'])
   114     ## attribute.h: ns3::EmptyAttributeValue [class]
   115     module.add_class('EmptyAttributeValue', parent=root_module['ns3::AttributeValue'])
   116     ## enum.h: ns3::EnumChecker [class]
   117     module.add_class('EnumChecker', parent=root_module['ns3::AttributeChecker'])
   118     ## enum.h: ns3::EnumValue [class]
   119     module.add_class('EnumValue', parent=root_module['ns3::AttributeValue'])
   120     ## random-variable.h: ns3::ErlangVariable [class]
   121     module.add_class('ErlangVariable', parent=root_module['ns3::RandomVariable'])
   122     ## random-variable.h: ns3::ExponentialVariable [class]
   123     module.add_class('ExponentialVariable', parent=root_module['ns3::RandomVariable'])
   124     ## random-variable.h: ns3::GammaVariable [class]
   125     module.add_class('GammaVariable', parent=root_module['ns3::RandomVariable'])
   126     ## random-variable.h: ns3::IntEmpiricalVariable [class]
   127     module.add_class('IntEmpiricalVariable', parent=root_module['ns3::EmpiricalVariable'])
   128     ## integer.h: ns3::IntegerValue [class]
   129     module.add_class('IntegerValue', parent=root_module['ns3::AttributeValue'])
   130     ## random-variable.h: ns3::LogNormalVariable [class]
   131     module.add_class('LogNormalVariable', parent=root_module['ns3::RandomVariable'])
   132     ## random-variable.h: ns3::NormalVariable [class]
   133     module.add_class('NormalVariable', parent=root_module['ns3::RandomVariable'])
   134     ## object.h: ns3::Object [class]
   135     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'))
   136     ## object.h: ns3::Object::AggregateIterator [class]
   137     module.add_class('AggregateIterator', outer_class=root_module['ns3::Object'])
   138     ## object-factory.h: ns3::ObjectFactoryChecker [class]
   139     module.add_class('ObjectFactoryChecker', parent=root_module['ns3::AttributeChecker'])
   140     ## object-factory.h: ns3::ObjectFactoryValue [class]
   141     module.add_class('ObjectFactoryValue', parent=root_module['ns3::AttributeValue'])
   142     ## object-vector.h: ns3::ObjectVectorAccessor [class]
   143     module.add_class('ObjectVectorAccessor', parent=root_module['ns3::AttributeAccessor'])
   144     ## object-vector.h: ns3::ObjectVectorChecker [class]
   145     module.add_class('ObjectVectorChecker', parent=root_module['ns3::AttributeChecker'])
   146     ## object-vector.h: ns3::ObjectVectorValue [class]
   147     module.add_class('ObjectVectorValue', parent=root_module['ns3::AttributeValue'])
   148     ## random-variable.h: ns3::ParetoVariable [class]
   149     module.add_class('ParetoVariable', parent=root_module['ns3::RandomVariable'])
   150     ## pointer.h: ns3::PointerChecker [class]
   151     module.add_class('PointerChecker', parent=root_module['ns3::AttributeChecker'])
   152     ## pointer.h: ns3::PointerValue [class]
   153     module.add_class('PointerValue', parent=root_module['ns3::AttributeValue'])
   154     ## random-variable.h: ns3::RandomVariableChecker [class]
   155     module.add_class('RandomVariableChecker', parent=root_module['ns3::AttributeChecker'])
   156     ## random-variable.h: ns3::RandomVariableValue [class]
   157     module.add_class('RandomVariableValue', parent=root_module['ns3::AttributeValue'])
   158     ## string.h: ns3::StringChecker [class]
   159     module.add_class('StringChecker', parent=root_module['ns3::AttributeChecker'])
   160     ## string.h: ns3::StringValue [class]
   161     module.add_class('StringValue', parent=root_module['ns3::AttributeValue'])
   162     ## type-id.h: ns3::TypeIdChecker [class]
   163     module.add_class('TypeIdChecker', parent=root_module['ns3::AttributeChecker'])
   164     ## type-id.h: ns3::TypeIdValue [class]
   165     module.add_class('TypeIdValue', parent=root_module['ns3::AttributeValue'])
   166     ## uinteger.h: ns3::UintegerValue [class]
   167     module.add_class('UintegerValue', parent=root_module['ns3::AttributeValue'])
   168     ## traced-value.h: ns3::TracedValue<unsigned int> [class]
   169     module.add_class('TracedValue', template_parameters=['unsigned int'])
   170     ## traced-value.h: ns3::TracedValue<unsigned int> [class]
   171     root_module['ns3::TracedValue< unsigned int >'].implicitly_converts_to(root_module['ns3::IntegerValue'])
   172     ## traced-value.h: ns3::TracedValue<unsigned int> [class]
   173     root_module['ns3::TracedValue< unsigned int >'].implicitly_converts_to(root_module['ns3::UintegerValue'])
   174     ## traced-value.h: ns3::TracedValue<unsigned int> [class]
   175     root_module['ns3::TracedValue< unsigned int >'].implicitly_converts_to(root_module['ns3::BooleanValue'])
   176     ## traced-value.h: ns3::TracedValue<unsigned int> [class]
   177     root_module['ns3::TracedValue< unsigned int >'].implicitly_converts_to(root_module['ns3::EnumValue'])
   178     
   179     ## Register a nested module for the namespace Config
   180     
   181     nested_module = module.add_cpp_namespace('Config')
   182     register_types_ns3_Config(nested_module)
   183     
   184     
   185     ## Register a nested module for the namespace TimeStepPrecision
   186     
   187     nested_module = module.add_cpp_namespace('TimeStepPrecision')
   188     register_types_ns3_TimeStepPrecision(nested_module)
   189     
   190     
   191     ## Register a nested module for the namespace addressUtils
   192     
   193     nested_module = module.add_cpp_namespace('addressUtils')
   194     register_types_ns3_addressUtils(nested_module)
   195     
   196     
   197     ## Register a nested module for the namespace internal
   198     
   199     nested_module = module.add_cpp_namespace('internal')
   200     register_types_ns3_internal(nested_module)
   201     
   202     
   203     ## Register a nested module for the namespace olsr
   204     
   205     nested_module = module.add_cpp_namespace('olsr')
   206     register_types_ns3_olsr(nested_module)
   207     
   208 
   209 def register_types_ns3_Config(module):
   210     root_module = module.get_root()
   211     
   212     ## config.h: ns3::Config::MatchContainer [class]
   213     module.add_class('MatchContainer')
   214     module.add_container('std::vector< ns3::Ptr< ns3::Object > >', 'ns3::Ptr< ns3::Object >', container_type='vector')
   215 
   216 def register_types_ns3_TimeStepPrecision(module):
   217     root_module = module.get_root()
   218     
   219 
   220 def register_types_ns3_addressUtils(module):
   221     root_module = module.get_root()
   222     
   223 
   224 def register_types_ns3_internal(module):
   225     root_module = module.get_root()
   226     
   227 
   228 def register_types_ns3_olsr(module):
   229     root_module = module.get_root()
   230     
   231 
   232 def register_methods(root_module):
   233     register_Ns3AttributeList_methods(root_module, root_module['ns3::AttributeList'])
   234     register_Ns3CallbackBase_methods(root_module, root_module['ns3::CallbackBase'])
   235     register_Ns3CallbackImplBase_methods(root_module, root_module['ns3::CallbackImplBase'])
   236     register_Ns3CommandLine_methods(root_module, root_module['ns3::CommandLine'])
   237     register_Ns3CriticalSection_methods(root_module, root_module['ns3::CriticalSection'])
   238     register_Ns3GlobalValue_methods(root_module, root_module['ns3::GlobalValue'])
   239     register_Ns3IntToType__0_methods(root_module, root_module['ns3::IntToType< 0 >'])
   240     register_Ns3IntToType__1_methods(root_module, root_module['ns3::IntToType< 1 >'])
   241     register_Ns3IntToType__2_methods(root_module, root_module['ns3::IntToType< 2 >'])
   242     register_Ns3IntToType__3_methods(root_module, root_module['ns3::IntToType< 3 >'])
   243     register_Ns3IntToType__4_methods(root_module, root_module['ns3::IntToType< 4 >'])
   244     register_Ns3IntToType__5_methods(root_module, root_module['ns3::IntToType< 5 >'])
   245     register_Ns3IntToType__6_methods(root_module, root_module['ns3::IntToType< 6 >'])
   246     register_Ns3Names_methods(root_module, root_module['ns3::Names'])
   247     register_Ns3ObjectBase_methods(root_module, root_module['ns3::ObjectBase'])
   248     register_Ns3ObjectFactory_methods(root_module, root_module['ns3::ObjectFactory'])
   249     register_Ns3RandomVariable_methods(root_module, root_module['ns3::RandomVariable'])
   250     register_Ns3RefCountBase_methods(root_module, root_module['ns3::RefCountBase'])
   251     register_Ns3RngStream_methods(root_module, root_module['ns3::RngStream'])
   252     register_Ns3SeedManager_methods(root_module, root_module['ns3::SeedManager'])
   253     register_Ns3SequentialVariable_methods(root_module, root_module['ns3::SequentialVariable'])
   254     register_Ns3SystemCondition_methods(root_module, root_module['ns3::SystemCondition'])
   255     register_Ns3SystemMutex_methods(root_module, root_module['ns3::SystemMutex'])
   256     register_Ns3SystemThread_methods(root_module, root_module['ns3::SystemThread'])
   257     register_Ns3SystemWallClockMs_methods(root_module, root_module['ns3::SystemWallClockMs'])
   258     register_Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::TraceSourceAccessor'])
   259     register_Ns3TriangularVariable_methods(root_module, root_module['ns3::TriangularVariable'])
   260     register_Ns3TypeId_methods(root_module, root_module['ns3::TypeId'])
   261     register_Ns3TypeIdAttributeInfo_methods(root_module, root_module['ns3::TypeId::AttributeInfo'])
   262     register_Ns3UniformVariable_methods(root_module, root_module['ns3::UniformVariable'])
   263     register_Ns3UnsafeAttributeList_methods(root_module, root_module['ns3::UnsafeAttributeList'])
   264     register_Ns3WeibullVariable_methods(root_module, root_module['ns3::WeibullVariable'])
   265     register_Ns3ZipfVariable_methods(root_module, root_module['ns3::ZipfVariable'])
   266     register_Ns3Empty_methods(root_module, root_module['ns3::empty'])
   267     register_Ns3AttributeAccessor_methods(root_module, root_module['ns3::AttributeAccessor'])
   268     register_Ns3AttributeChecker_methods(root_module, root_module['ns3::AttributeChecker'])
   269     register_Ns3AttributeValue_methods(root_module, root_module['ns3::AttributeValue'])
   270     register_Ns3BooleanChecker_methods(root_module, root_module['ns3::BooleanChecker'])
   271     register_Ns3BooleanValue_methods(root_module, root_module['ns3::BooleanValue'])
   272     register_Ns3CallbackChecker_methods(root_module, root_module['ns3::CallbackChecker'])
   273     register_Ns3CallbackValue_methods(root_module, root_module['ns3::CallbackValue'])
   274     register_Ns3ConstantVariable_methods(root_module, root_module['ns3::ConstantVariable'])
   275     register_Ns3DeterministicVariable_methods(root_module, root_module['ns3::DeterministicVariable'])
   276     register_Ns3DoubleValue_methods(root_module, root_module['ns3::DoubleValue'])
   277     register_Ns3EmpiricalVariable_methods(root_module, root_module['ns3::EmpiricalVariable'])
   278     register_Ns3EmptyAttributeValue_methods(root_module, root_module['ns3::EmptyAttributeValue'])
   279     register_Ns3EnumChecker_methods(root_module, root_module['ns3::EnumChecker'])
   280     register_Ns3EnumValue_methods(root_module, root_module['ns3::EnumValue'])
   281     register_Ns3ErlangVariable_methods(root_module, root_module['ns3::ErlangVariable'])
   282     register_Ns3ExponentialVariable_methods(root_module, root_module['ns3::ExponentialVariable'])
   283     register_Ns3GammaVariable_methods(root_module, root_module['ns3::GammaVariable'])
   284     register_Ns3IntEmpiricalVariable_methods(root_module, root_module['ns3::IntEmpiricalVariable'])
   285     register_Ns3IntegerValue_methods(root_module, root_module['ns3::IntegerValue'])
   286     register_Ns3LogNormalVariable_methods(root_module, root_module['ns3::LogNormalVariable'])
   287     register_Ns3NormalVariable_methods(root_module, root_module['ns3::NormalVariable'])
   288     register_Ns3Object_methods(root_module, root_module['ns3::Object'])
   289     register_Ns3ObjectAggregateIterator_methods(root_module, root_module['ns3::Object::AggregateIterator'])
   290     register_Ns3ObjectFactoryChecker_methods(root_module, root_module['ns3::ObjectFactoryChecker'])
   291     register_Ns3ObjectFactoryValue_methods(root_module, root_module['ns3::ObjectFactoryValue'])
   292     register_Ns3ObjectVectorAccessor_methods(root_module, root_module['ns3::ObjectVectorAccessor'])
   293     register_Ns3ObjectVectorChecker_methods(root_module, root_module['ns3::ObjectVectorChecker'])
   294     register_Ns3ObjectVectorValue_methods(root_module, root_module['ns3::ObjectVectorValue'])
   295     register_Ns3ParetoVariable_methods(root_module, root_module['ns3::ParetoVariable'])
   296     register_Ns3PointerChecker_methods(root_module, root_module['ns3::PointerChecker'])
   297     register_Ns3PointerValue_methods(root_module, root_module['ns3::PointerValue'])
   298     register_Ns3RandomVariableChecker_methods(root_module, root_module['ns3::RandomVariableChecker'])
   299     register_Ns3RandomVariableValue_methods(root_module, root_module['ns3::RandomVariableValue'])
   300     register_Ns3StringChecker_methods(root_module, root_module['ns3::StringChecker'])
   301     register_Ns3StringValue_methods(root_module, root_module['ns3::StringValue'])
   302     register_Ns3TypeIdChecker_methods(root_module, root_module['ns3::TypeIdChecker'])
   303     register_Ns3TypeIdValue_methods(root_module, root_module['ns3::TypeIdValue'])
   304     register_Ns3UintegerValue_methods(root_module, root_module['ns3::UintegerValue'])
   305     register_Ns3TracedValue__Unsigned_int_methods(root_module, root_module['ns3::TracedValue< unsigned int >'])
   306     register_Ns3ConfigMatchContainer_methods(root_module, root_module['ns3::Config::MatchContainer'])
   307     return
   308 
   309 def register_Ns3AttributeList_methods(root_module, cls):
   310     ## attribute-list.h: ns3::AttributeList::AttributeList() [constructor]
   311     cls.add_constructor([])
   312     ## attribute-list.h: ns3::AttributeList::AttributeList(ns3::AttributeList const & o) [copy constructor]
   313     cls.add_constructor([param('ns3::AttributeList const &', 'o')])
   314     ## attribute-list.h: void ns3::AttributeList::Set(std::string name, ns3::AttributeValue const & value) [member function]
   315     cls.add_method('Set', 
   316                    'void', 
   317                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
   318     ## attribute-list.h: bool ns3::AttributeList::SetFailSafe(std::string name, ns3::AttributeValue const & value) [member function]
   319     cls.add_method('SetFailSafe', 
   320                    'bool', 
   321                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
   322     ## attribute-list.h: void ns3::AttributeList::SetWithTid(ns3::TypeId tid, std::string name, ns3::AttributeValue const & value) [member function]
   323     cls.add_method('SetWithTid', 
   324                    'void', 
   325                    [param('ns3::TypeId', 'tid'), param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
   326     ## attribute-list.h: void ns3::AttributeList::Reset() [member function]
   327     cls.add_method('Reset', 
   328                    'void', 
   329                    [])
   330     ## attribute-list.h: static ns3::AttributeList * ns3::AttributeList::GetGlobal() [member function]
   331     cls.add_method('GetGlobal', 
   332                    'ns3::AttributeList *', 
   333                    [], 
   334                    is_static=True)
   335     ## attribute-list.h: std::string ns3::AttributeList::SerializeToString() const [member function]
   336     cls.add_method('SerializeToString', 
   337                    'std::string', 
   338                    [], 
   339                    is_const=True)
   340     ## attribute-list.h: bool ns3::AttributeList::DeserializeFromString(std::string value) [member function]
   341     cls.add_method('DeserializeFromString', 
   342                    'bool', 
   343                    [param('std::string', 'value')])
   344     return
   345 
   346 def register_Ns3CallbackBase_methods(root_module, cls):
   347     ## callback.h: ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [copy constructor]
   348     cls.add_constructor([param('ns3::CallbackBase const &', 'arg0')])
   349     ## callback.h: ns3::CallbackBase::CallbackBase() [constructor]
   350     cls.add_constructor([])
   351     ## callback.h: ns3::Ptr<ns3::CallbackImplBase> ns3::CallbackBase::GetImpl() const [member function]
   352     cls.add_method('GetImpl', 
   353                    'ns3::Ptr< ns3::CallbackImplBase >', 
   354                    [], 
   355                    is_const=True)
   356     ## callback.h: ns3::CallbackBase::CallbackBase(ns3::Ptr<ns3::CallbackImplBase> impl) [constructor]
   357     cls.add_constructor([param('ns3::Ptr< ns3::CallbackImplBase >', 'impl')], 
   358                         visibility='protected')
   359     ## callback.h: static std::string ns3::CallbackBase::Demangle(std::string const & mangled) [member function]
   360     cls.add_method('Demangle', 
   361                    'std::string', 
   362                    [param('std::string const &', 'mangled')], 
   363                    is_static=True, visibility='protected')
   364     return
   365 
   366 def register_Ns3CallbackImplBase_methods(root_module, cls):
   367     ## callback.h: ns3::CallbackImplBase::CallbackImplBase(ns3::CallbackImplBase const & arg0) [copy constructor]
   368     cls.add_constructor([param('ns3::CallbackImplBase const &', 'arg0')])
   369     ## callback.h: ns3::CallbackImplBase::CallbackImplBase() [constructor]
   370     cls.add_constructor([])
   371     ## callback.h: bool ns3::CallbackImplBase::IsEqual(ns3::Ptr<ns3::CallbackImplBase const> other) const [member function]
   372     cls.add_method('IsEqual', 
   373                    'bool', 
   374                    [param('ns3::Ptr< ns3::CallbackImplBase const >', 'other')], 
   375                    is_pure_virtual=True, is_const=True, is_virtual=True)
   376     return
   377 
   378 def register_Ns3CommandLine_methods(root_module, cls):
   379     ## command-line.h: ns3::CommandLine::CommandLine(ns3::CommandLine const & arg0) [copy constructor]
   380     cls.add_constructor([param('ns3::CommandLine const &', 'arg0')])
   381     ## command-line.h: ns3::CommandLine::CommandLine() [constructor]
   382     cls.add_constructor([])
   383     ## command-line.h: void ns3::CommandLine::AddValue(std::string const & name, std::string const & help, ns3::Callback<bool, std::string, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function]
   384     cls.add_method('AddValue', 
   385                    'void', 
   386                    [param('std::string const &', 'name'), param('std::string const &', 'help'), param('ns3::Callback< bool, std::string, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')])
   387     return
   388 
   389 def register_Ns3CriticalSection_methods(root_module, cls):
   390     ## system-mutex.h: ns3::CriticalSection::CriticalSection(ns3::CriticalSection const & arg0) [copy constructor]
   391     cls.add_constructor([param('ns3::CriticalSection const &', 'arg0')])
   392     ## system-mutex.h: ns3::CriticalSection::CriticalSection(ns3::SystemMutex & mutex) [constructor]
   393     cls.add_constructor([param('ns3::SystemMutex &', 'mutex')])
   394     return
   395 
   396 def register_Ns3GlobalValue_methods(root_module, cls):
   397     ## global-value.h: ns3::GlobalValue::GlobalValue(ns3::GlobalValue const & arg0) [copy constructor]
   398     cls.add_constructor([param('ns3::GlobalValue const &', 'arg0')])
   399     ## global-value.h: ns3::GlobalValue::GlobalValue(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr<ns3::AttributeChecker const> checker) [constructor]
   400     cls.add_constructor([param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')])
   401     ## global-value.h: std::string ns3::GlobalValue::GetName() const [member function]
   402     cls.add_method('GetName', 
   403                    'std::string', 
   404                    [], 
   405                    is_const=True)
   406     ## global-value.h: std::string ns3::GlobalValue::GetHelp() const [member function]
   407     cls.add_method('GetHelp', 
   408                    'std::string', 
   409                    [], 
   410                    is_const=True)
   411     ## global-value.h: void ns3::GlobalValue::GetValue(ns3::AttributeValue & value) const [member function]
   412     cls.add_method('GetValue', 
   413                    'void', 
   414                    [param('ns3::AttributeValue &', 'value')], 
   415                    is_const=True)
   416     ## global-value.h: ns3::Ptr<ns3::AttributeChecker const> ns3::GlobalValue::GetChecker() const [member function]
   417     cls.add_method('GetChecker', 
   418                    'ns3::Ptr< ns3::AttributeChecker const >', 
   419                    [], 
   420                    is_const=True)
   421     ## global-value.h: bool ns3::GlobalValue::SetValue(ns3::AttributeValue const & value) [member function]
   422     cls.add_method('SetValue', 
   423                    'bool', 
   424                    [param('ns3::AttributeValue const &', 'value')])
   425     ## global-value.h: static void ns3::GlobalValue::Bind(std::string name, ns3::AttributeValue const & value) [member function]
   426     cls.add_method('Bind', 
   427                    'void', 
   428                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')], 
   429                    is_static=True)
   430     ## global-value.h: static bool ns3::GlobalValue::BindFailSafe(std::string name, ns3::AttributeValue const & value) [member function]
   431     cls.add_method('BindFailSafe', 
   432                    'bool', 
   433                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')], 
   434                    is_static=True)
   435     ## global-value.h: static __gnu_cxx::__normal_iterator<ns3::GlobalValue* const*,std::vector<ns3::GlobalValue*, std::allocator<ns3::GlobalValue*> > > ns3::GlobalValue::Begin() [member function]
   436     cls.add_method('Begin', 
   437                    '__gnu_cxx::__normal_iterator< ns3::GlobalValue * const *, std::vector< ns3::GlobalValue * > >', 
   438                    [], 
   439                    is_static=True)
   440     ## global-value.h: static __gnu_cxx::__normal_iterator<ns3::GlobalValue* const*,std::vector<ns3::GlobalValue*, std::allocator<ns3::GlobalValue*> > > ns3::GlobalValue::End() [member function]
   441     cls.add_method('End', 
   442                    '__gnu_cxx::__normal_iterator< ns3::GlobalValue * const *, std::vector< ns3::GlobalValue * > >', 
   443                    [], 
   444                    is_static=True)
   445     return
   446 
   447 def register_Ns3IntToType__0_methods(root_module, cls):
   448     ## int-to-type.h: ns3::IntToType<0>::IntToType(ns3::IntToType<0> const & arg0) [copy constructor]
   449     cls.add_constructor([param('ns3::IntToType< 0 > const &', 'arg0')])
   450     ## int-to-type.h: ns3::IntToType<0>::IntToType() [constructor]
   451     cls.add_constructor([])
   452     return
   453 
   454 def register_Ns3IntToType__1_methods(root_module, cls):
   455     ## int-to-type.h: ns3::IntToType<1>::IntToType(ns3::IntToType<1> const & arg0) [copy constructor]
   456     cls.add_constructor([param('ns3::IntToType< 1 > const &', 'arg0')])
   457     ## int-to-type.h: ns3::IntToType<1>::IntToType() [constructor]
   458     cls.add_constructor([])
   459     return
   460 
   461 def register_Ns3IntToType__2_methods(root_module, cls):
   462     ## int-to-type.h: ns3::IntToType<2>::IntToType(ns3::IntToType<2> const & arg0) [copy constructor]
   463     cls.add_constructor([param('ns3::IntToType< 2 > const &', 'arg0')])
   464     ## int-to-type.h: ns3::IntToType<2>::IntToType() [constructor]
   465     cls.add_constructor([])
   466     return
   467 
   468 def register_Ns3IntToType__3_methods(root_module, cls):
   469     ## int-to-type.h: ns3::IntToType<3>::IntToType(ns3::IntToType<3> const & arg0) [copy constructor]
   470     cls.add_constructor([param('ns3::IntToType< 3 > const &', 'arg0')])
   471     ## int-to-type.h: ns3::IntToType<3>::IntToType() [constructor]
   472     cls.add_constructor([])
   473     return
   474 
   475 def register_Ns3IntToType__4_methods(root_module, cls):
   476     ## int-to-type.h: ns3::IntToType<4>::IntToType(ns3::IntToType<4> const & arg0) [copy constructor]
   477     cls.add_constructor([param('ns3::IntToType< 4 > const &', 'arg0')])
   478     ## int-to-type.h: ns3::IntToType<4>::IntToType() [constructor]
   479     cls.add_constructor([])
   480     return
   481 
   482 def register_Ns3IntToType__5_methods(root_module, cls):
   483     ## int-to-type.h: ns3::IntToType<5>::IntToType(ns3::IntToType<5> const & arg0) [copy constructor]
   484     cls.add_constructor([param('ns3::IntToType< 5 > const &', 'arg0')])
   485     ## int-to-type.h: ns3::IntToType<5>::IntToType() [constructor]
   486     cls.add_constructor([])
   487     return
   488 
   489 def register_Ns3IntToType__6_methods(root_module, cls):
   490     ## int-to-type.h: ns3::IntToType<6>::IntToType(ns3::IntToType<6> const & arg0) [copy constructor]
   491     cls.add_constructor([param('ns3::IntToType< 6 > const &', 'arg0')])
   492     ## int-to-type.h: ns3::IntToType<6>::IntToType() [constructor]
   493     cls.add_constructor([])
   494     return
   495 
   496 def register_Ns3Names_methods(root_module, cls):
   497     ## names.h: ns3::Names::Names(ns3::Names const & arg0) [copy constructor]
   498     cls.add_constructor([param('ns3::Names const &', 'arg0')])
   499     ## names.h: ns3::Names::Names() [constructor]
   500     cls.add_constructor([])
   501     ## names.h: static void ns3::Names::Add(std::string name, ns3::Ptr<ns3::Object> object) [member function]
   502     cls.add_method('Add', 
   503                    'void', 
   504                    [param('std::string', 'name'), param('ns3::Ptr< ns3::Object >', 'object')], 
   505                    is_static=True)
   506     ## names.h: static void ns3::Names::Add(std::string path, std::string name, ns3::Ptr<ns3::Object> object) [member function]
   507     cls.add_method('Add', 
   508                    'void', 
   509                    [param('std::string', 'path'), param('std::string', 'name'), param('ns3::Ptr< ns3::Object >', 'object')], 
   510                    is_static=True)
   511     ## names.h: static void ns3::Names::Add(ns3::Ptr<ns3::Object> context, std::string name, ns3::Ptr<ns3::Object> object) [member function]
   512     cls.add_method('Add', 
   513                    'void', 
   514                    [param('ns3::Ptr< ns3::Object >', 'context'), param('std::string', 'name'), param('ns3::Ptr< ns3::Object >', 'object')], 
   515                    is_static=True)
   516     ## names.h: static void ns3::Names::Rename(std::string oldpath, std::string newname) [member function]
   517     cls.add_method('Rename', 
   518                    'void', 
   519                    [param('std::string', 'oldpath'), param('std::string', 'newname')], 
   520                    is_static=True)
   521     ## names.h: static void ns3::Names::Rename(std::string path, std::string oldname, std::string newname) [member function]
   522     cls.add_method('Rename', 
   523                    'void', 
   524                    [param('std::string', 'path'), param('std::string', 'oldname'), param('std::string', 'newname')], 
   525                    is_static=True)
   526     ## names.h: static void ns3::Names::Rename(ns3::Ptr<ns3::Object> context, std::string oldname, std::string newname) [member function]
   527     cls.add_method('Rename', 
   528                    'void', 
   529                    [param('ns3::Ptr< ns3::Object >', 'context'), param('std::string', 'oldname'), param('std::string', 'newname')], 
   530                    is_static=True)
   531     ## names.h: static std::string ns3::Names::FindName(ns3::Ptr<ns3::Object> object) [member function]
   532     cls.add_method('FindName', 
   533                    'std::string', 
   534                    [param('ns3::Ptr< ns3::Object >', 'object')], 
   535                    is_static=True)
   536     ## names.h: static std::string ns3::Names::FindPath(ns3::Ptr<ns3::Object> object) [member function]
   537     cls.add_method('FindPath', 
   538                    'std::string', 
   539                    [param('ns3::Ptr< ns3::Object >', 'object')], 
   540                    is_static=True)
   541     ## names.h: static void ns3::Names::Delete() [member function]
   542     cls.add_method('Delete', 
   543                    'void', 
   544                    [], 
   545                    is_static=True)
   546     return
   547 
   548 def register_Ns3ObjectBase_methods(root_module, cls):
   549     ## object-base.h: ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [copy constructor]
   550     cls.add_constructor([param('ns3::ObjectBase const &', 'arg0')])
   551     ## object-base.h: ns3::ObjectBase::ObjectBase() [constructor]
   552     cls.add_constructor([])
   553     ## object-base.h: static ns3::TypeId ns3::ObjectBase::GetTypeId() [member function]
   554     cls.add_method('GetTypeId', 
   555                    'ns3::TypeId', 
   556                    [], 
   557                    is_static=True)
   558     ## object-base.h: ns3::TypeId ns3::ObjectBase::GetInstanceTypeId() const [member function]
   559     cls.add_method('GetInstanceTypeId', 
   560                    'ns3::TypeId', 
   561                    [], 
   562                    is_pure_virtual=True, is_const=True, is_virtual=True)
   563     ## object-base.h: void ns3::ObjectBase::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function]
   564     cls.add_method('SetAttribute', 
   565                    'void', 
   566                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
   567     ## object-base.h: bool ns3::ObjectBase::SetAttributeFailSafe(std::string name, ns3::AttributeValue const & value) [member function]
   568     cls.add_method('SetAttributeFailSafe', 
   569                    'bool', 
   570                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
   571     ## object-base.h: void ns3::ObjectBase::GetAttribute(std::string name, ns3::AttributeValue & value) const [member function]
   572     cls.add_method('GetAttribute', 
   573                    'void', 
   574                    [param('std::string', 'name'), param('ns3::AttributeValue &', 'value')], 
   575                    is_const=True)
   576     ## object-base.h: bool ns3::ObjectBase::GetAttributeFailSafe(std::string name, ns3::AttributeValue & attribute) const [member function]
   577     cls.add_method('GetAttributeFailSafe', 
   578                    'bool', 
   579                    [param('std::string', 'name'), param('ns3::AttributeValue &', 'attribute')], 
   580                    is_const=True)
   581     ## object-base.h: bool ns3::ObjectBase::TraceConnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function]
   582     cls.add_method('TraceConnect', 
   583                    'bool', 
   584                    [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')])
   585     ## object-base.h: bool ns3::ObjectBase::TraceConnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]
   586     cls.add_method('TraceConnectWithoutContext', 
   587                    'bool', 
   588                    [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])
   589     ## object-base.h: bool ns3::ObjectBase::TraceDisconnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function]
   590     cls.add_method('TraceDisconnect', 
   591                    'bool', 
   592                    [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')])
   593     ## object-base.h: bool ns3::ObjectBase::TraceDisconnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]
   594     cls.add_method('TraceDisconnectWithoutContext', 
   595                    'bool', 
   596                    [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])
   597     ## object-base.h: void ns3::ObjectBase::NotifyConstructionCompleted() [member function]
   598     cls.add_method('NotifyConstructionCompleted', 
   599                    'void', 
   600                    [], 
   601                    visibility='protected', is_virtual=True)
   602     ## object-base.h: void ns3::ObjectBase::ConstructSelf(ns3::AttributeList const & attributes) [member function]
   603     cls.add_method('ConstructSelf', 
   604                    'void', 
   605                    [param('ns3::AttributeList const &', 'attributes')], 
   606                    visibility='protected')
   607     return
   608 
   609 def register_Ns3ObjectFactory_methods(root_module, cls):
   610     cls.add_output_stream_operator()
   611     ## object-factory.h: ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [copy constructor]
   612     cls.add_constructor([param('ns3::ObjectFactory const &', 'arg0')])
   613     ## object-factory.h: ns3::ObjectFactory::ObjectFactory() [constructor]
   614     cls.add_constructor([])
   615     ## object-factory.h: ns3::Ptr<ns3::Object> ns3::ObjectFactory::Create() const [member function]
   616     cls.add_method('Create', 
   617                    'ns3::Ptr< ns3::Object >', 
   618                    [], 
   619                    is_const=True)
   620     ## object-factory.h: ns3::TypeId ns3::ObjectFactory::GetTypeId() const [member function]
   621     cls.add_method('GetTypeId', 
   622                    'ns3::TypeId', 
   623                    [], 
   624                    is_const=True)
   625     ## object-factory.h: void ns3::ObjectFactory::Set(std::string name, ns3::AttributeValue const & value) [member function]
   626     cls.add_method('Set', 
   627                    'void', 
   628                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
   629     ## object-factory.h: void ns3::ObjectFactory::Set(ns3::AttributeList const & list) [member function]
   630     cls.add_method('Set', 
   631                    'void', 
   632                    [param('ns3::AttributeList const &', 'list')])
   633     ## object-factory.h: void ns3::ObjectFactory::SetTypeId(ns3::TypeId tid) [member function]
   634     cls.add_method('SetTypeId', 
   635                    'void', 
   636                    [param('ns3::TypeId', 'tid')])
   637     ## object-factory.h: void ns3::ObjectFactory::SetTypeId(char const * tid) [member function]
   638     cls.add_method('SetTypeId', 
   639                    'void', 
   640                    [param('char const *', 'tid')])
   641     ## object-factory.h: void ns3::ObjectFactory::SetTypeId(std::string tid) [member function]
   642     cls.add_method('SetTypeId', 
   643                    'void', 
   644                    [param('std::string', 'tid')])
   645     return
   646 
   647 def register_Ns3RandomVariable_methods(root_module, cls):
   648     cls.add_output_stream_operator()
   649     ## random-variable.h: ns3::RandomVariable::RandomVariable() [constructor]
   650     cls.add_constructor([])
   651     ## random-variable.h: ns3::RandomVariable::RandomVariable(ns3::RandomVariable const & o) [copy constructor]
   652     cls.add_constructor([param('ns3::RandomVariable const &', 'o')])
   653     ## random-variable.h: uint32_t ns3::RandomVariable::GetInteger() const [member function]
   654     cls.add_method('GetInteger', 
   655                    'uint32_t', 
   656                    [], 
   657                    is_const=True)
   658     ## random-variable.h: double ns3::RandomVariable::GetValue() const [member function]
   659     cls.add_method('GetValue', 
   660                    'double', 
   661                    [], 
   662                    is_const=True)
   663     return
   664 
   665 def register_Ns3RefCountBase_methods(root_module, cls):
   666     ## ref-count-base.h: ns3::RefCountBase::RefCountBase() [constructor]
   667     cls.add_constructor([])
   668     ## ref-count-base.h: ns3::RefCountBase::RefCountBase(ns3::RefCountBase const & o) [copy constructor]
   669     cls.add_constructor([param('ns3::RefCountBase const &', 'o')])
   670     return
   671 
   672 def register_Ns3RngStream_methods(root_module, cls):
   673     ## rng-stream.h: ns3::RngStream::RngStream() [constructor]
   674     cls.add_constructor([])
   675     ## rng-stream.h: ns3::RngStream::RngStream(ns3::RngStream const & arg0) [copy constructor]
   676     cls.add_constructor([param('ns3::RngStream const &', 'arg0')])
   677     ## rng-stream.h: void ns3::RngStream::InitializeStream() [member function]
   678     cls.add_method('InitializeStream', 
   679                    'void', 
   680                    [])
   681     ## rng-stream.h: void ns3::RngStream::ResetStartStream() [member function]
   682     cls.add_method('ResetStartStream', 
   683                    'void', 
   684                    [])
   685     ## rng-stream.h: void ns3::RngStream::ResetStartSubstream() [member function]
   686     cls.add_method('ResetStartSubstream', 
   687                    'void', 
   688                    [])
   689     ## rng-stream.h: void ns3::RngStream::ResetNextSubstream() [member function]
   690     cls.add_method('ResetNextSubstream', 
   691                    'void', 
   692                    [])
   693     ## rng-stream.h: void ns3::RngStream::ResetNthSubstream(uint32_t N) [member function]
   694     cls.add_method('ResetNthSubstream', 
   695                    'void', 
   696                    [param('uint32_t', 'N')])
   697     ## rng-stream.h: void ns3::RngStream::SetAntithetic(bool a) [member function]
   698     cls.add_method('SetAntithetic', 
   699                    'void', 
   700                    [param('bool', 'a')])
   701     ## rng-stream.h: void ns3::RngStream::IncreasedPrecis(bool incp) [member function]
   702     cls.add_method('IncreasedPrecis', 
   703                    'void', 
   704                    [param('bool', 'incp')])
   705     ## rng-stream.h: bool ns3::RngStream::SetSeeds(uint32_t const * seed) [member function]
   706     cls.add_method('SetSeeds', 
   707                    'bool', 
   708                    [param('uint32_t const *', 'seed')])
   709     ## rng-stream.h: void ns3::RngStream::AdvanceState(int32_t e, int32_t c) [member function]
   710     cls.add_method('AdvanceState', 
   711                    'void', 
   712                    [param('int32_t', 'e'), param('int32_t', 'c')])
   713     ## rng-stream.h: void ns3::RngStream::GetState(uint32_t * seed) const [member function]
   714     cls.add_method('GetState', 
   715                    'void', 
   716                    [param('uint32_t *', 'seed')], 
   717                    is_const=True)
   718     ## rng-stream.h: double ns3::RngStream::RandU01() [member function]
   719     cls.add_method('RandU01', 
   720                    'double', 
   721                    [])
   722     ## rng-stream.h: int32_t ns3::RngStream::RandInt(int32_t i, int32_t j) [member function]
   723     cls.add_method('RandInt', 
   724                    'int32_t', 
   725                    [param('int32_t', 'i'), param('int32_t', 'j')])
   726     ## rng-stream.h: static bool ns3::RngStream::SetPackageSeed(uint32_t seed) [member function]
   727     cls.add_method('SetPackageSeed', 
   728                    'bool', 
   729                    [param('uint32_t', 'seed')], 
   730                    is_static=True)
   731     ## rng-stream.h: static bool ns3::RngStream::SetPackageSeed(uint32_t const * seed) [member function]
   732     cls.add_method('SetPackageSeed', 
   733                    'bool', 
   734                    [param('uint32_t const *', 'seed')], 
   735                    is_static=True)
   736     ## rng-stream.h: static void ns3::RngStream::GetPackageSeed(uint32_t * seed) [member function]
   737     cls.add_method('GetPackageSeed', 
   738                    'void', 
   739                    [param('uint32_t *', 'seed')], 
   740                    is_static=True)
   741     ## rng-stream.h: static void ns3::RngStream::SetPackageRun(uint32_t run) [member function]
   742     cls.add_method('SetPackageRun', 
   743                    'void', 
   744                    [param('uint32_t', 'run')], 
   745                    is_static=True)
   746     ## rng-stream.h: static uint32_t ns3::RngStream::GetPackageRun() [member function]
   747     cls.add_method('GetPackageRun', 
   748                    'uint32_t', 
   749                    [], 
   750                    is_static=True)
   751     ## rng-stream.h: static bool ns3::RngStream::CheckSeed(uint32_t const * seed) [member function]
   752     cls.add_method('CheckSeed', 
   753                    'bool', 
   754                    [param('uint32_t const *', 'seed')], 
   755                    is_static=True)
   756     ## rng-stream.h: static bool ns3::RngStream::CheckSeed(uint32_t seed) [member function]
   757     cls.add_method('CheckSeed', 
   758                    'bool', 
   759                    [param('uint32_t', 'seed')], 
   760                    is_static=True)
   761     return
   762 
   763 def register_Ns3SeedManager_methods(root_module, cls):
   764     ## random-variable.h: ns3::SeedManager::SeedManager(ns3::SeedManager const & arg0) [copy constructor]
   765     cls.add_constructor([param('ns3::SeedManager const &', 'arg0')])
   766     ## random-variable.h: ns3::SeedManager::SeedManager() [constructor]
   767     cls.add_constructor([])
   768     ## random-variable.h: static void ns3::SeedManager::SetSeed(uint32_t seed) [member function]
   769     cls.add_method('SetSeed', 
   770                    'void', 
   771                    [param('uint32_t', 'seed')], 
   772                    is_static=True)
   773     ## random-variable.h: static uint32_t ns3::SeedManager::GetSeed() [member function]
   774     cls.add_method('GetSeed', 
   775                    'uint32_t', 
   776                    [], 
   777                    is_static=True)
   778     ## random-variable.h: static void ns3::SeedManager::SetRun(uint32_t run) [member function]
   779     cls.add_method('SetRun', 
   780                    'void', 
   781                    [param('uint32_t', 'run')], 
   782                    is_static=True)
   783     ## random-variable.h: static uint32_t ns3::SeedManager::GetRun() [member function]
   784     cls.add_method('GetRun', 
   785                    'uint32_t', 
   786                    [], 
   787                    is_static=True)
   788     ## random-variable.h: static bool ns3::SeedManager::CheckSeed(uint32_t seed) [member function]
   789     cls.add_method('CheckSeed', 
   790                    'bool', 
   791                    [param('uint32_t', 'seed')], 
   792                    is_static=True)
   793     return
   794 
   795 def register_Ns3SequentialVariable_methods(root_module, cls):
   796     ## random-variable.h: ns3::SequentialVariable::SequentialVariable(ns3::SequentialVariable const & arg0) [copy constructor]
   797     cls.add_constructor([param('ns3::SequentialVariable const &', 'arg0')])
   798     ## random-variable.h: ns3::SequentialVariable::SequentialVariable(double f, double l, double i=1, uint32_t c=1) [constructor]
   799     cls.add_constructor([param('double', 'f'), param('double', 'l'), param('double', 'i', default_value='1'), param('uint32_t', 'c', default_value='1')])
   800     ## random-variable.h: ns3::SequentialVariable::SequentialVariable(double f, double l, ns3::RandomVariable const & i, uint32_t c=1) [constructor]
   801     cls.add_constructor([param('double', 'f'), param('double', 'l'), param('ns3::RandomVariable const &', 'i'), param('uint32_t', 'c', default_value='1')])
   802     return
   803 
   804 def register_Ns3SystemCondition_methods(root_module, cls):
   805     ## system-condition.h: ns3::SystemCondition::SystemCondition(ns3::SystemCondition const & arg0) [copy constructor]
   806     cls.add_constructor([param('ns3::SystemCondition const &', 'arg0')])
   807     ## system-condition.h: ns3::SystemCondition::SystemCondition() [constructor]
   808     cls.add_constructor([])
   809     ## system-condition.h: void ns3::SystemCondition::SetCondition(bool condition) [member function]
   810     cls.add_method('SetCondition', 
   811                    'void', 
   812                    [param('bool', 'condition')])
   813     ## system-condition.h: bool ns3::SystemCondition::GetCondition() [member function]
   814     cls.add_method('GetCondition', 
   815                    'bool', 
   816                    [])
   817     ## system-condition.h: void ns3::SystemCondition::Signal() [member function]
   818     cls.add_method('Signal', 
   819                    'void', 
   820                    [])
   821     ## system-condition.h: void ns3::SystemCondition::Broadcast() [member function]
   822     cls.add_method('Broadcast', 
   823                    'void', 
   824                    [])
   825     ## system-condition.h: void ns3::SystemCondition::Wait() [member function]
   826     cls.add_method('Wait', 
   827                    'void', 
   828                    [])
   829     ## system-condition.h: bool ns3::SystemCondition::TimedWait(uint64_t ns) [member function]
   830     cls.add_method('TimedWait', 
   831                    'bool', 
   832                    [param('uint64_t', 'ns')])
   833     return
   834 
   835 def register_Ns3SystemMutex_methods(root_module, cls):
   836     ## system-mutex.h: ns3::SystemMutex::SystemMutex(ns3::SystemMutex const & arg0) [copy constructor]
   837     cls.add_constructor([param('ns3::SystemMutex const &', 'arg0')])
   838     ## system-mutex.h: ns3::SystemMutex::SystemMutex() [constructor]
   839     cls.add_constructor([])
   840     ## system-mutex.h: void ns3::SystemMutex::Lock() [member function]
   841     cls.add_method('Lock', 
   842                    'void', 
   843                    [])
   844     ## system-mutex.h: void ns3::SystemMutex::Unlock() [member function]
   845     cls.add_method('Unlock', 
   846                    'void', 
   847                    [])
   848     return
   849 
   850 def register_Ns3SystemThread_methods(root_module, cls):
   851     ## system-thread.h: ns3::SystemThread::SystemThread(ns3::SystemThread const & arg0) [copy constructor]
   852     cls.add_constructor([param('ns3::SystemThread const &', 'arg0')])
   853     ## system-thread.h: ns3::SystemThread::SystemThread(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [constructor]
   854     cls.add_constructor([param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')])
   855     ## system-thread.h: void ns3::SystemThread::Ref() const [member function]
   856     cls.add_method('Ref', 
   857                    'void', 
   858                    [], 
   859                    is_const=True)
   860     ## system-thread.h: void ns3::SystemThread::Unref() const [member function]
   861     cls.add_method('Unref', 
   862                    'void', 
   863                    [], 
   864                    is_const=True)
   865     ## system-thread.h: void ns3::SystemThread::Start() [member function]
   866     cls.add_method('Start', 
   867                    'void', 
   868                    [])
   869     ## system-thread.h: void ns3::SystemThread::Join() [member function]
   870     cls.add_method('Join', 
   871                    'void', 
   872                    [])
   873     ## system-thread.h: void ns3::SystemThread::Shutdown() [member function]
   874     cls.add_method('Shutdown', 
   875                    'void', 
   876                    [])
   877     ## system-thread.h: bool ns3::SystemThread::Break() [member function]
   878     cls.add_method('Break', 
   879                    'bool', 
   880                    [])
   881     return
   882 
   883 def register_Ns3SystemWallClockMs_methods(root_module, cls):
   884     ## system-wall-clock-ms.h: ns3::SystemWallClockMs::SystemWallClockMs(ns3::SystemWallClockMs const & arg0) [copy constructor]
   885     cls.add_constructor([param('ns3::SystemWallClockMs const &', 'arg0')])
   886     ## system-wall-clock-ms.h: ns3::SystemWallClockMs::SystemWallClockMs() [constructor]
   887     cls.add_constructor([])
   888     ## system-wall-clock-ms.h: void ns3::SystemWallClockMs::Start() [member function]
   889     cls.add_method('Start', 
   890                    'void', 
   891                    [])
   892     ## system-wall-clock-ms.h: long long unsigned int ns3::SystemWallClockMs::End() [member function]
   893     cls.add_method('End', 
   894                    'long long unsigned int', 
   895                    [])
   896     return
   897 
   898 def register_Ns3TraceSourceAccessor_methods(root_module, cls):
   899     ## trace-source-accessor.h: ns3::TraceSourceAccessor::TraceSourceAccessor(ns3::TraceSourceAccessor const & arg0) [copy constructor]
   900     cls.add_constructor([param('ns3::TraceSourceAccessor const &', 'arg0')])
   901     ## trace-source-accessor.h: ns3::TraceSourceAccessor::TraceSourceAccessor() [constructor]
   902     cls.add_constructor([])
   903     ## trace-source-accessor.h: void ns3::TraceSourceAccessor::Ref() const [member function]
   904     cls.add_method('Ref', 
   905                    'void', 
   906                    [], 
   907                    is_const=True)
   908     ## trace-source-accessor.h: void ns3::TraceSourceAccessor::Unref() const [member function]
   909     cls.add_method('Unref', 
   910                    'void', 
   911                    [], 
   912                    is_const=True)
   913     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::ConnectWithoutContext(ns3::ObjectBase * obj, ns3::CallbackBase const & cb) const [member function]
   914     cls.add_method('ConnectWithoutContext', 
   915                    'bool', 
   916                    [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase const &', 'cb')], 
   917                    is_pure_virtual=True, is_const=True, is_virtual=True)
   918     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::Connect(ns3::ObjectBase * obj, std::string context, ns3::CallbackBase const & cb) const [member function]
   919     cls.add_method('Connect', 
   920                    'bool', 
   921                    [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')], 
   922                    is_pure_virtual=True, is_const=True, is_virtual=True)
   923     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::DisconnectWithoutContext(ns3::ObjectBase * obj, ns3::CallbackBase const & cb) const [member function]
   924     cls.add_method('DisconnectWithoutContext', 
   925                    'bool', 
   926                    [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase const &', 'cb')], 
   927                    is_pure_virtual=True, is_const=True, is_virtual=True)
   928     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::Disconnect(ns3::ObjectBase * obj, std::string context, ns3::CallbackBase const & cb) const [member function]
   929     cls.add_method('Disconnect', 
   930                    'bool', 
   931                    [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')], 
   932                    is_pure_virtual=True, is_const=True, is_virtual=True)
   933     return
   934 
   935 def register_Ns3TriangularVariable_methods(root_module, cls):
   936     ## random-variable.h: ns3::TriangularVariable::TriangularVariable(ns3::TriangularVariable const & arg0) [copy constructor]
   937     cls.add_constructor([param('ns3::TriangularVariable const &', 'arg0')])
   938     ## random-variable.h: ns3::TriangularVariable::TriangularVariable() [constructor]
   939     cls.add_constructor([])
   940     ## random-variable.h: ns3::TriangularVariable::TriangularVariable(double s, double l, double mean) [constructor]
   941     cls.add_constructor([param('double', 's'), param('double', 'l'), param('double', 'mean')])
   942     return
   943 
   944 def register_Ns3TypeId_methods(root_module, cls):
   945     cls.add_binary_comparison_operator('!=')
   946     cls.add_binary_comparison_operator('<')
   947     cls.add_output_stream_operator()
   948     cls.add_binary_comparison_operator('==')
   949     ## type-id.h: ns3::TypeId::TypeId(char const * name) [constructor]
   950     cls.add_constructor([param('char const *', 'name')])
   951     ## type-id.h: ns3::TypeId::TypeId() [constructor]
   952     cls.add_constructor([])
   953     ## type-id.h: ns3::TypeId::TypeId(ns3::TypeId const & o) [copy constructor]
   954     cls.add_constructor([param('ns3::TypeId const &', 'o')])
   955     ## 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]
   956     cls.add_method('AddAttribute', 
   957                    'ns3::TypeId', 
   958                    [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')])
   959     ## 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]
   960     cls.add_method('AddAttribute', 
   961                    'ns3::TypeId', 
   962                    [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')])
   963     ## type-id.h: ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr<ns3::TraceSourceAccessor const> accessor) [member function]
   964     cls.add_method('AddTraceSource', 
   965                    'ns3::TypeId', 
   966                    [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')])
   967     ## type-id.h: ns3::Ptr<ns3::AttributeAccessor const> ns3::TypeId::GetAttributeAccessor(uint32_t i) const [member function]
   968     cls.add_method('GetAttributeAccessor', 
   969                    'ns3::Ptr< ns3::AttributeAccessor const >', 
   970                    [param('uint32_t', 'i')], 
   971                    is_const=True)
   972     ## type-id.h: ns3::Ptr<ns3::AttributeChecker const> ns3::TypeId::GetAttributeChecker(uint32_t i) const [member function]
   973     cls.add_method('GetAttributeChecker', 
   974                    'ns3::Ptr< ns3::AttributeChecker const >', 
   975                    [param('uint32_t', 'i')], 
   976                    is_const=True)
   977     ## type-id.h: uint32_t ns3::TypeId::GetAttributeFlags(uint32_t i) const [member function]
   978     cls.add_method('GetAttributeFlags', 
   979                    'uint32_t', 
   980                    [param('uint32_t', 'i')], 
   981                    is_const=True)
   982     ## type-id.h: std::string ns3::TypeId::GetAttributeFullName(uint32_t i) const [member function]
   983     cls.add_method('GetAttributeFullName', 
   984                    'std::string', 
   985                    [param('uint32_t', 'i')], 
   986                    is_const=True)
   987     ## type-id.h: std::string ns3::TypeId::GetAttributeHelp(uint32_t i) const [member function]
   988     cls.add_method('GetAttributeHelp', 
   989                    'std::string', 
   990                    [param('uint32_t', 'i')], 
   991                    is_const=True)
   992     ## type-id.h: ns3::Ptr<ns3::AttributeValue const> ns3::TypeId::GetAttributeInitialValue(uint32_t i) const [member function]
   993     cls.add_method('GetAttributeInitialValue', 
   994                    'ns3::Ptr< ns3::AttributeValue const >', 
   995                    [param('uint32_t', 'i')], 
   996                    is_const=True)
   997     ## type-id.h: uint32_t ns3::TypeId::GetAttributeN() const [member function]
   998     cls.add_method('GetAttributeN', 
   999                    'uint32_t', 
  1000                    [], 
  1001                    is_const=True)
  1002     ## type-id.h: std::string ns3::TypeId::GetAttributeName(uint32_t i) const [member function]
  1003     cls.add_method('GetAttributeName', 
  1004                    'std::string', 
  1005                    [param('uint32_t', 'i')], 
  1006                    is_const=True)
  1007     ## type-id.h: ns3::Callback<ns3::ObjectBase*,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ns3::TypeId::GetConstructor() const [member function]
  1008     cls.add_method('GetConstructor', 
  1009                    'ns3::Callback< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 
  1010                    [], 
  1011                    is_const=True)
  1012     ## type-id.h: std::string ns3::TypeId::GetGroupName() const [member function]
  1013     cls.add_method('GetGroupName', 
  1014                    'std::string', 
  1015                    [], 
  1016                    is_const=True)
  1017     ## type-id.h: std::string ns3::TypeId::GetName() const [member function]
  1018     cls.add_method('GetName', 
  1019                    'std::string', 
  1020                    [], 
  1021                    is_const=True)
  1022     ## type-id.h: ns3::TypeId ns3::TypeId::GetParent() const [member function]
  1023     cls.add_method('GetParent', 
  1024                    'ns3::TypeId', 
  1025                    [], 
  1026                    is_const=True)
  1027     ## type-id.h: static ns3::TypeId ns3::TypeId::GetRegistered(uint32_t i) [member function]
  1028     cls.add_method('GetRegistered', 
  1029                    'ns3::TypeId', 
  1030                    [param('uint32_t', 'i')], 
  1031                    is_static=True)
  1032     ## type-id.h: static uint32_t ns3::TypeId::GetRegisteredN() [member function]
  1033     cls.add_method('GetRegisteredN', 
  1034                    'uint32_t', 
  1035                    [], 
  1036                    is_static=True)
  1037     ## type-id.h: ns3::Ptr<ns3::TraceSourceAccessor const> ns3::TypeId::GetTraceSourceAccessor(uint32_t i) const [member function]
  1038     cls.add_method('GetTraceSourceAccessor', 
  1039                    'ns3::Ptr< ns3::TraceSourceAccessor const >', 
  1040                    [param('uint32_t', 'i')], 
  1041                    is_const=True)
  1042     ## type-id.h: std::string ns3::TypeId::GetTraceSourceHelp(uint32_t i) const [member function]
  1043     cls.add_method('GetTraceSourceHelp', 
  1044                    'std::string', 
  1045                    [param('uint32_t', 'i')], 
  1046                    is_const=True)
  1047     ## type-id.h: uint32_t ns3::TypeId::GetTraceSourceN() const [member function]
  1048     cls.add_method('GetTraceSourceN', 
  1049                    'uint32_t', 
  1050                    [], 
  1051                    is_const=True)
  1052     ## type-id.h: std::string ns3::TypeId::GetTraceSourceName(uint32_t i) const [member function]
  1053     cls.add_method('GetTraceSourceName', 
  1054                    'std::string', 
  1055                    [param('uint32_t', 'i')], 
  1056                    is_const=True)
  1057     ## type-id.h: uint16_t ns3::TypeId::GetUid() const [member function]
  1058     cls.add_method('GetUid', 
  1059                    'uint16_t', 
  1060                    [], 
  1061                    is_const=True)
  1062     ## type-id.h: bool ns3::TypeId::HasConstructor() const [member function]
  1063     cls.add_method('HasConstructor', 
  1064                    'bool', 
  1065                    [], 
  1066                    is_const=True)
  1067     ## type-id.h: bool ns3::TypeId::HasParent() const [member function]
  1068     cls.add_method('HasParent', 
  1069                    'bool', 
  1070                    [], 
  1071                    is_const=True)
  1072     ## type-id.h: ns3::TypeId ns3::TypeId::HideFromDocumentation() [member function]
  1073     cls.add_method('HideFromDocumentation', 
  1074                    'ns3::TypeId', 
  1075                    [])
  1076     ## type-id.h: bool ns3::TypeId::IsChildOf(ns3::TypeId other) const [member function]
  1077     cls.add_method('IsChildOf', 
  1078                    'bool', 
  1079                    [param('ns3::TypeId', 'other')], 
  1080                    is_const=True)
  1081     ## type-id.h: static bool ns3::TypeId::LookupAttributeByFullName(std::string fullName, ns3::TypeId::AttributeInfo * info) [member function]
  1082     cls.add_method('LookupAttributeByFullName', 
  1083                    'bool', 
  1084                    [param('std::string', 'fullName'), param('ns3::TypeId::AttributeInfo *', 'info')], 
  1085                    is_static=True)
  1086     ## type-id.h: bool ns3::TypeId::LookupAttributeByName(std::string name, ns3::TypeId::AttributeInfo * info) const [member function]
  1087     cls.add_method('LookupAttributeByName', 
  1088                    'bool', 
  1089                    [param('std::string', 'name'), param('ns3::TypeId::AttributeInfo *', 'info', transfer_ownership=False)], 
  1090                    is_const=True)
  1091     ## type-id.h: static ns3::TypeId ns3::TypeId::LookupByName(std::string name) [member function]
  1092     cls.add_method('LookupByName', 
  1093                    'ns3::TypeId', 
  1094                    [param('std::string', 'name')], 
  1095                    is_static=True)
  1096     ## type-id.h: ns3::Ptr<ns3::TraceSourceAccessor const> ns3::TypeId::LookupTraceSourceByName(std::string name) const [member function]
  1097     cls.add_method('LookupTraceSourceByName', 
  1098                    'ns3::Ptr< ns3::TraceSourceAccessor const >', 
  1099                    [param('std::string', 'name')], 
  1100                    is_const=True)
  1101     ## type-id.h: bool ns3::TypeId::MustHideFromDocumentation() const [member function]
  1102     cls.add_method('MustHideFromDocumentation', 
  1103                    'bool', 
  1104                    [], 
  1105                    is_const=True)
  1106     ## type-id.h: ns3::TypeId ns3::TypeId::SetGroupName(std::string groupName) [member function]
  1107     cls.add_method('SetGroupName', 
  1108                    'ns3::TypeId', 
  1109                    [param('std::string', 'groupName')])
  1110     ## type-id.h: ns3::TypeId ns3::TypeId::SetParent(ns3::TypeId tid) [member function]
  1111     cls.add_method('SetParent', 
  1112                    'ns3::TypeId', 
  1113                    [param('ns3::TypeId', 'tid')])
  1114     ## type-id.h: void ns3::TypeId::SetUid(uint16_t tid) [member function]
  1115     cls.add_method('SetUid', 
  1116                    'void', 
  1117                    [param('uint16_t', 'tid')])
  1118     return
  1119 
  1120 def register_Ns3TypeIdAttributeInfo_methods(root_module, cls):
  1121     ## type-id.h: ns3::TypeId::AttributeInfo::accessor [variable]
  1122     cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::AttributeAccessor const >', is_const=False)
  1123     ## type-id.h: ns3::TypeId::AttributeInfo::initialValue [variable]
  1124     cls.add_instance_attribute('initialValue', 'ns3::Ptr< ns3::AttributeValue const >', is_const=False)
  1125     ## type-id.h: ns3::TypeId::AttributeInfo::flags [variable]
  1126     cls.add_instance_attribute('flags', 'uint32_t', is_const=False)
  1127     ## type-id.h: ns3::TypeId::AttributeInfo::checker [variable]
  1128     cls.add_instance_attribute('checker', 'ns3::Ptr< ns3::AttributeChecker const >', is_const=False)
  1129     ## type-id.h: ns3::TypeId::AttributeInfo::AttributeInfo(ns3::TypeId::AttributeInfo const & arg0) [copy constructor]
  1130     cls.add_constructor([param('ns3::TypeId::AttributeInfo const &', 'arg0')])
  1131     ## type-id.h: ns3::TypeId::AttributeInfo::AttributeInfo() [constructor]
  1132     cls.add_constructor([])
  1133     return
  1134 
  1135 def register_Ns3UniformVariable_methods(root_module, cls):
  1136     ## random-variable.h: ns3::UniformVariable::UniformVariable(ns3::UniformVariable const & arg0) [copy constructor]
  1137     cls.add_constructor([param('ns3::UniformVariable const &', 'arg0')])
  1138     ## random-variable.h: ns3::UniformVariable::UniformVariable() [constructor]
  1139     cls.add_constructor([])
  1140     ## random-variable.h: ns3::UniformVariable::UniformVariable(double s, double l) [constructor]
  1141     cls.add_constructor([param('double', 's'), param('double', 'l')])
  1142     ## random-variable.h: double ns3::UniformVariable::GetValue() const [member function]
  1143     cls.add_method('GetValue', 
  1144                    'double', 
  1145                    [], 
  1146                    is_const=True)
  1147     ## random-variable.h: double ns3::UniformVariable::GetValue(double s, double l) [member function]
  1148     cls.add_method('GetValue', 
  1149                    'double', 
  1150                    [param('double', 's'), param('double', 'l')])
  1151     ## random-variable.h: uint32_t ns3::UniformVariable::GetInteger(uint32_t s, uint32_t l) [member function]
  1152     cls.add_method('GetInteger', 
  1153                    'uint32_t', 
  1154                    [param('uint32_t', 's'), param('uint32_t', 'l')])
  1155     return
  1156 
  1157 def register_Ns3UnsafeAttributeList_methods(root_module, cls):
  1158     ## attribute-list.h: ns3::UnsafeAttributeList::UnsafeAttributeList() [constructor]
  1159     cls.add_constructor([])
  1160     ## attribute-list.h: ns3::UnsafeAttributeList::UnsafeAttributeList(ns3::UnsafeAttributeList const & o) [copy constructor]
  1161     cls.add_constructor([param('ns3::UnsafeAttributeList const &', 'o')])
  1162     ## attribute-list.h: void ns3::UnsafeAttributeList::Set(std::string name, ns3::AttributeValue const & param) [member function]
  1163     cls.add_method('Set', 
  1164                    'void', 
  1165                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'param')])
  1166     ## attribute-list.h: ns3::AttributeList ns3::UnsafeAttributeList::GetSafe(std::string name) const [member function]
  1167     cls.add_method('GetSafe', 
  1168                    'ns3::AttributeList', 
  1169                    [param('std::string', 'name')], 
  1170                    is_const=True)
  1171     return
  1172 
  1173 def register_Ns3WeibullVariable_methods(root_module, cls):
  1174     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(ns3::WeibullVariable const & arg0) [copy constructor]
  1175     cls.add_constructor([param('ns3::WeibullVariable const &', 'arg0')])
  1176     ## random-variable.h: ns3::WeibullVariable::WeibullVariable() [constructor]
  1177     cls.add_constructor([])
  1178     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(double m) [constructor]
  1179     cls.add_constructor([param('double', 'm')])
  1180     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(double m, double s) [constructor]
  1181     cls.add_constructor([param('double', 'm'), param('double', 's')])
  1182     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(double m, double s, double b) [constructor]
  1183     cls.add_constructor([param('double', 'm'), param('double', 's'), param('double', 'b')])
  1184     return
  1185 
  1186 def register_Ns3ZipfVariable_methods(root_module, cls):
  1187     ## random-variable.h: ns3::ZipfVariable::ZipfVariable(ns3::ZipfVariable const & arg0) [copy constructor]
  1188     cls.add_constructor([param('ns3::ZipfVariable const &', 'arg0')])
  1189     ## random-variable.h: ns3::ZipfVariable::ZipfVariable(long int n, double alpha) [constructor]
  1190     cls.add_constructor([param('long int', 'n'), param('double', 'alpha')])
  1191     ## random-variable.h: ns3::ZipfVariable::ZipfVariable() [constructor]
  1192     cls.add_constructor([])
  1193     return
  1194 
  1195 def register_Ns3Empty_methods(root_module, cls):
  1196     ## empty.h: ns3::empty::empty(ns3::empty const & arg0) [copy constructor]
  1197     cls.add_constructor([param('ns3::empty const &', 'arg0')])
  1198     ## empty.h: ns3::empty::empty() [constructor]
  1199     cls.add_constructor([])
  1200     return
  1201 
  1202 def register_Ns3AttributeAccessor_methods(root_module, cls):
  1203     ## attribute.h: ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [copy constructor]
  1204     cls.add_constructor([param('ns3::AttributeAccessor const &', 'arg0')])
  1205     ## attribute.h: ns3::AttributeAccessor::AttributeAccessor() [constructor]
  1206     cls.add_constructor([])
  1207     ## attribute.h: bool ns3::AttributeAccessor::Set(ns3::ObjectBase * object, ns3::AttributeValue const & value) const [member function]
  1208     cls.add_method('Set', 
  1209                    'bool', 
  1210                    [param('ns3::ObjectBase *', 'object', transfer_ownership=False), param('ns3::AttributeValue const &', 'value')], 
  1211                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1212     ## attribute.h: bool ns3::AttributeAccessor::Get(ns3::ObjectBase const * object, ns3::AttributeValue & attribute) const [member function]
  1213     cls.add_method('Get', 
  1214                    'bool', 
  1215                    [param('ns3::ObjectBase const *', 'object'), param('ns3::AttributeValue &', 'attribute')], 
  1216                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1217     ## attribute.h: bool ns3::AttributeAccessor::HasGetter() const [member function]
  1218     cls.add_method('HasGetter', 
  1219                    'bool', 
  1220                    [], 
  1221                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1222     ## attribute.h: bool ns3::AttributeAccessor::HasSetter() const [member function]
  1223     cls.add_method('HasSetter', 
  1224                    'bool', 
  1225                    [], 
  1226                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1227     return
  1228 
  1229 def register_Ns3AttributeChecker_methods(root_module, cls):
  1230     ## attribute.h: ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [copy constructor]
  1231     cls.add_constructor([param('ns3::AttributeChecker const &', 'arg0')])
  1232     ## attribute.h: ns3::AttributeChecker::AttributeChecker() [constructor]
  1233     cls.add_constructor([])
  1234     ## attribute.h: bool ns3::AttributeChecker::Check(ns3::AttributeValue const & value) const [member function]
  1235     cls.add_method('Check', 
  1236                    'bool', 
  1237                    [param('ns3::AttributeValue const &', 'value')], 
  1238                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1239     ## attribute.h: std::string ns3::AttributeChecker::GetValueTypeName() const [member function]
  1240     cls.add_method('GetValueTypeName', 
  1241                    'std::string', 
  1242                    [], 
  1243                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1244     ## attribute.h: bool ns3::AttributeChecker::HasUnderlyingTypeInformation() const [member function]
  1245     cls.add_method('HasUnderlyingTypeInformation', 
  1246                    'bool', 
  1247                    [], 
  1248                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1249     ## attribute.h: std::string ns3::AttributeChecker::GetUnderlyingTypeInformation() const [member function]
  1250     cls.add_method('GetUnderlyingTypeInformation', 
  1251                    'std::string', 
  1252                    [], 
  1253                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1254     ## attribute.h: ns3::Ptr<ns3::AttributeValue> ns3::AttributeChecker::Create() const [member function]
  1255     cls.add_method('Create', 
  1256                    'ns3::Ptr< ns3::AttributeValue >', 
  1257                    [], 
  1258                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1259     ## attribute.h: bool ns3::AttributeChecker::Copy(ns3::AttributeValue const & source, ns3::AttributeValue & destination) const [member function]
  1260     cls.add_method('Copy', 
  1261                    'bool', 
  1262                    [param('ns3::AttributeValue const &', 'source'), param('ns3::AttributeValue &', 'destination')], 
  1263                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1264     return
  1265 
  1266 def register_Ns3AttributeValue_methods(root_module, cls):
  1267     ## attribute.h: ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [copy constructor]
  1268     cls.add_constructor([param('ns3::AttributeValue const &', 'arg0')])
  1269     ## attribute.h: ns3::AttributeValue::AttributeValue() [constructor]
  1270     cls.add_constructor([])
  1271     ## attribute.h: ns3::Ptr<ns3::AttributeValue> ns3::AttributeValue::Copy() const [member function]
  1272     cls.add_method('Copy', 
  1273                    'ns3::Ptr< ns3::AttributeValue >', 
  1274                    [], 
  1275                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1276     ## attribute.h: std::string ns3::AttributeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1277     cls.add_method('SerializeToString', 
  1278                    'std::string', 
  1279                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1280                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1281     ## attribute.h: bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1282     cls.add_method('DeserializeFromString', 
  1283                    'bool', 
  1284                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1285                    is_pure_virtual=True, is_virtual=True)
  1286     return
  1287 
  1288 def register_Ns3BooleanChecker_methods(root_module, cls):
  1289     ## boolean.h: ns3::BooleanChecker::BooleanChecker(ns3::BooleanChecker const & arg0) [copy constructor]
  1290     cls.add_constructor([param('ns3::BooleanChecker const &', 'arg0')])
  1291     ## boolean.h: ns3::BooleanChecker::BooleanChecker() [constructor]
  1292     cls.add_constructor([])
  1293     return
  1294 
  1295 def register_Ns3BooleanValue_methods(root_module, cls):
  1296     cls.add_output_stream_operator()
  1297     ## boolean.h: ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [copy constructor]
  1298     cls.add_constructor([param('ns3::BooleanValue const &', 'arg0')])
  1299     ## boolean.h: ns3::BooleanValue::BooleanValue() [constructor]
  1300     cls.add_constructor([])
  1301     ## boolean.h: ns3::BooleanValue::BooleanValue(bool value) [constructor]
  1302     cls.add_constructor([param('bool', 'value')])
  1303     ## boolean.h: ns3::Ptr<ns3::AttributeValue> ns3::BooleanValue::Copy() const [member function]
  1304     cls.add_method('Copy', 
  1305                    'ns3::Ptr< ns3::AttributeValue >', 
  1306                    [], 
  1307                    is_const=True, is_virtual=True)
  1308     ## boolean.h: bool ns3::BooleanValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1309     cls.add_method('DeserializeFromString', 
  1310                    'bool', 
  1311                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1312                    is_virtual=True)
  1313     ## boolean.h: bool ns3::BooleanValue::Get() const [member function]
  1314     cls.add_method('Get', 
  1315                    'bool', 
  1316                    [], 
  1317                    is_const=True)
  1318     ## boolean.h: std::string ns3::BooleanValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1319     cls.add_method('SerializeToString', 
  1320                    'std::string', 
  1321                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1322                    is_const=True, is_virtual=True)
  1323     ## boolean.h: void ns3::BooleanValue::Set(bool value) [member function]
  1324     cls.add_method('Set', 
  1325                    'void', 
  1326                    [param('bool', 'value')])
  1327     return
  1328 
  1329 def register_Ns3CallbackChecker_methods(root_module, cls):
  1330     ## callback.h: ns3::CallbackChecker::CallbackChecker(ns3::CallbackChecker const & arg0) [copy constructor]
  1331     cls.add_constructor([param('ns3::CallbackChecker const &', 'arg0')])
  1332     ## callback.h: ns3::CallbackChecker::CallbackChecker() [constructor]
  1333     cls.add_constructor([])
  1334     return
  1335 
  1336 def register_Ns3CallbackValue_methods(root_module, cls):
  1337     ## callback.h: ns3::CallbackValue::CallbackValue(ns3::CallbackValue const & arg0) [copy constructor]
  1338     cls.add_constructor([param('ns3::CallbackValue const &', 'arg0')])
  1339     ## callback.h: ns3::CallbackValue::CallbackValue() [constructor]
  1340     cls.add_constructor([])
  1341     ## callback.h: ns3::CallbackValue::CallbackValue(ns3::CallbackBase const & base) [constructor]
  1342     cls.add_constructor([param('ns3::CallbackBase const &', 'base')])
  1343     ## callback.h: void ns3::CallbackValue::Set(ns3::CallbackBase base) [member function]
  1344     cls.add_method('Set', 
  1345                    'void', 
  1346                    [param('ns3::CallbackBase', 'base')])
  1347     ## callback.h: ns3::Ptr<ns3::AttributeValue> ns3::CallbackValue::Copy() const [member function]
  1348     cls.add_method('Copy', 
  1349                    'ns3::Ptr< ns3::AttributeValue >', 
  1350                    [], 
  1351                    is_const=True, is_virtual=True)
  1352     ## callback.h: std::string ns3::CallbackValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1353     cls.add_method('SerializeToString', 
  1354                    'std::string', 
  1355                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1356                    is_const=True, is_virtual=True)
  1357     ## callback.h: bool ns3::CallbackValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1358     cls.add_method('DeserializeFromString', 
  1359                    'bool', 
  1360                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1361                    is_virtual=True)
  1362     return
  1363 
  1364 def register_Ns3ConstantVariable_methods(root_module, cls):
  1365     ## random-variable.h: ns3::ConstantVariable::ConstantVariable(ns3::ConstantVariable const & arg0) [copy constructor]
  1366     cls.add_constructor([param('ns3::ConstantVariable const &', 'arg0')])
  1367     ## random-variable.h: ns3::ConstantVariable::ConstantVariable() [constructor]
  1368     cls.add_constructor([])
  1369     ## random-variable.h: ns3::ConstantVariable::ConstantVariable(double c) [constructor]
  1370     cls.add_constructor([param('double', 'c')])
  1371     ## random-variable.h: void ns3::ConstantVariable::SetConstant(double c) [member function]
  1372     cls.add_method('SetConstant', 
  1373                    'void', 
  1374                    [param('double', 'c')])
  1375     return
  1376 
  1377 def register_Ns3DeterministicVariable_methods(root_module, cls):
  1378     ## random-variable.h: ns3::DeterministicVariable::DeterministicVariable(ns3::DeterministicVariable const & arg0) [copy constructor]
  1379     cls.add_constructor([param('ns3::DeterministicVariable const &', 'arg0')])
  1380     ## random-variable.h: ns3::DeterministicVariable::DeterministicVariable(double * d, uint32_t c) [constructor]
  1381     cls.add_constructor([param('double *', 'd'), param('uint32_t', 'c')])
  1382     return
  1383 
  1384 def register_Ns3DoubleValue_methods(root_module, cls):
  1385     ## double.h: ns3::DoubleValue::DoubleValue(ns3::DoubleValue const & arg0) [copy constructor]
  1386     cls.add_constructor([param('ns3::DoubleValue const &', 'arg0')])
  1387     ## double.h: ns3::DoubleValue::DoubleValue() [constructor]
  1388     cls.add_constructor([])
  1389     ## double.h: ns3::DoubleValue::DoubleValue(double const & value) [constructor]
  1390     cls.add_constructor([param('double const &', 'value')])
  1391     ## double.h: void ns3::DoubleValue::Set(double const & value) [member function]
  1392     cls.add_method('Set', 
  1393                    'void', 
  1394                    [param('double const &', 'value')])
  1395     ## double.h: double ns3::DoubleValue::Get() const [member function]
  1396     cls.add_method('Get', 
  1397                    'double', 
  1398                    [], 
  1399                    is_const=True)
  1400     ## double.h: ns3::Ptr<ns3::AttributeValue> ns3::DoubleValue::Copy() const [member function]
  1401     cls.add_method('Copy', 
  1402                    'ns3::Ptr< ns3::AttributeValue >', 
  1403                    [], 
  1404                    is_const=True, is_virtual=True)
  1405     ## double.h: std::string ns3::DoubleValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1406     cls.add_method('SerializeToString', 
  1407                    'std::string', 
  1408                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1409                    is_const=True, is_virtual=True)
  1410     ## double.h: bool ns3::DoubleValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1411     cls.add_method('DeserializeFromString', 
  1412                    'bool', 
  1413                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1414                    is_virtual=True)
  1415     return
  1416 
  1417 def register_Ns3EmpiricalVariable_methods(root_module, cls):
  1418     ## random-variable.h: ns3::EmpiricalVariable::EmpiricalVariable(ns3::EmpiricalVariable const & arg0) [copy constructor]
  1419     cls.add_constructor([param('ns3::EmpiricalVariable const &', 'arg0')])
  1420     ## random-variable.h: ns3::EmpiricalVariable::EmpiricalVariable() [constructor]
  1421     cls.add_constructor([])
  1422     ## random-variable.h: void ns3::EmpiricalVariable::CDF(double v, double c) [member function]
  1423     cls.add_method('CDF', 
  1424                    'void', 
  1425                    [param('double', 'v'), param('double', 'c')])
  1426     return
  1427 
  1428 def register_Ns3EmptyAttributeValue_methods(root_module, cls):
  1429     ## attribute.h: ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [copy constructor]
  1430     cls.add_constructor([param('ns3::EmptyAttributeValue const &', 'arg0')])
  1431     ## attribute.h: ns3::EmptyAttributeValue::EmptyAttributeValue() [constructor]
  1432     cls.add_constructor([])
  1433     ## attribute.h: ns3::Ptr<ns3::AttributeValue> ns3::EmptyAttributeValue::Copy() const [member function]
  1434     cls.add_method('Copy', 
  1435                    'ns3::Ptr< ns3::AttributeValue >', 
  1436                    [], 
  1437                    is_const=True, visibility='private', is_virtual=True)
  1438     ## attribute.h: std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1439     cls.add_method('SerializeToString', 
  1440                    'std::string', 
  1441                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1442                    is_const=True, visibility='private', is_virtual=True)
  1443     ## attribute.h: bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1444     cls.add_method('DeserializeFromString', 
  1445                    'bool', 
  1446                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1447                    visibility='private', is_virtual=True)
  1448     return
  1449 
  1450 def register_Ns3EnumChecker_methods(root_module, cls):
  1451     ## enum.h: ns3::EnumChecker::EnumChecker(ns3::EnumChecker const & arg0) [copy constructor]
  1452     cls.add_constructor([param('ns3::EnumChecker const &', 'arg0')])
  1453     ## enum.h: ns3::EnumChecker::EnumChecker() [constructor]
  1454     cls.add_constructor([])
  1455     ## enum.h: void ns3::EnumChecker::AddDefault(int v, std::string name) [member function]
  1456     cls.add_method('AddDefault', 
  1457                    'void', 
  1458                    [param('int', 'v'), param('std::string', 'name')])
  1459     ## enum.h: void ns3::EnumChecker::Add(int v, std::string name) [member function]
  1460     cls.add_method('Add', 
  1461                    'void', 
  1462                    [param('int', 'v'), param('std::string', 'name')])
  1463     ## enum.h: bool ns3::EnumChecker::Check(ns3::AttributeValue const & value) const [member function]
  1464     cls.add_method('Check', 
  1465                    'bool', 
  1466                    [param('ns3::AttributeValue const &', 'value')], 
  1467                    is_const=True, is_virtual=True)
  1468     ## enum.h: std::string ns3::EnumChecker::GetValueTypeName() const [member function]
  1469     cls.add_method('GetValueTypeName', 
  1470                    'std::string', 
  1471                    [], 
  1472                    is_const=True, is_virtual=True)
  1473     ## enum.h: bool ns3::EnumChecker::HasUnderlyingTypeInformation() const [member function]
  1474     cls.add_method('HasUnderlyingTypeInformation', 
  1475                    'bool', 
  1476                    [], 
  1477                    is_const=True, is_virtual=True)
  1478     ## enum.h: std::string ns3::EnumChecker::GetUnderlyingTypeInformation() const [member function]
  1479     cls.add_method('GetUnderlyingTypeInformation', 
  1480                    'std::string', 
  1481                    [], 
  1482                    is_const=True, is_virtual=True)
  1483     ## enum.h: ns3::Ptr<ns3::AttributeValue> ns3::EnumChecker::Create() const [member function]
  1484     cls.add_method('Create', 
  1485                    'ns3::Ptr< ns3::AttributeValue >', 
  1486                    [], 
  1487                    is_const=True, is_virtual=True)
  1488     ## enum.h: bool ns3::EnumChecker::Copy(ns3::AttributeValue const & src, ns3::AttributeValue & dst) const [member function]
  1489     cls.add_method('Copy', 
  1490                    'bool', 
  1491                    [param('ns3::AttributeValue const &', 'src'), param('ns3::AttributeValue &', 'dst')], 
  1492                    is_const=True, is_virtual=True)
  1493     return
  1494 
  1495 def register_Ns3EnumValue_methods(root_module, cls):
  1496     ## enum.h: ns3::EnumValue::EnumValue(ns3::EnumValue const & arg0) [copy constructor]
  1497     cls.add_constructor([param('ns3::EnumValue const &', 'arg0')])
  1498     ## enum.h: ns3::EnumValue::EnumValue() [constructor]
  1499     cls.add_constructor([])
  1500     ## enum.h: ns3::EnumValue::EnumValue(int v) [constructor]
  1501     cls.add_constructor([param('int', 'v')])
  1502     ## enum.h: void ns3::EnumValue::Set(int v) [member function]
  1503     cls.add_method('Set', 
  1504                    'void', 
  1505                    [param('int', 'v')])
  1506     ## enum.h: int ns3::EnumValue::Get() const [member function]
  1507     cls.add_method('Get', 
  1508                    'int', 
  1509                    [], 
  1510                    is_const=True)
  1511     ## enum.h: ns3::Ptr<ns3::AttributeValue> ns3::EnumValue::Copy() const [member function]
  1512     cls.add_method('Copy', 
  1513                    'ns3::Ptr< ns3::AttributeValue >', 
  1514                    [], 
  1515                    is_const=True, is_virtual=True)
  1516     ## enum.h: std::string ns3::EnumValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1517     cls.add_method('SerializeToString', 
  1518                    'std::string', 
  1519                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1520                    is_const=True, is_virtual=True)
  1521     ## enum.h: bool ns3::EnumValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1522     cls.add_method('DeserializeFromString', 
  1523                    'bool', 
  1524                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1525                    is_virtual=True)
  1526     return
  1527 
  1528 def register_Ns3ErlangVariable_methods(root_module, cls):
  1529     ## random-variable.h: ns3::ErlangVariable::ErlangVariable(ns3::ErlangVariable const & arg0) [copy constructor]
  1530     cls.add_constructor([param('ns3::ErlangVariable const &', 'arg0')])
  1531     ## random-variable.h: ns3::ErlangVariable::ErlangVariable() [constructor]
  1532     cls.add_constructor([])
  1533     ## random-variable.h: ns3::ErlangVariable::ErlangVariable(unsigned int k, double lambda) [constructor]
  1534     cls.add_constructor([param('unsigned int', 'k'), param('double', 'lambda')])
  1535     ## random-variable.h: double ns3::ErlangVariable::GetValue() const [member function]
  1536     cls.add_method('GetValue', 
  1537                    'double', 
  1538                    [], 
  1539                    is_const=True)
  1540     ## random-variable.h: double ns3::ErlangVariable::GetValue(unsigned int k, double lambda) const [member function]
  1541     cls.add_method('GetValue', 
  1542                    'double', 
  1543                    [param('unsigned int', 'k'), param('double', 'lambda')], 
  1544                    is_const=True)
  1545     return
  1546 
  1547 def register_Ns3ExponentialVariable_methods(root_module, cls):
  1548     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable(ns3::ExponentialVariable const & arg0) [copy constructor]
  1549     cls.add_constructor([param('ns3::ExponentialVariable const &', 'arg0')])
  1550     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable() [constructor]
  1551     cls.add_constructor([])
  1552     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable(double m) [constructor]
  1553     cls.add_constructor([param('double', 'm')])
  1554     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable(double m, double b) [constructor]
  1555     cls.add_constructor([param('double', 'm'), param('double', 'b')])
  1556     return
  1557 
  1558 def register_Ns3GammaVariable_methods(root_module, cls):
  1559     ## random-variable.h: ns3::GammaVariable::GammaVariable(ns3::GammaVariable const & arg0) [copy constructor]
  1560     cls.add_constructor([param('ns3::GammaVariable const &', 'arg0')])
  1561     ## random-variable.h: ns3::GammaVariable::GammaVariable() [constructor]
  1562     cls.add_constructor([])
  1563     ## random-variable.h: ns3::GammaVariable::GammaVariable(double alpha, double beta) [constructor]
  1564     cls.add_constructor([param('double', 'alpha'), param('double', 'beta')])
  1565     ## random-variable.h: double ns3::GammaVariable::GetValue() const [member function]
  1566     cls.add_method('GetValue', 
  1567                    'double', 
  1568                    [], 
  1569                    is_const=True)
  1570     ## random-variable.h: double ns3::GammaVariable::GetValue(double alpha, double beta) const [member function]
  1571     cls.add_method('GetValue', 
  1572                    'double', 
  1573                    [param('double', 'alpha'), param('double', 'beta')], 
  1574                    is_const=True)
  1575     return
  1576 
  1577 def register_Ns3IntEmpiricalVariable_methods(root_module, cls):
  1578     ## random-variable.h: ns3::IntEmpiricalVariable::IntEmpiricalVariable(ns3::IntEmpiricalVariable const & arg0) [copy constructor]
  1579     cls.add_constructor([param('ns3::IntEmpiricalVariable const &', 'arg0')])
  1580     ## random-variable.h: ns3::IntEmpiricalVariable::IntEmpiricalVariable() [constructor]
  1581     cls.add_constructor([])
  1582     return
  1583 
  1584 def register_Ns3IntegerValue_methods(root_module, cls):
  1585     ## integer.h: ns3::IntegerValue::IntegerValue(ns3::IntegerValue const & arg0) [copy constructor]
  1586     cls.add_constructor([param('ns3::IntegerValue const &', 'arg0')])
  1587     ## integer.h: ns3::IntegerValue::IntegerValue() [constructor]
  1588     cls.add_constructor([])
  1589     ## integer.h: ns3::IntegerValue::IntegerValue(int64_t const & value) [constructor]
  1590     cls.add_constructor([param('int64_t const &', 'value')])
  1591     ## integer.h: void ns3::IntegerValue::Set(int64_t const & value) [member function]
  1592     cls.add_method('Set', 
  1593                    'void', 
  1594                    [param('int64_t const &', 'value')])
  1595     ## integer.h: int64_t ns3::IntegerValue::Get() const [member function]
  1596     cls.add_method('Get', 
  1597                    'int64_t', 
  1598                    [], 
  1599                    is_const=True)
  1600     ## integer.h: ns3::Ptr<ns3::AttributeValue> ns3::IntegerValue::Copy() const [member function]
  1601     cls.add_method('Copy', 
  1602                    'ns3::Ptr< ns3::AttributeValue >', 
  1603                    [], 
  1604                    is_const=True, is_virtual=True)
  1605     ## integer.h: std::string ns3::IntegerValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1606     cls.add_method('SerializeToString', 
  1607                    'std::string', 
  1608                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1609                    is_const=True, is_virtual=True)
  1610     ## integer.h: bool ns3::IntegerValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1611     cls.add_method('DeserializeFromString', 
  1612                    'bool', 
  1613                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1614                    is_virtual=True)
  1615     return
  1616 
  1617 def register_Ns3LogNormalVariable_methods(root_module, cls):
  1618     ## random-variable.h: ns3::LogNormalVariable::LogNormalVariable(ns3::LogNormalVariable const & arg0) [copy constructor]
  1619     cls.add_constructor([param('ns3::LogNormalVariable const &', 'arg0')])
  1620     ## random-variable.h: ns3::LogNormalVariable::LogNormalVariable(double mu, double sigma) [constructor]
  1621     cls.add_constructor([param('double', 'mu'), param('double', 'sigma')])
  1622     return
  1623 
  1624 def register_Ns3NormalVariable_methods(root_module, cls):
  1625     ## random-variable.h: ns3::NormalVariable::NormalVariable(ns3::NormalVariable const & arg0) [copy constructor]
  1626     cls.add_constructor([param('ns3::NormalVariable const &', 'arg0')])
  1627     ## random-variable.h: ns3::NormalVariable::NormalVariable() [constructor]
  1628     cls.add_constructor([])
  1629     ## random-variable.h: ns3::NormalVariable::NormalVariable(double m, double v) [constructor]
  1630     cls.add_constructor([param('double', 'm'), param('double', 'v')])
  1631     ## random-variable.h: ns3::NormalVariable::NormalVariable(double m, double v, double b) [constructor]
  1632     cls.add_constructor([param('double', 'm'), param('double', 'v'), param('double', 'b')])
  1633     return
  1634 
  1635 def register_Ns3Object_methods(root_module, cls):
  1636     ## object.h: static ns3::TypeId ns3::Object::GetTypeId() [member function]
  1637     cls.add_method('GetTypeId', 
  1638                    'ns3::TypeId', 
  1639                    [], 
  1640                    is_static=True)
  1641     ## object.h: ns3::Object::Object() [constructor]
  1642     cls.add_constructor([])
  1643     ## object.h: ns3::TypeId ns3::Object::GetInstanceTypeId() const [member function]
  1644     cls.add_method('GetInstanceTypeId', 
  1645                    'ns3::TypeId', 
  1646                    [], 
  1647                    is_const=True, is_virtual=True)
  1648     ## object.h: ns3::Ptr<ns3::Object> ns3::Object::GetObject(ns3::TypeId tid) const [member function]
  1649     cls.add_method('GetObject', 
  1650                    'ns3::Ptr< ns3::Object >', 
  1651                    [param('ns3::TypeId', 'tid')], 
  1652                    is_const=True, template_parameters=['ns3::Object'], custom_template_method_name='GetObject')
  1653     ## object.h: void ns3::Object::Dispose() [member function]
  1654     cls.add_method('Dispose', 
  1655                    'void', 
  1656                    [])
  1657     ## object.h: void ns3::Object::AggregateObject(ns3::Ptr<ns3::Object> other) [member function]
  1658     cls.add_method('AggregateObject', 
  1659                    'void', 
  1660                    [param('ns3::Ptr< ns3::Object >', 'other')])
  1661     ## object.h: ns3::Object::AggregateIterator ns3::Object::GetAggregateIterator() const [member function]
  1662     cls.add_method('GetAggregateIterator', 
  1663                    'ns3::Object::AggregateIterator', 
  1664                    [], 
  1665                    is_const=True)
  1666     ## object.h: void ns3::Object::NotifyNewAggregate() [member function]
  1667     cls.add_method('NotifyNewAggregate', 
  1668                    'void', 
  1669                    [], 
  1670                    visibility='protected', is_virtual=True)
  1671     ## object.h: void ns3::Object::DoDispose() [member function]
  1672     cls.add_method('DoDispose', 
  1673                    'void', 
  1674                    [], 
  1675                    visibility='protected', is_virtual=True)
  1676     ## object.h: ns3::Object::Object(ns3::Object const & o) [copy constructor]
  1677     cls.add_constructor([param('ns3::Object const &', 'o')], 
  1678                         visibility='protected')
  1679     return
  1680 
  1681 def register_Ns3ObjectAggregateIterator_methods(root_module, cls):
  1682     ## object.h: ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [copy constructor]
  1683     cls.add_constructor([param('ns3::Object::AggregateIterator const &', 'arg0')])
  1684     ## object.h: ns3::Object::AggregateIterator::AggregateIterator() [constructor]
  1685     cls.add_constructor([])
  1686     ## object.h: bool ns3::Object::AggregateIterator::HasNext() const [member function]
  1687     cls.add_method('HasNext', 
  1688                    'bool', 
  1689                    [], 
  1690                    is_const=True)
  1691     ## object.h: ns3::Ptr<ns3::Object const> ns3::Object::AggregateIterator::Next() [member function]
  1692     cls.add_method('Next', 
  1693                    'ns3::Ptr< ns3::Object const >', 
  1694                    [])
  1695     return
  1696 
  1697 def register_Ns3ObjectFactoryChecker_methods(root_module, cls):
  1698     ## object-factory.h: ns3::ObjectFactoryChecker::ObjectFactoryChecker(ns3::ObjectFactoryChecker const & arg0) [copy constructor]
  1699     cls.add_constructor([param('ns3::ObjectFactoryChecker const &', 'arg0')])
  1700     ## object-factory.h: ns3::ObjectFactoryChecker::ObjectFactoryChecker() [constructor]
  1701     cls.add_constructor([])
  1702     return
  1703 
  1704 def register_Ns3ObjectFactoryValue_methods(root_module, cls):
  1705     ## object-factory.h: ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactoryValue const & arg0) [copy constructor]
  1706     cls.add_constructor([param('ns3::ObjectFactoryValue const &', 'arg0')])
  1707     ## object-factory.h: ns3::ObjectFactoryValue::ObjectFactoryValue() [constructor]
  1708     cls.add_constructor([])
  1709     ## object-factory.h: ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactory const & value) [constructor]
  1710     cls.add_constructor([param('ns3::ObjectFactory const &', 'value')])
  1711     ## object-factory.h: void ns3::ObjectFactoryValue::Set(ns3::ObjectFactory const & value) [member function]
  1712     cls.add_method('Set', 
  1713                    'void', 
  1714                    [param('ns3::ObjectFactory const &', 'value')])
  1715     ## object-factory.h: ns3::ObjectFactory ns3::ObjectFactoryValue::Get() const [member function]
  1716     cls.add_method('Get', 
  1717                    'ns3::ObjectFactory', 
  1718                    [], 
  1719                    is_const=True)
  1720     ## object-factory.h: ns3::Ptr<ns3::AttributeValue> ns3::ObjectFactoryValue::Copy() const [member function]
  1721     cls.add_method('Copy', 
  1722                    'ns3::Ptr< ns3::AttributeValue >', 
  1723                    [], 
  1724                    is_const=True, is_virtual=True)
  1725     ## object-factory.h: std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1726     cls.add_method('SerializeToString', 
  1727                    'std::string', 
  1728                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1729                    is_const=True, is_virtual=True)
  1730     ## object-factory.h: bool ns3::ObjectFactoryValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1731     cls.add_method('DeserializeFromString', 
  1732                    'bool', 
  1733                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1734                    is_virtual=True)
  1735     return
  1736 
  1737 def register_Ns3ObjectVectorAccessor_methods(root_module, cls):
  1738     ## object-vector.h: ns3::ObjectVectorAccessor::ObjectVectorAccessor(ns3::ObjectVectorAccessor const & arg0) [copy constructor]
  1739     cls.add_constructor([param('ns3::ObjectVectorAccessor const &', 'arg0')])
  1740     ## object-vector.h: ns3::ObjectVectorAccessor::ObjectVectorAccessor() [constructor]
  1741     cls.add_constructor([])
  1742     ## object-vector.h: bool ns3::ObjectVectorAccessor::Set(ns3::ObjectBase * object, ns3::AttributeValue const & value) const [member function]
  1743     cls.add_method('Set', 
  1744                    'bool', 
  1745                    [param('ns3::ObjectBase *', 'object'), param('ns3::AttributeValue const &', 'value')], 
  1746                    is_const=True, is_virtual=True)
  1747     ## object-vector.h: bool ns3::ObjectVectorAccessor::Get(ns3::ObjectBase const * object, ns3::AttributeValue & value) const [member function]
  1748     cls.add_method('Get', 
  1749                    'bool', 
  1750                    [param('ns3::ObjectBase const *', 'object'), param('ns3::AttributeValue &', 'value')], 
  1751                    is_const=True, is_virtual=True)
  1752     ## object-vector.h: bool ns3::ObjectVectorAccessor::HasGetter() const [member function]
  1753     cls.add_method('HasGetter', 
  1754                    'bool', 
  1755                    [], 
  1756                    is_const=True, is_virtual=True)
  1757     ## object-vector.h: bool ns3::ObjectVectorAccessor::HasSetter() const [member function]
  1758     cls.add_method('HasSetter', 
  1759                    'bool', 
  1760                    [], 
  1761                    is_const=True, is_virtual=True)
  1762     ## object-vector.h: bool ns3::ObjectVectorAccessor::DoGetN(ns3::ObjectBase const * object, uint32_t * n) const [member function]
  1763     cls.add_method('DoGetN', 
  1764                    'bool', 
  1765                    [param('ns3::ObjectBase const *', 'object'), param('uint32_t *', 'n')], 
  1766                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1767     ## object-vector.h: ns3::Ptr<ns3::Object> ns3::ObjectVectorAccessor::DoGet(ns3::ObjectBase const * object, uint32_t i) const [member function]
  1768     cls.add_method('DoGet', 
  1769                    'ns3::Ptr< ns3::Object >', 
  1770                    [param('ns3::ObjectBase const *', 'object'), param('uint32_t', 'i')], 
  1771                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
  1772     return
  1773 
  1774 def register_Ns3ObjectVectorChecker_methods(root_module, cls):
  1775     ## object-vector.h: ns3::ObjectVectorChecker::ObjectVectorChecker(ns3::ObjectVectorChecker const & arg0) [copy constructor]
  1776     cls.add_constructor([param('ns3::ObjectVectorChecker const &', 'arg0')])
  1777     ## object-vector.h: ns3::ObjectVectorChecker::ObjectVectorChecker() [constructor]
  1778     cls.add_constructor([])
  1779     ## object-vector.h: ns3::TypeId ns3::ObjectVectorChecker::GetItemTypeId() const [member function]
  1780     cls.add_method('GetItemTypeId', 
  1781                    'ns3::TypeId', 
  1782                    [], 
  1783                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1784     return
  1785 
  1786 def register_Ns3ObjectVectorValue_methods(root_module, cls):
  1787     ## object-vector.h: ns3::ObjectVectorValue::ObjectVectorValue(ns3::ObjectVectorValue const & arg0) [copy constructor]
  1788     cls.add_constructor([param('ns3::ObjectVectorValue const &', 'arg0')])
  1789     ## object-vector.h: ns3::ObjectVectorValue::ObjectVectorValue() [constructor]
  1790     cls.add_constructor([])
  1791     ## 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]
  1792     cls.add_method('Begin', 
  1793                    '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Object > const, std::vector< ns3::Ptr< ns3::Object > > >', 
  1794                    [], 
  1795                    is_const=True)
  1796     ## 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]
  1797     cls.add_method('End', 
  1798                    '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Object > const, std::vector< ns3::Ptr< ns3::Object > > >', 
  1799                    [], 
  1800                    is_const=True)
  1801     ## object-vector.h: uint32_t ns3::ObjectVectorValue::GetN() const [member function]
  1802     cls.add_method('GetN', 
  1803                    'uint32_t', 
  1804                    [], 
  1805                    is_const=True)
  1806     ## object-vector.h: ns3::Ptr<ns3::Object> ns3::ObjectVectorValue::Get(uint32_t i) const [member function]
  1807     cls.add_method('Get', 
  1808                    'ns3::Ptr< ns3::Object >', 
  1809                    [param('uint32_t', 'i')], 
  1810                    is_const=True)
  1811     ## object-vector.h: ns3::Ptr<ns3::AttributeValue> ns3::ObjectVectorValue::Copy() const [member function]
  1812     cls.add_method('Copy', 
  1813                    'ns3::Ptr< ns3::AttributeValue >', 
  1814                    [], 
  1815                    is_const=True, is_virtual=True)
  1816     ## object-vector.h: std::string ns3::ObjectVectorValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1817     cls.add_method('SerializeToString', 
  1818                    'std::string', 
  1819                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1820                    is_const=True, is_virtual=True)
  1821     ## object-vector.h: bool ns3::ObjectVectorValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1822     cls.add_method('DeserializeFromString', 
  1823                    'bool', 
  1824                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1825                    is_virtual=True)
  1826     return
  1827 
  1828 def register_Ns3ParetoVariable_methods(root_module, cls):
  1829     ## random-variable.h: ns3::ParetoVariable::ParetoVariable(ns3::ParetoVariable const & arg0) [copy constructor]
  1830     cls.add_constructor([param('ns3::ParetoVariable const &', 'arg0')])
  1831     ## random-variable.h: ns3::ParetoVariable::ParetoVariable() [constructor]
  1832     cls.add_constructor([])
  1833     ## random-variable.h: ns3::ParetoVariable::ParetoVariable(double m) [constructor]
  1834     cls.add_constructor([param('double', 'm')])
  1835     ## random-variable.h: ns3::ParetoVariable::ParetoVariable(double m, double s) [constructor]
  1836     cls.add_constructor([param('double', 'm'), param('double', 's')])
  1837     ## random-variable.h: ns3::ParetoVariable::ParetoVariable(double m, double s, double b) [constructor]
  1838     cls.add_constructor([param('double', 'm'), param('double', 's'), param('double', 'b')])
  1839     return
  1840 
  1841 def register_Ns3PointerChecker_methods(root_module, cls):
  1842     ## pointer.h: ns3::PointerChecker::PointerChecker(ns3::PointerChecker const & arg0) [copy constructor]
  1843     cls.add_constructor([param('ns3::PointerChecker const &', 'arg0')])
  1844     ## pointer.h: ns3::PointerChecker::PointerChecker() [constructor]
  1845     cls.add_constructor([])
  1846     ## pointer.h: ns3::TypeId ns3::PointerChecker::GetPointeeTypeId() const [member function]
  1847     cls.add_method('GetPointeeTypeId', 
  1848                    'ns3::TypeId', 
  1849                    [], 
  1850                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1851     return
  1852 
  1853 def register_Ns3PointerValue_methods(root_module, cls):
  1854     ## pointer.h: ns3::PointerValue::PointerValue(ns3::PointerValue const & arg0) [copy constructor]
  1855     cls.add_constructor([param('ns3::PointerValue const &', 'arg0')])
  1856     ## pointer.h: ns3::PointerValue::PointerValue() [constructor]
  1857     cls.add_constructor([])
  1858     ## pointer.h: ns3::PointerValue::PointerValue(ns3::Ptr<ns3::Object> object) [constructor]
  1859     cls.add_constructor([param('ns3::Ptr< ns3::Object >', 'object')])
  1860     ## pointer.h: void ns3::PointerValue::SetObject(ns3::Ptr<ns3::Object> object) [member function]
  1861     cls.add_method('SetObject', 
  1862                    'void', 
  1863                    [param('ns3::Ptr< ns3::Object >', 'object')])
  1864     ## pointer.h: ns3::Ptr<ns3::Object> ns3::PointerValue::GetObject() const [member function]
  1865     cls.add_method('GetObject', 
  1866                    'ns3::Ptr< ns3::Object >', 
  1867                    [], 
  1868                    is_const=True)
  1869     ## pointer.h: ns3::Ptr<ns3::AttributeValue> ns3::PointerValue::Copy() const [member function]
  1870     cls.add_method('Copy', 
  1871                    'ns3::Ptr< ns3::AttributeValue >', 
  1872                    [], 
  1873                    is_const=True, is_virtual=True)
  1874     ## pointer.h: std::string ns3::PointerValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1875     cls.add_method('SerializeToString', 
  1876                    'std::string', 
  1877                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1878                    is_const=True, is_virtual=True)
  1879     ## pointer.h: bool ns3::PointerValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1880     cls.add_method('DeserializeFromString', 
  1881                    'bool', 
  1882                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1883                    is_virtual=True)
  1884     return
  1885 
  1886 def register_Ns3RandomVariableChecker_methods(root_module, cls):
  1887     ## random-variable.h: ns3::RandomVariableChecker::RandomVariableChecker(ns3::RandomVariableChecker const & arg0) [copy constructor]
  1888     cls.add_constructor([param('ns3::RandomVariableChecker const &', 'arg0')])
  1889     ## random-variable.h: ns3::RandomVariableChecker::RandomVariableChecker() [constructor]
  1890     cls.add_constructor([])
  1891     return
  1892 
  1893 def register_Ns3RandomVariableValue_methods(root_module, cls):
  1894     ## random-variable.h: ns3::RandomVariableValue::RandomVariableValue(ns3::RandomVariableValue const & arg0) [copy constructor]
  1895     cls.add_constructor([param('ns3::RandomVariableValue const &', 'arg0')])
  1896     ## random-variable.h: ns3::RandomVariableValue::RandomVariableValue() [constructor]
  1897     cls.add_constructor([])
  1898     ## random-variable.h: ns3::RandomVariableValue::RandomVariableValue(ns3::RandomVariable const & value) [constructor]
  1899     cls.add_constructor([param('ns3::RandomVariable const &', 'value')])
  1900     ## random-variable.h: void ns3::RandomVariableValue::Set(ns3::RandomVariable const & value) [member function]
  1901     cls.add_method('Set', 
  1902                    'void', 
  1903                    [param('ns3::RandomVariable const &', 'value')])
  1904     ## random-variable.h: ns3::RandomVariable ns3::RandomVariableValue::Get() const [member function]
  1905     cls.add_method('Get', 
  1906                    'ns3::RandomVariable', 
  1907                    [], 
  1908                    is_const=True)
  1909     ## random-variable.h: ns3::Ptr<ns3::AttributeValue> ns3::RandomVariableValue::Copy() const [member function]
  1910     cls.add_method('Copy', 
  1911                    'ns3::Ptr< ns3::AttributeValue >', 
  1912                    [], 
  1913                    is_const=True, is_virtual=True)
  1914     ## random-variable.h: std::string ns3::RandomVariableValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1915     cls.add_method('SerializeToString', 
  1916                    'std::string', 
  1917                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1918                    is_const=True, is_virtual=True)
  1919     ## random-variable.h: bool ns3::RandomVariableValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1920     cls.add_method('DeserializeFromString', 
  1921                    'bool', 
  1922                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1923                    is_virtual=True)
  1924     return
  1925 
  1926 def register_Ns3StringChecker_methods(root_module, cls):
  1927     ## string.h: ns3::StringChecker::StringChecker(ns3::StringChecker const & arg0) [copy constructor]
  1928     cls.add_constructor([param('ns3::StringChecker const &', 'arg0')])
  1929     ## string.h: ns3::StringChecker::StringChecker() [constructor]
  1930     cls.add_constructor([])
  1931     return
  1932 
  1933 def register_Ns3StringValue_methods(root_module, cls):
  1934     ## string.h: ns3::StringValue::StringValue(ns3::StringValue const & arg0) [copy constructor]
  1935     cls.add_constructor([param('ns3::StringValue const &', 'arg0')])
  1936     ## string.h: ns3::StringValue::StringValue() [constructor]
  1937     cls.add_constructor([])
  1938     ## string.h: ns3::StringValue::StringValue(std::string const & value) [constructor]
  1939     cls.add_constructor([param('std::string const &', 'value')])
  1940     ## string.h: void ns3::StringValue::Set(std::string const & value) [member function]
  1941     cls.add_method('Set', 
  1942                    'void', 
  1943                    [param('std::string const &', 'value')])
  1944     ## string.h: std::string ns3::StringValue::Get() const [member function]
  1945     cls.add_method('Get', 
  1946                    'std::string', 
  1947                    [], 
  1948                    is_const=True)
  1949     ## string.h: ns3::Ptr<ns3::AttributeValue> ns3::StringValue::Copy() const [member function]
  1950     cls.add_method('Copy', 
  1951                    'ns3::Ptr< ns3::AttributeValue >', 
  1952                    [], 
  1953                    is_const=True, is_virtual=True)
  1954     ## string.h: std::string ns3::StringValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1955     cls.add_method('SerializeToString', 
  1956                    'std::string', 
  1957                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1958                    is_const=True, is_virtual=True)
  1959     ## string.h: bool ns3::StringValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1960     cls.add_method('DeserializeFromString', 
  1961                    'bool', 
  1962                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1963                    is_virtual=True)
  1964     return
  1965 
  1966 def register_Ns3TypeIdChecker_methods(root_module, cls):
  1967     ## type-id.h: ns3::TypeIdChecker::TypeIdChecker(ns3::TypeIdChecker const & arg0) [copy constructor]
  1968     cls.add_constructor([param('ns3::TypeIdChecker const &', 'arg0')])
  1969     ## type-id.h: ns3::TypeIdChecker::TypeIdChecker() [constructor]
  1970     cls.add_constructor([])
  1971     return
  1972 
  1973 def register_Ns3TypeIdValue_methods(root_module, cls):
  1974     ## type-id.h: ns3::TypeIdValue::TypeIdValue(ns3::TypeIdValue const & arg0) [copy constructor]
  1975     cls.add_constructor([param('ns3::TypeIdValue const &', 'arg0')])
  1976     ## type-id.h: ns3::TypeIdValue::TypeIdValue() [constructor]
  1977     cls.add_constructor([])
  1978     ## type-id.h: ns3::TypeIdValue::TypeIdValue(ns3::TypeId const & value) [constructor]
  1979     cls.add_constructor([param('ns3::TypeId const &', 'value')])
  1980     ## type-id.h: void ns3::TypeIdValue::Set(ns3::TypeId const & value) [member function]
  1981     cls.add_method('Set', 
  1982                    'void', 
  1983                    [param('ns3::TypeId const &', 'value')])
  1984     ## type-id.h: ns3::TypeId ns3::TypeIdValue::Get() const [member function]
  1985     cls.add_method('Get', 
  1986                    'ns3::TypeId', 
  1987                    [], 
  1988                    is_const=True)
  1989     ## type-id.h: ns3::Ptr<ns3::AttributeValue> ns3::TypeIdValue::Copy() const [member function]
  1990     cls.add_method('Copy', 
  1991                    'ns3::Ptr< ns3::AttributeValue >', 
  1992                    [], 
  1993                    is_const=True, is_virtual=True)
  1994     ## type-id.h: std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1995     cls.add_method('SerializeToString', 
  1996                    'std::string', 
  1997                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1998                    is_const=True, is_virtual=True)
  1999     ## type-id.h: bool ns3::TypeIdValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  2000     cls.add_method('DeserializeFromString', 
  2001                    'bool', 
  2002                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  2003                    is_virtual=True)
  2004     return
  2005 
  2006 def register_Ns3UintegerValue_methods(root_module, cls):
  2007     ## uinteger.h: ns3::UintegerValue::UintegerValue(ns3::UintegerValue const & arg0) [copy constructor]
  2008     cls.add_constructor([param('ns3::UintegerValue const &', 'arg0')])
  2009     ## uinteger.h: ns3::UintegerValue::UintegerValue() [constructor]
  2010     cls.add_constructor([])
  2011     ## uinteger.h: ns3::UintegerValue::UintegerValue(uint64_t const & value) [constructor]
  2012     cls.add_constructor([param('uint64_t const &', 'value')])
  2013     ## uinteger.h: void ns3::UintegerValue::Set(uint64_t const & value) [member function]
  2014     cls.add_method('Set', 
  2015                    'void', 
  2016                    [param('uint64_t const &', 'value')])
  2017     ## uinteger.h: uint64_t ns3::UintegerValue::Get() const [member function]
  2018     cls.add_method('Get', 
  2019                    'uint64_t', 
  2020                    [], 
  2021                    is_const=True)
  2022     ## uinteger.h: ns3::Ptr<ns3::AttributeValue> ns3::UintegerValue::Copy() const [member function]
  2023     cls.add_method('Copy', 
  2024                    'ns3::Ptr< ns3::AttributeValue >', 
  2025                    [], 
  2026                    is_const=True, is_virtual=True)
  2027     ## uinteger.h: std::string ns3::UintegerValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  2028     cls.add_method('SerializeToString', 
  2029                    'std::string', 
  2030                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  2031                    is_const=True, is_virtual=True)
  2032     ## uinteger.h: bool ns3::UintegerValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  2033     cls.add_method('DeserializeFromString', 
  2034                    'bool', 
  2035                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  2036                    is_virtual=True)
  2037     return
  2038 
  2039 def register_Ns3TracedValue__Unsigned_int_methods(root_module, cls):
  2040     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue() [constructor]
  2041     cls.add_constructor([])
  2042     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::TracedValue<unsigned int> const & o) [copy constructor]
  2043     cls.add_constructor([param('ns3::TracedValue< unsigned int > const &', 'o')])
  2044     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(unsigned int const & v) [constructor]
  2045     cls.add_constructor([param('unsigned int const &', 'v')])
  2046     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::IntegerValue const & value) [constructor]
  2047     cls.add_constructor([param('ns3::IntegerValue const &', 'value')])
  2048     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::UintegerValue const & value) [constructor]
  2049     cls.add_constructor([param('ns3::UintegerValue const &', 'value')])
  2050     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::BooleanValue const & value) [constructor]
  2051     cls.add_constructor([param('ns3::BooleanValue const &', 'value')])
  2052     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::EnumValue const & value) [constructor]
  2053     cls.add_constructor([param('ns3::EnumValue const &', 'value')])
  2054     ## traced-value.h: void ns3::TracedValue<unsigned int>::ConnectWithoutContext(ns3::CallbackBase const & cb) [member function]
  2055     cls.add_method('ConnectWithoutContext', 
  2056                    'void', 
  2057                    [param('ns3::CallbackBase const &', 'cb')])
  2058     ## traced-value.h: void ns3::TracedValue<unsigned int>::Connect(ns3::CallbackBase const & cb, std::string path) [member function]
  2059     cls.add_method('Connect', 
  2060                    'void', 
  2061                    [param('ns3::CallbackBase const &', 'cb'), param('std::string', 'path')])
  2062     ## traced-value.h: void ns3::TracedValue<unsigned int>::DisconnectWithoutContext(ns3::CallbackBase const & cb) [member function]
  2063     cls.add_method('DisconnectWithoutContext', 
  2064                    'void', 
  2065                    [param('ns3::CallbackBase const &', 'cb')])
  2066     ## traced-value.h: void ns3::TracedValue<unsigned int>::Disconnect(ns3::CallbackBase const & cb, std::string path) [member function]
  2067     cls.add_method('Disconnect', 
  2068                    'void', 
  2069                    [param('ns3::CallbackBase const &', 'cb'), param('std::string', 'path')])
  2070     ## traced-value.h: void ns3::TracedValue<unsigned int>::Set(unsigned int const & v) [member function]
  2071     cls.add_method('Set', 
  2072                    'void', 
  2073                    [param('unsigned int const &', 'v')])
  2074     ## traced-value.h: unsigned int ns3::TracedValue<unsigned int>::Get() const [member function]
  2075     cls.add_method('Get', 
  2076                    'unsigned int', 
  2077                    [], 
  2078                    is_const=True)
  2079     return
  2080 
  2081 def register_Ns3ConfigMatchContainer_methods(root_module, cls):
  2082     ## config.h: ns3::Config::MatchContainer::MatchContainer(ns3::Config::MatchContainer const & arg0) [copy constructor]
  2083     cls.add_constructor([param('ns3::Config::MatchContainer const &', 'arg0')])
  2084     ## config.h: ns3::Config::MatchContainer::MatchContainer() [constructor]
  2085     cls.add_constructor([])
  2086     ## config.h: ns3::Config::MatchContainer::MatchContainer(std::vector<ns3::Ptr<ns3::Object>, std::allocator<ns3::Ptr<ns3::Object> > > const & objects, std::vector<std::string, std::allocator<std::string> > const & contexts, std::string path) [constructor]
  2087     cls.add_constructor([param('std::vector< ns3::Ptr< ns3::Object > > const &', 'objects'), param('std::vector< std::string > const &', 'contexts'), param('std::string', 'path')])
  2088     ## config.h: __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Object>*,std::vector<ns3::Ptr<ns3::Object>, std::allocator<ns3::Ptr<ns3::Object> > > > ns3::Config::MatchContainer::Begin() const [member function]
  2089     cls.add_method('Begin', 
  2090                    '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Object > const, std::vector< ns3::Ptr< ns3::Object > > >', 
  2091                    [], 
  2092                    is_const=True)
  2093     ## config.h: __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Object>*,std::vector<ns3::Ptr<ns3::Object>, std::allocator<ns3::Ptr<ns3::Object> > > > ns3::Config::MatchContainer::End() const [member function]
  2094     cls.add_method('End', 
  2095                    '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Object > const, std::vector< ns3::Ptr< ns3::Object > > >', 
  2096                    [], 
  2097                    is_const=True)
  2098     ## config.h: uint32_t ns3::Config::MatchContainer::GetN() const [member function]
  2099     cls.add_method('GetN', 
  2100                    'uint32_t', 
  2101                    [], 
  2102                    is_const=True)
  2103     ## config.h: ns3::Ptr<ns3::Object> ns3::Config::MatchContainer::Get(uint32_t i) const [member function]
  2104     cls.add_method('Get', 
  2105                    'ns3::Ptr< ns3::Object >', 
  2106                    [param('uint32_t', 'i')], 
  2107                    is_const=True)
  2108     ## config.h: std::string ns3::Config::MatchContainer::GetMatchedPath(uint32_t i) const [member function]
  2109     cls.add_method('GetMatchedPath', 
  2110                    'std::string', 
  2111                    [param('uint32_t', 'i')], 
  2112                    is_const=True)
  2113     ## config.h: std::string ns3::Config::MatchContainer::GetPath() const [member function]
  2114     cls.add_method('GetPath', 
  2115                    'std::string', 
  2116                    [], 
  2117                    is_const=True)
  2118     ## config.h: void ns3::Config::MatchContainer::Set(std::string name, ns3::AttributeValue const & value) [member function]
  2119     cls.add_method('Set', 
  2120                    'void', 
  2121                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
  2122     ## config.h: void ns3::Config::MatchContainer::Connect(std::string name, ns3::CallbackBase const & cb) [member function]
  2123     cls.add_method('Connect', 
  2124                    'void', 
  2125                    [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])
  2126     ## config.h: void ns3::Config::MatchContainer::ConnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]
  2127     cls.add_method('ConnectWithoutContext', 
  2128                    'void', 
  2129                    [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])
  2130     ## config.h: void ns3::Config::MatchContainer::Disconnect(std::string name, ns3::CallbackBase const & cb) [member function]
  2131     cls.add_method('Disconnect', 
  2132                    'void', 
  2133                    [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])
  2134     ## config.h: void ns3::Config::MatchContainer::DisconnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]
  2135     cls.add_method('DisconnectWithoutContext', 
  2136                    'void', 
  2137                    [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])
  2138     return
  2139 
  2140 def register_functions(root_module):
  2141     module = root_module
  2142     ## breakpoint.h: extern void ns3::BreakpointFallback() [free function]
  2143     module.add_function('BreakpointFallback', 
  2144                         'void', 
  2145                         [])
  2146     ## ptr.h: extern ns3::Ptr<ns3::ObjectVectorValue> ns3::Create() [free function]
  2147     module.add_function('Create', 
  2148                         'ns3::Ptr< ns3::ObjectVectorValue >', 
  2149                         [], 
  2150                         template_parameters=['ns3::ObjectVectorValue'])
  2151     ## ptr.h: extern ns3::Ptr<ns3::PointerValue> ns3::Create() [free function]
  2152     module.add_function('Create', 
  2153                         'ns3::Ptr< ns3::PointerValue >', 
  2154                         [], 
  2155                         template_parameters=['ns3::PointerValue'])
  2156     ## log.h: extern void ns3::LogComponentDisable(char const * name, ns3::LogLevel level) [free function]
  2157     module.add_function('LogComponentDisable', 
  2158                         'void', 
  2159                         [param('char const *', 'name'), param('ns3::LogLevel', 'level')])
  2160     ## log.h: extern void ns3::LogComponentDisableAll(ns3::LogLevel level) [free function]
  2161     module.add_function('LogComponentDisableAll', 
  2162                         'void', 
  2163                         [param('ns3::LogLevel', 'level')])
  2164     ## log.h: extern void ns3::LogComponentEnable(char const * name, ns3::LogLevel level) [free function]
  2165     module.add_function('LogComponentEnable', 
  2166                         'void', 
  2167                         [param('char const *', 'name'), param('ns3::LogLevel', 'level')])
  2168     ## log.h: extern void ns3::LogComponentEnableAll(ns3::LogLevel level) [free function]
  2169     module.add_function('LogComponentEnableAll', 
  2170                         'void', 
  2171                         [param('ns3::LogLevel', 'level')])
  2172     ## boolean.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeBooleanChecker() [free function]
  2173     module.add_function('MakeBooleanChecker', 
  2174                         'ns3::Ptr< ns3::AttributeChecker const >', 
  2175                         [])
  2176     ## callback.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeCallbackChecker() [free function]
  2177     module.add_function('MakeCallbackChecker', 
  2178                         'ns3::Ptr< ns3::AttributeChecker const >', 
  2179                         [])
  2180     ## 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]
  2181     module.add_function('MakeEnumChecker', 
  2182                         'ns3::Ptr< ns3::AttributeChecker const >', 
  2183                         [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='""')])
  2184     ## object-factory.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeObjectFactoryChecker() [free function]
  2185     module.add_function('MakeObjectFactoryChecker', 
  2186                         'ns3::Ptr< ns3::AttributeChecker const >', 
  2187                         [])
  2188     ## random-variable.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeRandomVariableChecker() [free function]
  2189     module.add_function('MakeRandomVariableChecker', 
  2190                         'ns3::Ptr< ns3::AttributeChecker const >', 
  2191                         [])
  2192     ## string.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeStringChecker() [free function]
  2193     module.add_function('MakeStringChecker', 
  2194                         'ns3::Ptr< ns3::AttributeChecker const >', 
  2195                         [])
  2196     ## type-id.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeTypeIdChecker() [free function]
  2197     module.add_function('MakeTypeIdChecker', 
  2198                         'ns3::Ptr< ns3::AttributeChecker const >', 
  2199                         [])
  2200     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  2201     module.add_function('TypeNameGet', 
  2202                         'std::string', 
  2203                         [], 
  2204                         template_parameters=['double'])
  2205     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  2206     module.add_function('TypeNameGet', 
  2207                         'std::string', 
  2208                         [], 
  2209                         template_parameters=['float'])
  2210     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  2211     module.add_function('TypeNameGet', 
  2212                         'std::string', 
  2213                         [], 
  2214                         template_parameters=['long long'])
  2215     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  2216     module.add_function('TypeNameGet', 
  2217                         'std::string', 
  2218                         [], 
  2219                         template_parameters=['int'])
  2220     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  2221     module.add_function('TypeNameGet', 
  2222                         'std::string', 
  2223                         [], 
  2224                         template_parameters=['short'])
  2225     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  2226     module.add_function('TypeNameGet', 
  2227                         'std::string', 
  2228                         [], 
  2229                         template_parameters=['signed char'])
  2230     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  2231     module.add_function('TypeNameGet', 
  2232                         'std::string', 
  2233                         [], 
  2234                         template_parameters=['unsigned long long'])
  2235     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  2236     module.add_function('TypeNameGet', 
  2237                         'std::string', 
  2238                         [], 
  2239                         template_parameters=['unsigned int'])
  2240     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  2241     module.add_function('TypeNameGet', 
  2242                         'std::string', 
  2243                         [], 
  2244                         template_parameters=['unsigned short'])
  2245     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]
  2246     module.add_function('TypeNameGet', 
  2247                         'std::string', 
  2248                         [], 
  2249                         template_parameters=['unsigned char'])
  2250     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
  2251     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
  2252     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
  2253     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
  2254     register_functions_ns3_olsr(module.get_submodule('olsr'), root_module)
  2255     return
  2256 
  2257 def register_functions_ns3_Config(module, root_module):
  2258     ## config.h: extern void ns3::Config::Connect(std::string path, ns3::CallbackBase const & cb) [free function]
  2259     module.add_function('Connect', 
  2260                         'void', 
  2261                         [param('std::string', 'path'), param('ns3::CallbackBase const &', 'cb')])
  2262     ## config.h: extern void ns3::Config::ConnectWithoutContext(std::string path, ns3::CallbackBase const & cb) [free function]
  2263     module.add_function('ConnectWithoutContext', 
  2264                         'void', 
  2265                         [param('std::string', 'path'), param('ns3::CallbackBase const &', 'cb')])
  2266     ## config.h: extern void ns3::Config::Disconnect(std::string path, ns3::CallbackBase const & cb) [free function]
  2267     module.add_function('Disconnect', 
  2268                         'void', 
  2269                         [param('std::string', 'path'), param('ns3::CallbackBase const &', 'cb')])
  2270     ## config.h: extern void ns3::Config::DisconnectWithoutContext(std::string path, ns3::CallbackBase const & cb) [free function]
  2271     module.add_function('DisconnectWithoutContext', 
  2272                         'void', 
  2273                         [param('std::string', 'path'), param('ns3::CallbackBase const &', 'cb')])
  2274     ## config.h: extern ns3::Ptr<ns3::Object> ns3::Config::GetRootNamespaceObject(uint32_t i) [free function]
  2275     module.add_function('GetRootNamespaceObject', 
  2276                         'ns3::Ptr< ns3::Object >', 
  2277                         [param('uint32_t', 'i')])
  2278     ## config.h: extern uint32_t ns3::Config::GetRootNamespaceObjectN() [free function]
  2279     module.add_function('GetRootNamespaceObjectN', 
  2280                         'uint32_t', 
  2281                         [])
  2282     ## config.h: extern ns3::Config::MatchContainer ns3::Config::LookupMatches(std::string path) [free function]
  2283     module.add_function('LookupMatches', 
  2284                         'ns3::Config::MatchContainer', 
  2285                         [param('std::string', 'path')])
  2286     ## config.h: extern void ns3::Config::RegisterRootNamespaceObject(ns3::Ptr<ns3::Object> obj) [free function]
  2287     module.add_function('RegisterRootNamespaceObject', 
  2288                         'void', 
  2289                         [param('ns3::Ptr< ns3::Object >', 'obj')])
  2290     ## config.h: extern void ns3::Config::Set(std::string path, ns3::AttributeValue const & value) [free function]
  2291     module.add_function('Set', 
  2292                         'void', 
  2293                         [param('std::string', 'path'), param('ns3::AttributeValue const &', 'value')])
  2294     ## config.h: extern void ns3::Config::SetDefault(std::string name, ns3::AttributeValue const & value) [free function]
  2295     module.add_function('SetDefault', 
  2296                         'void', 
  2297                         [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
  2298     ## config.h: extern bool ns3::Config::SetDefaultFailSafe(std::string name, ns3::AttributeValue const & value) [free function]
  2299     module.add_function('SetDefaultFailSafe', 
  2300                         'bool', 
  2301                         [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
  2302     ## config.h: extern void ns3::Config::SetGlobal(std::string name, ns3::AttributeValue const & value) [free function]
  2303     module.add_function('SetGlobal', 
  2304                         'void', 
  2305                         [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
  2306     ## config.h: extern bool ns3::Config::SetGlobalFailSafe(std::string name, ns3::AttributeValue const & value) [free function]
  2307     module.add_function('SetGlobalFailSafe', 
  2308                         'bool', 
  2309                         [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
  2310     ## config.h: extern void ns3::Config::UnregisterRootNamespaceObject(ns3::Ptr<ns3::Object> obj) [free function]
  2311     module.add_function('UnregisterRootNamespaceObject', 
  2312                         'void', 
  2313                         [param('ns3::Ptr< ns3::Object >', 'obj')])
  2314     return
  2315 
  2316 def register_functions_ns3_TimeStepPrecision(module, root_module):
  2317     return
  2318 
  2319 def register_functions_ns3_addressUtils(module, root_module):
  2320     return
  2321 
  2322 def register_functions_ns3_internal(module, root_module):
  2323     ## double.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::internal::MakeDoubleChecker(double min, double max, std::string name) [free function]
  2324     module.add_function('MakeDoubleChecker', 
  2325                         'ns3::Ptr< ns3::AttributeChecker const >', 
  2326                         [param('double', 'min'), param('double', 'max'), param('std::string', 'name')])
  2327     ## integer.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::internal::MakeIntegerChecker(int64_t min, int64_t max, std::string name) [free function]
  2328     module.add_function('MakeIntegerChecker', 
  2329                         'ns3::Ptr< ns3::AttributeChecker const >', 
  2330                         [param('int64_t', 'min'), param('int64_t', 'max'), param('std::string', 'name')])
  2331     ## uinteger.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::internal::MakeUintegerChecker(uint64_t min, uint64_t max, std::string name) [free function]
  2332     module.add_function('MakeUintegerChecker', 
  2333                         'ns3::Ptr< ns3::AttributeChecker const >', 
  2334                         [param('uint64_t', 'min'), param('uint64_t', 'max'), param('std::string', 'name')])
  2335     return
  2336 
  2337 def register_functions_ns3_olsr(module, root_module):
  2338     return
  2339