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