ns-3.5: bindings/python/ns3_module

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

     3 def register_types(module):

     4     root_module = module.get_root()

     6     ## log.h: ns3::LogLevel [enumeration]

     7     module.add_enum('LogLevel', ['LOG_NONE', 'LOG_ERROR', 'LOG_LEVEL_ERROR', 'LOG_WARN', 'LOG_LEVEL_WARN', 'LOG_DEBUG', 'LOG_LEVEL_DEBUG', 'LOG_INFO', 'LOG_LEVEL_INFO', 'LOG_FUNCTION', 'LOG_LEVEL_FUNCTION', 'LOG_LOGIC', 'LOG_LEVEL_LOGIC', 'LOG_ALL', 'LOG_LEVEL_ALL', 'LOG_PREFIX_FUNC', 'LOG_PREFIX_TIME'])

     8     ## attribute-list.h: ns3::AttributeList [class]

     9     module.add_class('AttributeList')

    10     ## callback.h: ns3::CallbackBase [class]

    11     module.add_class('CallbackBase')

    12     ## callback.h: ns3::CallbackImplBase [class]

    13     module.add_class('CallbackImplBase', allow_subclassing=True, memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))

    14     ## command-line.h: ns3::CommandLine [class]

    15     module.add_class('CommandLine', allow_subclassing=True)

    16     ## system-mutex.h: ns3::CriticalSection [class]

    17     module.add_class('CriticalSection')

    18     ## global-value.h: ns3::GlobalValue [class]

    19     module.add_class('GlobalValue')

    20     ## int-to-type.h: ns3::IntToType<0> [struct]

    21     module.add_class('IntToType', template_parameters=['0'])

    22     ## int-to-type.h: ns3::IntToType<0>::v_e [enumeration]

    23     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 0 >'])

    24     ## int-to-type.h: ns3::IntToType<1> [struct]

    25     module.add_class('IntToType', template_parameters=['1'])

    26     ## int-to-type.h: ns3::IntToType<1>::v_e [enumeration]

    27     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 1 >'])

    28     ## int-to-type.h: ns3::IntToType<2> [struct]

    29     module.add_class('IntToType', template_parameters=['2'])

    30     ## int-to-type.h: ns3::IntToType<2>::v_e [enumeration]

    31     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 2 >'])

    32     ## int-to-type.h: ns3::IntToType<3> [struct]

    33     module.add_class('IntToType', template_parameters=['3'])

    34     ## int-to-type.h: ns3::IntToType<3>::v_e [enumeration]

    35     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 3 >'])

    36     ## int-to-type.h: ns3::IntToType<4> [struct]

    37     module.add_class('IntToType', template_parameters=['4'])

    38     ## int-to-type.h: ns3::IntToType<4>::v_e [enumeration]

    39     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 4 >'])

    40     ## int-to-type.h: ns3::IntToType<5> [struct]

    41     module.add_class('IntToType', template_parameters=['5'])

    42     ## int-to-type.h: ns3::IntToType<5>::v_e [enumeration]

    43     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 5 >'])

    44     ## int-to-type.h: ns3::IntToType<6> [struct]

    45     module.add_class('IntToType', template_parameters=['6'])

    46     ## int-to-type.h: ns3::IntToType<6>::v_e [enumeration]

    47     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 6 >'])

    48     ## names.h: ns3::Names [class]

    49     module.add_class('Names')

    50     ## object-base.h: ns3::ObjectBase [class]

    51     module.add_class('ObjectBase', allow_subclassing=True)

    52     ## object-factory.h: ns3::ObjectFactory [class]

    53     module.add_class('ObjectFactory')

    54     ## random-variable.h: ns3::RandomVariable [class]

    55     module.add_class('RandomVariable')

    56     ## ref-count-base.h: ns3::RefCountBase [class]

    57     module.add_class('RefCountBase', automatic_type_narrowing=True, memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))

    58     ## rng-stream.h: ns3::RngStream [class]

    59     module.add_class('RngStream')

    60     ## random-variable.h: ns3::SeedManager [class]

    61     module.add_class('SeedManager')

    62     ## random-variable.h: ns3::SequentialVariable [class]

    63     module.add_class('SequentialVariable', parent=root_module['ns3::RandomVariable'])

    64     ## system-condition.h: ns3::SystemCondition [class]

    65     module.add_class('SystemCondition')

    66     ## system-mutex.h: ns3::SystemMutex [class]

    67     module.add_class('SystemMutex')

    68     ## system-thread.h: ns3::SystemThread [class]

    69     module.add_class('SystemThread')

    70     ## system-wall-clock-ms.h: ns3::SystemWallClockMs [class]

    71     module.add_class('SystemWallClockMs')

    72     ## trace-source-accessor.h: ns3::TraceSourceAccessor [class]

    73     module.add_class('TraceSourceAccessor', allow_subclassing=True)

    74     ## random-variable.h: ns3::TriangularVariable [class]

    75     module.add_class('TriangularVariable', parent=root_module['ns3::RandomVariable'])

    76     ## type-id.h: ns3::TypeId [class]

    77     module.add_class('TypeId')

    78     ## type-id.h: ns3::TypeId::AttributeFlag [enumeration]

    79     module.add_enum('AttributeFlag', ['ATTR_GET', 'ATTR_SET', 'ATTR_CONSTRUCT', 'ATTR_SGC'], outer_class=root_module['ns3::TypeId'])

    80     ## type-id.h: ns3::TypeId::AttributeInfo [struct]

    81     module.add_class('AttributeInfo', outer_class=root_module['ns3::TypeId'])

    82     ## random-variable.h: ns3::UniformVariable [class]

    83     module.add_class('UniformVariable', parent=root_module['ns3::RandomVariable'])

    84     ## attribute-list.h: ns3::UnsafeAttributeList [class]

    85     module.add_class('UnsafeAttributeList')

    86     ## random-variable.h: ns3::WeibullVariable [class]

    87     module.add_class('WeibullVariable', parent=root_module['ns3::RandomVariable'])

    88     ## random-variable.h: ns3::ZipfVariable [class]

    89     module.add_class('ZipfVariable', parent=root_module['ns3::RandomVariable'])

    90     ## empty.h: ns3::empty [class]

    91     module.add_class('empty')

    92     ## attribute.h: ns3::AttributeAccessor [class]

    93     module.add_class('AttributeAccessor', parent=root_module['ns3::RefCountBase'])

    94     ## attribute.h: ns3::AttributeChecker [class]

    95     module.add_class('AttributeChecker', allow_subclassing=False, automatic_type_narrowing=True, parent=root_module['ns3::RefCountBase'])

    96     ## attribute.h: ns3::AttributeValue [class]

    97     module.add_class('AttributeValue', allow_subclassing=False, automatic_type_narrowing=True, parent=root_module['ns3::RefCountBase'])

    98     ## boolean.h: ns3::BooleanChecker [class]

    99     module.add_class('BooleanChecker', parent=root_module['ns3::AttributeChecker'])

   100     ## boolean.h: ns3::BooleanValue [class]

   101     module.add_class('BooleanValue', parent=root_module['ns3::AttributeValue'])

   102     ## callback.h: ns3::CallbackChecker [class]

   103     module.add_class('CallbackChecker', parent=root_module['ns3::AttributeChecker'])

   104     ## callback.h: ns3::CallbackValue [class]

   105     module.add_class('CallbackValue', parent=root_module['ns3::AttributeValue'])

   106     ## random-variable.h: ns3::ConstantVariable [class]

   107     module.add_class('ConstantVariable', parent=root_module['ns3::RandomVariable'])

   108     ## random-variable.h: ns3::DeterministicVariable [class]

   109     module.add_class('DeterministicVariable', parent=root_module['ns3::RandomVariable'])

   110     ## double.h: ns3::DoubleValue [class]

   111     module.add_class('DoubleValue', parent=root_module['ns3::AttributeValue'])

   112     ## random-variable.h: ns3::EmpiricalVariable [class]

   113     module.add_class('EmpiricalVariable', parent=root_module['ns3::RandomVariable'])

   114     ## attribute.h: ns3::EmptyAttributeValue [class]

   115     module.add_class('EmptyAttributeValue', parent=root_module['ns3::AttributeValue'])

   116     ## enum.h: ns3::EnumChecker [class]

   117     module.add_class('EnumChecker', parent=root_module['ns3::AttributeChecker'])

   118     ## enum.h: ns3::EnumValue [class]

   119     module.add_class('EnumValue', parent=root_module['ns3::AttributeValue'])

   120     ## random-variable.h: ns3::ErlangVariable [class]

   121     module.add_class('ErlangVariable', parent=root_module['ns3::RandomVariable'])

   122     ## random-variable.h: ns3::ExponentialVariable [class]

   123     module.add_class('ExponentialVariable', parent=root_module['ns3::RandomVariable'])

   124     ## random-variable.h: ns3::GammaVariable [class]

   125     module.add_class('GammaVariable', parent=root_module['ns3::RandomVariable'])

   126     ## random-variable.h: ns3::IntEmpiricalVariable [class]

   127     module.add_class('IntEmpiricalVariable', parent=root_module['ns3::EmpiricalVariable'])

   128     ## integer.h: ns3::IntegerValue [class]

   129     module.add_class('IntegerValue', parent=root_module['ns3::AttributeValue'])

   130     ## random-variable.h: ns3::LogNormalVariable [class]

   131     module.add_class('LogNormalVariable', parent=root_module['ns3::RandomVariable'])

   132     ## random-variable.h: ns3::NormalVariable [class]

   133     module.add_class('NormalVariable', parent=root_module['ns3::RandomVariable'])

   134     ## object.h: ns3::Object [class]

   135     module.add_class('Object', automatic_type_narrowing=True, parent=root_module['ns3::ObjectBase'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))

   136     ## object.h: ns3::Object::AggregateIterator [class]

   137     module.add_class('AggregateIterator', outer_class=root_module['ns3::Object'])

   138     ## object-factory.h: ns3::ObjectFactoryChecker [class]

   139     module.add_class('ObjectFactoryChecker', parent=root_module['ns3::AttributeChecker'])

   140     ## object-factory.h: ns3::ObjectFactoryValue [class]

   141     module.add_class('ObjectFactoryValue', parent=root_module['ns3::AttributeValue'])

   142     ## object-vector.h: ns3::ObjectVectorAccessor [class]

   143     module.add_class('ObjectVectorAccessor', parent=root_module['ns3::AttributeAccessor'])

   144     ## object-vector.h: ns3::ObjectVectorChecker [class]

   145     module.add_class('ObjectVectorChecker', parent=root_module['ns3::AttributeChecker'])

   146     ## object-vector.h: ns3::ObjectVectorValue [class]

   147     module.add_class('ObjectVectorValue', parent=root_module['ns3::AttributeValue'])

   148     ## random-variable.h: ns3::ParetoVariable [class]

   149     module.add_class('ParetoVariable', parent=root_module['ns3::RandomVariable'])

   150     ## pointer.h: ns3::PointerChecker [class]

   151     module.add_class('PointerChecker', parent=root_module['ns3::AttributeChecker'])

   152     ## pointer.h: ns3::PointerValue [class]

   153     module.add_class('PointerValue', parent=root_module['ns3::AttributeValue'])

   154     ## random-variable.h: ns3::RandomVariableChecker [class]

   155     module.add_class('RandomVariableChecker', parent=root_module['ns3::AttributeChecker'])

   156     ## random-variable.h: ns3::RandomVariableValue [class]

   157     module.add_class('RandomVariableValue', parent=root_module['ns3::AttributeValue'])

   158     ## string.h: ns3::StringChecker [class]

   159     module.add_class('StringChecker', parent=root_module['ns3::AttributeChecker'])

   160     ## string.h: ns3::StringValue [class]

   161     module.add_class('StringValue', parent=root_module['ns3::AttributeValue'])

   162     ## type-id.h: ns3::TypeIdChecker [class]

   163     module.add_class('TypeIdChecker', parent=root_module['ns3::AttributeChecker'])

   164     ## type-id.h: ns3::TypeIdValue [class]

   165     module.add_class('TypeIdValue', parent=root_module['ns3::AttributeValue'])

   166     ## uinteger.h: ns3::UintegerValue [class]

   167     module.add_class('UintegerValue', parent=root_module['ns3::AttributeValue'])

   168     ## traced-value.h: ns3::TracedValue<unsigned int> [class]

   169     module.add_class('TracedValue', template_parameters=['unsigned int'])

   170     ## traced-value.h: ns3::TracedValue<unsigned int> [class]

   171     root_module['ns3::TracedValue< unsigned int >'].implicitly_converts_to(root_module['ns3::IntegerValue'])

   172     ## traced-value.h: ns3::TracedValue<unsigned int> [class]

   173     root_module['ns3::TracedValue< unsigned int >'].implicitly_converts_to(root_module['ns3::UintegerValue'])

   174     ## traced-value.h: ns3::TracedValue<unsigned int> [class]

   175     root_module['ns3::TracedValue< unsigned int >'].implicitly_converts_to(root_module['ns3::BooleanValue'])

   176     ## traced-value.h: ns3::TracedValue<unsigned int> [class]

   177     root_module['ns3::TracedValue< unsigned int >'].implicitly_converts_to(root_module['ns3::EnumValue'])

   179     ## Register a nested module for the namespace Config

   181     nested_module = module.add_cpp_namespace('Config')

   182     register_types_ns3_Config(nested_module)

   185     ## Register a nested module for the namespace TimeStepPrecision

   187     nested_module = module.add_cpp_namespace('TimeStepPrecision')

   188     register_types_ns3_TimeStepPrecision(nested_module)

   191     ## Register a nested module for the namespace addressUtils

   193     nested_module = module.add_cpp_namespace('addressUtils')

   194     register_types_ns3_addressUtils(nested_module)

   197     ## Register a nested module for the namespace internal

   199     nested_module = module.add_cpp_namespace('internal')

   200     register_types_ns3_internal(nested_module)

   203     ## Register a nested module for the namespace olsr

   205     nested_module = module.add_cpp_namespace('olsr')

   206     register_types_ns3_olsr(nested_module)

   209 def register_types_ns3_Config(module):

   210     root_module = module.get_root()

   212     ## config.h: ns3::Config::MatchContainer [class]

   213     module.add_class('MatchContainer')

   214     module.add_container('std::vector< ns3::Ptr< ns3::Object > >', 'ns3::Ptr< ns3::Object >', container_type='vector')

   216 def register_types_ns3_TimeStepPrecision(module):

   217     root_module = module.get_root()

   220 def register_types_ns3_addressUtils(module):

   221     root_module = module.get_root()

   224 def register_types_ns3_internal(module):

   225     root_module = module.get_root()

   228 def register_types_ns3_olsr(module):

   229     root_module = module.get_root()

   232 def register_methods(root_module):

   233     register_Ns3AttributeList_methods(root_module, root_module['ns3::AttributeList'])

   234     register_Ns3CallbackBase_methods(root_module, root_module['ns3::CallbackBase'])

   235     register_Ns3CallbackImplBase_methods(root_module, root_module['ns3::CallbackImplBase'])

   236     register_Ns3CommandLine_methods(root_module, root_module['ns3::CommandLine'])

   237     register_Ns3CriticalSection_methods(root_module, root_module['ns3::CriticalSection'])

   238     register_Ns3GlobalValue_methods(root_module, root_module['ns3::GlobalValue'])

   239     register_Ns3IntToType__0_methods(root_module, root_module['ns3::IntToType< 0 >'])

   240     register_Ns3IntToType__1_methods(root_module, root_module['ns3::IntToType< 1 >'])

   241     register_Ns3IntToType__2_methods(root_module, root_module['ns3::IntToType< 2 >'])

   242     register_Ns3IntToType__3_methods(root_module, root_module['ns3::IntToType< 3 >'])

   243     register_Ns3IntToType__4_methods(root_module, root_module['ns3::IntToType< 4 >'])

   244     register_Ns3IntToType__5_methods(root_module, root_module['ns3::IntToType< 5 >'])

   245     register_Ns3IntToType__6_methods(root_module, root_module['ns3::IntToType< 6 >'])

   246     register_Ns3Names_methods(root_module, root_module['ns3::Names'])

   247     register_Ns3ObjectBase_methods(root_module, root_module['ns3::ObjectBase'])

   248     register_Ns3ObjectFactory_methods(root_module, root_module['ns3::ObjectFactory'])

   249     register_Ns3RandomVariable_methods(root_module, root_module['ns3::RandomVariable'])

   250     register_Ns3RefCountBase_methods(root_module, root_module['ns3::RefCountBase'])

   251     register_Ns3RngStream_methods(root_module, root_module['ns3::RngStream'])

   252     register_Ns3SeedManager_methods(root_module, root_module['ns3::SeedManager'])

   253     register_Ns3SequentialVariable_methods(root_module, root_module['ns3::SequentialVariable'])

   254     register_Ns3SystemCondition_methods(root_module, root_module['ns3::SystemCondition'])

   255     register_Ns3SystemMutex_methods(root_module, root_module['ns3::SystemMutex'])

   256     register_Ns3SystemThread_methods(root_module, root_module['ns3::SystemThread'])

   257     register_Ns3SystemWallClockMs_methods(root_module, root_module['ns3::SystemWallClockMs'])

   258     register_Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::TraceSourceAccessor'])

   259     register_Ns3TriangularVariable_methods(root_module, root_module['ns3::TriangularVariable'])

   260     register_Ns3TypeId_methods(root_module, root_module['ns3::TypeId'])

   261     register_Ns3TypeIdAttributeInfo_methods(root_module, root_module['ns3::TypeId::AttributeInfo'])

   262     register_Ns3UniformVariable_methods(root_module, root_module['ns3::UniformVariable'])

   263     register_Ns3UnsafeAttributeList_methods(root_module, root_module['ns3::UnsafeAttributeList'])

   264     register_Ns3WeibullVariable_methods(root_module, root_module['ns3::WeibullVariable'])

   265     register_Ns3ZipfVariable_methods(root_module, root_module['ns3::ZipfVariable'])

   266     register_Ns3Empty_methods(root_module, root_module['ns3::empty'])

   267     register_Ns3AttributeAccessor_methods(root_module, root_module['ns3::AttributeAccessor'])

   268     register_Ns3AttributeChecker_methods(root_module, root_module['ns3::AttributeChecker'])

   269     register_Ns3AttributeValue_methods(root_module, root_module['ns3::AttributeValue'])

   270     register_Ns3BooleanChecker_methods(root_module, root_module['ns3::BooleanChecker'])

   271     register_Ns3BooleanValue_methods(root_module, root_module['ns3::BooleanValue'])

   272     register_Ns3CallbackChecker_methods(root_module, root_module['ns3::CallbackChecker'])

   273     register_Ns3CallbackValue_methods(root_module, root_module['ns3::CallbackValue'])

   274     register_Ns3ConstantVariable_methods(root_module, root_module['ns3::ConstantVariable'])

   275     register_Ns3DeterministicVariable_methods(root_module, root_module['ns3::DeterministicVariable'])

   276     register_Ns3DoubleValue_methods(root_module, root_module['ns3::DoubleValue'])

   277     register_Ns3EmpiricalVariable_methods(root_module, root_module['ns3::EmpiricalVariable'])

   278     register_Ns3EmptyAttributeValue_methods(root_module, root_module['ns3::EmptyAttributeValue'])

   279     register_Ns3EnumChecker_methods(root_module, root_module['ns3::EnumChecker'])

   280     register_Ns3EnumValue_methods(root_module, root_module['ns3::EnumValue'])

   281     register_Ns3ErlangVariable_methods(root_module, root_module['ns3::ErlangVariable'])

   282     register_Ns3ExponentialVariable_methods(root_module, root_module['ns3::ExponentialVariable'])

   283     register_Ns3GammaVariable_methods(root_module, root_module['ns3::GammaVariable'])

   284     register_Ns3IntEmpiricalVariable_methods(root_module, root_module['ns3::IntEmpiricalVariable'])

   285     register_Ns3IntegerValue_methods(root_module, root_module['ns3::IntegerValue'])

   286     register_Ns3LogNormalVariable_methods(root_module, root_module['ns3::LogNormalVariable'])

   287     register_Ns3NormalVariable_methods(root_module, root_module['ns3::NormalVariable'])

   288     register_Ns3Object_methods(root_module, root_module['ns3::Object'])

   289     register_Ns3ObjectAggregateIterator_methods(root_module, root_module['ns3::Object::AggregateIterator'])

   290     register_Ns3ObjectFactoryChecker_methods(root_module, root_module['ns3::ObjectFactoryChecker'])

   291     register_Ns3ObjectFactoryValue_methods(root_module, root_module['ns3::ObjectFactoryValue'])

   292     register_Ns3ObjectVectorAccessor_methods(root_module, root_module['ns3::ObjectVectorAccessor'])

   293     register_Ns3ObjectVectorChecker_methods(root_module, root_module['ns3::ObjectVectorChecker'])

   294     register_Ns3ObjectVectorValue_methods(root_module, root_module['ns3::ObjectVectorValue'])

   295     register_Ns3ParetoVariable_methods(root_module, root_module['ns3::ParetoVariable'])

   296     register_Ns3PointerChecker_methods(root_module, root_module['ns3::PointerChecker'])

   297     register_Ns3PointerValue_methods(root_module, root_module['ns3::PointerValue'])

   298     register_Ns3RandomVariableChecker_methods(root_module, root_module['ns3::RandomVariableChecker'])

   299     register_Ns3RandomVariableValue_methods(root_module, root_module['ns3::RandomVariableValue'])

   300     register_Ns3StringChecker_methods(root_module, root_module['ns3::StringChecker'])

   301     register_Ns3StringValue_methods(root_module, root_module['ns3::StringValue'])

   302     register_Ns3TypeIdChecker_methods(root_module, root_module['ns3::TypeIdChecker'])

   303     register_Ns3TypeIdValue_methods(root_module, root_module['ns3::TypeIdValue'])

   304     register_Ns3UintegerValue_methods(root_module, root_module['ns3::UintegerValue'])

   305     register_Ns3TracedValue__Unsigned_int_methods(root_module, root_module['ns3::TracedValue< unsigned int >'])

   306     register_Ns3ConfigMatchContainer_methods(root_module, root_module['ns3::Config::MatchContainer'])

   307     return

   309 def register_Ns3AttributeList_methods(root_module, cls):

   310     ## attribute-list.h: ns3::AttributeList::AttributeList() [constructor]

   311     cls.add_constructor([])

   312     ## attribute-list.h: ns3::AttributeList::AttributeList(ns3::AttributeList const & o) [copy constructor]

   313     cls.add_constructor([param('ns3::AttributeList const &', 'o')])

   314     ## attribute-list.h: void ns3::AttributeList::Set(std::string name, ns3::AttributeValue const & value) [member function]

   315     cls.add_method('Set',

   316                    'void',

   317                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])

   318     ## attribute-list.h: bool ns3::AttributeList::SetFailSafe(std::string name, ns3::AttributeValue const & value) [member function]

   319     cls.add_method('SetFailSafe',

   320                    'bool',

   321                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])

   322     ## attribute-list.h: void ns3::AttributeList::SetWithTid(ns3::TypeId tid, std::string name, ns3::AttributeValue const & value) [member function]

   323     cls.add_method('SetWithTid',

   324                    'void',

   325                    [param('ns3::TypeId', 'tid'), param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])

   326     ## attribute-list.h: void ns3::AttributeList::Reset() [member function]

   327     cls.add_method('Reset',

   328                    'void',

   329                    [])

   330     ## attribute-list.h: static ns3::AttributeList * ns3::AttributeList::GetGlobal() [member function]

   331     cls.add_method('GetGlobal',

   332                    'ns3::AttributeList *',

   333                    [],

   334                    is_static=True)

   335     ## attribute-list.h: std::string ns3::AttributeList::SerializeToString() const [member function]

   336     cls.add_method('SerializeToString',

   337                    'std::string',

   338                    [],

   339                    is_const=True)

   340     ## attribute-list.h: bool ns3::AttributeList::DeserializeFromString(std::string value) [member function]

   341     cls.add_method('DeserializeFromString',

   342                    'bool',

   343                    [param('std::string', 'value')])

   344     return

   346 def register_Ns3CallbackBase_methods(root_module, cls):

   347     ## callback.h: ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [copy constructor]

   348     cls.add_constructor([param('ns3::CallbackBase const &', 'arg0')])

   349     ## callback.h: ns3::CallbackBase::CallbackBase() [constructor]

   350     cls.add_constructor([])

   351     ## callback.h: ns3::Ptr<ns3::CallbackImplBase> ns3::CallbackBase::GetImpl() const [member function]

   352     cls.add_method('GetImpl',

   353                    'ns3::Ptr< ns3::CallbackImplBase >',

   354                    [],

   355                    is_const=True)

   356     ## callback.h: ns3::CallbackBase::CallbackBase(ns3::Ptr<ns3::CallbackImplBase> impl) [constructor]

   357     cls.add_constructor([param('ns3::Ptr< ns3::CallbackImplBase >', 'impl')],

   358                         visibility='protected')

   359     ## callback.h: static std::string ns3::CallbackBase::Demangle(std::string const & mangled) [member function]

   360     cls.add_method('Demangle',

   361                    'std::string',

   362                    [param('std::string const &', 'mangled')],

   363                    is_static=True, visibility='protected')

   364     return

   366 def register_Ns3CallbackImplBase_methods(root_module, cls):

   367     ## callback.h: ns3::CallbackImplBase::CallbackImplBase(ns3::CallbackImplBase const & arg0) [copy constructor]

   368     cls.add_constructor([param('ns3::CallbackImplBase const &', 'arg0')])

   369     ## callback.h: ns3::CallbackImplBase::CallbackImplBase() [constructor]

   370     cls.add_constructor([])

   371     ## callback.h: bool ns3::CallbackImplBase::IsEqual(ns3::Ptr<ns3::CallbackImplBase const> other) const [member function]

   372     cls.add_method('IsEqual',

   373                    'bool',

   374                    [param('ns3::Ptr< ns3::CallbackImplBase const >', 'other')],

   375                    is_pure_virtual=True, is_const=True, is_virtual=True)

   376     return

   378 def register_Ns3CommandLine_methods(root_module, cls):

   379     ## command-line.h: ns3::CommandLine::CommandLine(ns3::CommandLine const & arg0) [copy constructor]

   380     cls.add_constructor([param('ns3::CommandLine const &', 'arg0')])

   381     ## command-line.h: ns3::CommandLine::CommandLine() [constructor]

   382     cls.add_constructor([])

   383     ## command-line.h: void ns3::CommandLine::AddValue(std::string const & name, std::string const & help, ns3::Callback<bool, std::string, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function]

   384     cls.add_method('AddValue',

   385                    'void',

   386                    [param('std::string const &', 'name'), param('std::string const &', 'help'), param('ns3::Callback< bool, std::string, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')])

   387     return

   389 def register_Ns3CriticalSection_methods(root_module, cls):

   390     ## system-mutex.h: ns3::CriticalSection::CriticalSection(ns3::CriticalSection const & arg0) [copy constructor]

   391     cls.add_constructor([param('ns3::CriticalSection const &', 'arg0')])

   392     ## system-mutex.h: ns3::CriticalSection::CriticalSection(ns3::SystemMutex & mutex) [constructor]

   393     cls.add_constructor([param('ns3::SystemMutex &', 'mutex')])

   394     return

   396 def register_Ns3GlobalValue_methods(root_module, cls):

   397     ## global-value.h: ns3::GlobalValue::GlobalValue(ns3::GlobalValue const & arg0) [copy constructor]

   398     cls.add_constructor([param('ns3::GlobalValue const &', 'arg0')])

   399     ## global-value.h: ns3::GlobalValue::GlobalValue(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr<ns3::AttributeChecker const> checker) [constructor]

   400     cls.add_constructor([param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')])

   401     ## global-value.h: std::string ns3::GlobalValue::GetName() const [member function]

   402     cls.add_method('GetName',

   403                    'std::string',

   404                    [],

   405                    is_const=True)

   406     ## global-value.h: std::string ns3::GlobalValue::GetHelp() const [member function]

   407     cls.add_method('GetHelp',

   408                    'std::string',

   409                    [],

   410                    is_const=True)

   411     ## global-value.h: void ns3::GlobalValue::GetValue(ns3::AttributeValue & value) const [member function]

   412     cls.add_method('GetValue',

   413                    'void',

   414                    [param('ns3::AttributeValue &', 'value')],

   415                    is_const=True)

   416     ## global-value.h: ns3::Ptr<ns3::AttributeChecker const> ns3::GlobalValue::GetChecker() const [member function]

   417     cls.add_method('GetChecker',

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

   419                    [],

   420                    is_const=True)

   421     ## global-value.h: bool ns3::GlobalValue::SetValue(ns3::AttributeValue const & value) [member function]

   422     cls.add_method('SetValue',

   423                    'bool',

   424                    [param('ns3::AttributeValue const &', 'value')])

   425     ## global-value.h: static void ns3::GlobalValue::Bind(std::string name, ns3::AttributeValue const & value) [member function]

   426     cls.add_method('Bind',

   427                    'void',

   428                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')],

   429                    is_static=True)

   430     ## global-value.h: static bool ns3::GlobalValue::BindFailSafe(std::string name, ns3::AttributeValue const & value) [member function]

   431     cls.add_method('BindFailSafe',

   432                    'bool',

   433                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')],

   434                    is_static=True)

   435     ## global-value.h: static __gnu_cxx::__normal_iterator<ns3::GlobalValue* const*,std::vector<ns3::GlobalValue*, std::allocator<ns3::GlobalValue*> > > ns3::GlobalValue::Begin() [member function]

   436     cls.add_method('Begin',

   437                    '__gnu_cxx::__normal_iterator< ns3::GlobalValue * const *, std::vector< ns3::GlobalValue * > >',

   438                    [],

   439                    is_static=True)

   440     ## global-value.h: static __gnu_cxx::__normal_iterator<ns3::GlobalValue* const*,std::vector<ns3::GlobalValue*, std::allocator<ns3::GlobalValue*> > > ns3::GlobalValue::End() [member function]

   441     cls.add_method('End',

   442                    '__gnu_cxx::__normal_iterator< ns3::GlobalValue * const *, std::vector< ns3::GlobalValue * > >',

   443                    [],

   444                    is_static=True)

   445     return

   447 def register_Ns3IntToType__0_methods(root_module, cls):

   448     ## int-to-type.h: ns3::IntToType<0>::IntToType(ns3::IntToType<0> const & arg0) [copy constructor]

   449     cls.add_constructor([param('ns3::IntToType< 0 > const &', 'arg0')])

   450     ## int-to-type.h: ns3::IntToType<0>::IntToType() [constructor]

   451     cls.add_constructor([])

   452     return

   454 def register_Ns3IntToType__1_methods(root_module, cls):

   455     ## int-to-type.h: ns3::IntToType<1>::IntToType(ns3::IntToType<1> const & arg0) [copy constructor]

   456     cls.add_constructor([param('ns3::IntToType< 1 > const &', 'arg0')])

   457     ## int-to-type.h: ns3::IntToType<1>::IntToType() [constructor]

   458     cls.add_constructor([])

   459     return

   461 def register_Ns3IntToType__2_methods(root_module, cls):

   462     ## int-to-type.h: ns3::IntToType<2>::IntToType(ns3::IntToType<2> const & arg0) [copy constructor]

   463     cls.add_constructor([param('ns3::IntToType< 2 > const &', 'arg0')])

   464     ## int-to-type.h: ns3::IntToType<2>::IntToType() [constructor]

   465     cls.add_constructor([])

   466     return

   468 def register_Ns3IntToType__3_methods(root_module, cls):

   469     ## int-to-type.h: ns3::IntToType<3>::IntToType(ns3::IntToType<3> const & arg0) [copy constructor]

   470     cls.add_constructor([param('ns3::IntToType< 3 > const &', 'arg0')])

   471     ## int-to-type.h: ns3::IntToType<3>::IntToType() [constructor]

   472     cls.add_constructor([])

   473     return

   475 def register_Ns3IntToType__4_methods(root_module, cls):

   476     ## int-to-type.h: ns3::IntToType<4>::IntToType(ns3::IntToType<4> const & arg0) [copy constructor]

   477     cls.add_constructor([param('ns3::IntToType< 4 > const &', 'arg0')])

   478     ## int-to-type.h: ns3::IntToType<4>::IntToType() [constructor]

   479     cls.add_constructor([])

   480     return

   482 def register_Ns3IntToType__5_methods(root_module, cls):

   483     ## int-to-type.h: ns3::IntToType<5>::IntToType(ns3::IntToType<5> const & arg0) [copy constructor]

   484     cls.add_constructor([param('ns3::IntToType< 5 > const &', 'arg0')])

   485     ## int-to-type.h: ns3::IntToType<5>::IntToType() [constructor]

   486     cls.add_constructor([])

   487     return

   489 def register_Ns3IntToType__6_methods(root_module, cls):

   490     ## int-to-type.h: ns3::IntToType<6>::IntToType(ns3::IntToType<6> const & arg0) [copy constructor]

   491     cls.add_constructor([param('ns3::IntToType< 6 > const &', 'arg0')])

   492     ## int-to-type.h: ns3::IntToType<6>::IntToType() [constructor]

   493     cls.add_constructor([])

   494     return

   496 def register_Ns3Names_methods(root_module, cls):

   497     ## names.h: ns3::Names::Names(ns3::Names const & arg0) [copy constructor]

   498     cls.add_constructor([param('ns3::Names const &', 'arg0')])

   499     ## names.h: ns3::Names::Names() [constructor]

   500     cls.add_constructor([])

   501     ## names.h: static void ns3::Names::Add(std::string name, ns3::Ptr<ns3::Object> object) [member function]

   502     cls.add_method('Add',

   503                    'void',

   504                    [param('std::string', 'name'), param('ns3::Ptr< ns3::Object >', 'object')],

   505                    is_static=True)

   506     ## names.h: static void ns3::Names::Add(std::string path, std::string name, ns3::Ptr<ns3::Object> object) [member function]

   507     cls.add_method('Add',

   508                    'void',

   509                    [param('std::string', 'path'), param('std::string', 'name'), param('ns3::Ptr< ns3::Object >', 'object')],

   510                    is_static=True)

   511     ## names.h: static void ns3::Names::Add(ns3::Ptr<ns3::Object> context, std::string name, ns3::Ptr<ns3::Object> object) [member function]

   512     cls.add_method('Add',

   513                    'void',

   514                    [param('ns3::Ptr< ns3::Object >', 'context'), param('std::string', 'name'), param('ns3::Ptr< ns3::Object >', 'object')],

   515                    is_static=True)

   516     ## names.h: static void ns3::Names::Rename(std::string oldpath, std::string newname) [member function]

   517     cls.add_method('Rename',

   518                    'void',

   519                    [param('std::string', 'oldpath'), param('std::string', 'newname')],

   520                    is_static=True)

   521     ## names.h: static void ns3::Names::Rename(std::string path, std::string oldname, std::string newname) [member function]

   522     cls.add_method('Rename',

   523                    'void',

   524                    [param('std::string', 'path'), param('std::string', 'oldname'), param('std::string', 'newname')],

   525                    is_static=True)

   526     ## names.h: static void ns3::Names::Rename(ns3::Ptr<ns3::Object> context, std::string oldname, std::string newname) [member function]

   527     cls.add_method('Rename',

   528                    'void',

   529                    [param('ns3::Ptr< ns3::Object >', 'context'), param('std::string', 'oldname'), param('std::string', 'newname')],

   530                    is_static=True)

   531     ## names.h: static std::string ns3::Names::FindName(ns3::Ptr<ns3::Object> object) [member function]

   532     cls.add_method('FindName',

   533                    'std::string',

   534                    [param('ns3::Ptr< ns3::Object >', 'object')],

   535                    is_static=True)

   536     ## names.h: static std::string ns3::Names::FindPath(ns3::Ptr<ns3::Object> object) [member function]

   537     cls.add_method('FindPath',

   538                    'std::string',

   539                    [param('ns3::Ptr< ns3::Object >', 'object')],

   540                    is_static=True)

   541     ## names.h: static void ns3::Names::Delete() [member function]

   542     cls.add_method('Delete',

   543                    'void',

   544                    [],

   545                    is_static=True)

   546     return

   548 def register_Ns3ObjectBase_methods(root_module, cls):

   549     ## object-base.h: ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [copy constructor]

   550     cls.add_constructor([param('ns3::ObjectBase const &', 'arg0')])

   551     ## object-base.h: ns3::ObjectBase::ObjectBase() [constructor]

   552     cls.add_constructor([])

   553     ## object-base.h: static ns3::TypeId ns3::ObjectBase::GetTypeId() [member function]

   554     cls.add_method('GetTypeId',

   555                    'ns3::TypeId',

   556                    [],

   557                    is_static=True)

   558     ## object-base.h: ns3::TypeId ns3::ObjectBase::GetInstanceTypeId() const [member function]

   559     cls.add_method('GetInstanceTypeId',

   560                    'ns3::TypeId',

   561                    [],

   562                    is_pure_virtual=True, is_const=True, is_virtual=True)

   563     ## object-base.h: void ns3::ObjectBase::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function]

   564     cls.add_method('SetAttribute',

   565                    'void',

   566                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])

   567     ## object-base.h: bool ns3::ObjectBase::SetAttributeFailSafe(std::string name, ns3::AttributeValue const & value) [member function]

   568     cls.add_method('SetAttributeFailSafe',

   569                    'bool',

   570                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])

   571     ## object-base.h: void ns3::ObjectBase::GetAttribute(std::string name, ns3::AttributeValue & value) const [member function]

   572     cls.add_method('GetAttribute',

   573                    'void',

   574                    [param('std::string', 'name'), param('ns3::AttributeValue &', 'value')],

   575                    is_const=True)

   576     ## object-base.h: bool ns3::ObjectBase::GetAttributeFailSafe(std::string name, ns3::AttributeValue & attribute) const [member function]

   577     cls.add_method('GetAttributeFailSafe',

   578                    'bool',

   579                    [param('std::string', 'name'), param('ns3::AttributeValue &', 'attribute')],

   580                    is_const=True)

   581     ## object-base.h: bool ns3::ObjectBase::TraceConnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function]

   582     cls.add_method('TraceConnect',

   583                    'bool',

   584                    [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')])

   585     ## object-base.h: bool ns3::ObjectBase::TraceConnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]

   586     cls.add_method('TraceConnectWithoutContext',

   587                    'bool',

   588                    [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])

   589     ## object-base.h: bool ns3::ObjectBase::TraceDisconnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function]

   590     cls.add_method('TraceDisconnect',

   591                    'bool',

   592                    [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')])

   593     ## object-base.h: bool ns3::ObjectBase::TraceDisconnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]

   594     cls.add_method('TraceDisconnectWithoutContext',

   595                    'bool',

   596                    [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])

   597     ## object-base.h: void ns3::ObjectBase::NotifyConstructionCompleted() [member function]

   598     cls.add_method('NotifyConstructionCompleted',

   599                    'void',

   600                    [],

   601                    visibility='protected', is_virtual=True)

   602     ## object-base.h: void ns3::ObjectBase::ConstructSelf(ns3::AttributeList const & attributes) [member function]

   603     cls.add_method('ConstructSelf',

   604                    'void',

   605                    [param('ns3::AttributeList const &', 'attributes')],

   606                    visibility='protected')

   607     return

   609 def register_Ns3ObjectFactory_methods(root_module, cls):

   610     cls.add_output_stream_operator()

   611     ## object-factory.h: ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [copy constructor]

   612     cls.add_constructor([param('ns3::ObjectFactory const &', 'arg0')])

   613     ## object-factory.h: ns3::ObjectFactory::ObjectFactory() [constructor]

   614     cls.add_constructor([])

   615     ## object-factory.h: ns3::Ptr<ns3::Object> ns3::ObjectFactory::Create() const [member function]

   616     cls.add_method('Create',

   617                    'ns3::Ptr< ns3::Object >',

   618                    [],

   619                    is_const=True)

   620     ## object-factory.h: ns3::TypeId ns3::ObjectFactory::GetTypeId() const [member function]

   621     cls.add_method('GetTypeId',

   622                    'ns3::TypeId',

   623                    [],

   624                    is_const=True)

   625     ## object-factory.h: void ns3::ObjectFactory::Set(std::string name, ns3::AttributeValue const & value) [member function]

   626     cls.add_method('Set',

   627                    'void',

   628                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])

   629     ## object-factory.h: void ns3::ObjectFactory::Set(ns3::AttributeList const & list) [member function]

   630     cls.add_method('Set',

   631                    'void',

   632                    [param('ns3::AttributeList const &', 'list')])

   633     ## object-factory.h: void ns3::ObjectFactory::SetTypeId(ns3::TypeId tid) [member function]

   634     cls.add_method('SetTypeId',

   635                    'void',

   636                    [param('ns3::TypeId', 'tid')])

   637     ## object-factory.h: void ns3::ObjectFactory::SetTypeId(char const * tid) [member function]

   638     cls.add_method('SetTypeId',

   639                    'void',

   640                    [param('char const *', 'tid')])

   641     ## object-factory.h: void ns3::ObjectFactory::SetTypeId(std::string tid) [member function]

   642     cls.add_method('SetTypeId',

   643                    'void',

   644                    [param('std::string', 'tid')])

   645     return

   647 def register_Ns3RandomVariable_methods(root_module, cls):

   648     cls.add_output_stream_operator()

   649     ## random-variable.h: ns3::RandomVariable::RandomVariable() [constructor]

   650     cls.add_constructor([])

   651     ## random-variable.h: ns3::RandomVariable::RandomVariable(ns3::RandomVariable const & o) [copy constructor]

   652     cls.add_constructor([param('ns3::RandomVariable const &', 'o')])

   653     ## random-variable.h: uint32_t ns3::RandomVariable::GetInteger() const [member function]

   654     cls.add_method('GetInteger',

   655                    'uint32_t',

   656                    [],

   657                    is_const=True)

   658     ## random-variable.h: double ns3::RandomVariable::GetValue() const [member function]

   659     cls.add_method('GetValue',

   660                    'double',

   661                    [],

   662                    is_const=True)

   663     return

   665 def register_Ns3RefCountBase_methods(root_module, cls):

   666     ## ref-count-base.h: ns3::RefCountBase::RefCountBase() [constructor]

   667     cls.add_constructor([])

   668     ## ref-count-base.h: ns3::RefCountBase::RefCountBase(ns3::RefCountBase const & o) [copy constructor]

   669     cls.add_constructor([param('ns3::RefCountBase const &', 'o')])

   670     return

   672 def register_Ns3RngStream_methods(root_module, cls):

   673     ## rng-stream.h: ns3::RngStream::RngStream() [constructor]

   674     cls.add_constructor([])

   675     ## rng-stream.h: ns3::RngStream::RngStream(ns3::RngStream const & arg0) [copy constructor]

   676     cls.add_constructor([param('ns3::RngStream const &', 'arg0')])

   677     ## rng-stream.h: void ns3::RngStream::InitializeStream() [member function]

   678     cls.add_method('InitializeStream',

   679                    'void',

   680                    [])

   681     ## rng-stream.h: void ns3::RngStream::ResetStartStream() [member function]

   682     cls.add_method('ResetStartStream',

   683                    'void',

   684                    [])

   685     ## rng-stream.h: void ns3::RngStream::ResetStartSubstream() [member function]

   686     cls.add_method('ResetStartSubstream',

   687                    'void',

   688                    [])

   689     ## rng-stream.h: void ns3::RngStream::ResetNextSubstream() [member function]

   690     cls.add_method('ResetNextSubstream',

   691                    'void',

   692                    [])

   693     ## rng-stream.h: void ns3::RngStream::ResetNthSubstream(uint32_t N) [member function]

   694     cls.add_method('ResetNthSubstream',

   695                    'void',

   696                    [param('uint32_t', 'N')])

   697     ## rng-stream.h: void ns3::RngStream::SetAntithetic(bool a) [member function]

   698     cls.add_method('SetAntithetic',

   699                    'void',

   700                    [param('bool', 'a')])

   701     ## rng-stream.h: void ns3::RngStream::IncreasedPrecis(bool incp) [member function]

   702     cls.add_method('IncreasedPrecis',

   703                    'void',

   704                    [param('bool', 'incp')])

   705     ## rng-stream.h: bool ns3::RngStream::SetSeeds(uint32_t const * seed) [member function]

   706     cls.add_method('SetSeeds',

   707                    'bool',

   708                    [param('uint32_t const *', 'seed')])

   709     ## rng-stream.h: void ns3::RngStream::AdvanceState(int32_t e, int32_t c) [member function]

   710     cls.add_method('AdvanceState',

   711                    'void',

   712                    [param('int32_t', 'e'), param('int32_t', 'c')])

   713     ## rng-stream.h: void ns3::RngStream::GetState(uint32_t * seed) const [member function]

   714     cls.add_method('GetState',

   715                    'void',

   716                    [param('uint32_t *', 'seed')],

   717                    is_const=True)

   718     ## rng-stream.h: double ns3::RngStream::RandU01() [member function]

   719     cls.add_method('RandU01',

   720                    'double',

   721                    [])

   722     ## rng-stream.h: int32_t ns3::RngStream::RandInt(int32_t i, int32_t j) [member function]

   723     cls.add_method('RandInt',

   724                    'int32_t',

   725                    [param('int32_t', 'i'), param('int32_t', 'j')])

   726     ## rng-stream.h: static bool ns3::RngStream::SetPackageSeed(uint32_t seed) [member function]

   727     cls.add_method('SetPackageSeed',

   728                    'bool',

   729                    [param('uint32_t', 'seed')],

   730                    is_static=True)

   731     ## rng-stream.h: static bool ns3::RngStream::SetPackageSeed(uint32_t const * seed) [member function]

   732     cls.add_method('SetPackageSeed',

   733                    'bool',

   734                    [param('uint32_t const *', 'seed')],

   735                    is_static=True)

   736     ## rng-stream.h: static void ns3::RngStream::GetPackageSeed(uint32_t * seed) [member function]

   737     cls.add_method('GetPackageSeed',

   738                    'void',

   739                    [param('uint32_t *', 'seed')],

   740                    is_static=True)

   741     ## rng-stream.h: static void ns3::RngStream::SetPackageRun(uint32_t run) [member function]

   742     cls.add_method('SetPackageRun',

   743                    'void',

   744                    [param('uint32_t', 'run')],

   745                    is_static=True)

   746     ## rng-stream.h: static uint32_t ns3::RngStream::GetPackageRun() [member function]

   747     cls.add_method('GetPackageRun',

   748                    'uint32_t',

   749                    [],

   750                    is_static=True)

   751     ## rng-stream.h: static bool ns3::RngStream::CheckSeed(uint32_t const * seed) [member function]

   752     cls.add_method('CheckSeed',

   753                    'bool',

   754                    [param('uint32_t const *', 'seed')],

   755                    is_static=True)

   756     ## rng-stream.h: static bool ns3::RngStream::CheckSeed(uint32_t seed) [member function]

   757     cls.add_method('CheckSeed',

   758                    'bool',

   759                    [param('uint32_t', 'seed')],

   760                    is_static=True)

   761     return

   763 def register_Ns3SeedManager_methods(root_module, cls):

   764     ## random-variable.h: ns3::SeedManager::SeedManager(ns3::SeedManager const & arg0) [copy constructor]

   765     cls.add_constructor([param('ns3::SeedManager const &', 'arg0')])

   766     ## random-variable.h: ns3::SeedManager::SeedManager() [constructor]

   767     cls.add_constructor([])

   768     ## random-variable.h: static void ns3::SeedManager::SetSeed(uint32_t seed) [member function]

   769     cls.add_method('SetSeed',

   770                    'void',

   771                    [param('uint32_t', 'seed')],

   772                    is_static=True)

   773     ## random-variable.h: static uint32_t ns3::SeedManager::GetSeed() [member function]

   774     cls.add_method('GetSeed',

   775                    'uint32_t',

   776                    [],

   777                    is_static=True)

   778     ## random-variable.h: static void ns3::SeedManager::SetRun(uint32_t run) [member function]

   779     cls.add_method('SetRun',

   780                    'void',

   781                    [param('uint32_t', 'run')],

   782                    is_static=True)

   783     ## random-variable.h: static uint32_t ns3::SeedManager::GetRun() [member function]

   784     cls.add_method('GetRun',

   785                    'uint32_t',

   786                    [],

   787                    is_static=True)

   788     ## random-variable.h: static bool ns3::SeedManager::CheckSeed(uint32_t seed) [member function]

   789     cls.add_method('CheckSeed',

   790                    'bool',

   791                    [param('uint32_t', 'seed')],

   792                    is_static=True)

   793     return

   795 def register_Ns3SequentialVariable_methods(root_module, cls):

   796     ## random-variable.h: ns3::SequentialVariable::SequentialVariable(ns3::SequentialVariable const & arg0) [copy constructor]

   797     cls.add_constructor([param('ns3::SequentialVariable const &', 'arg0')])

   798     ## random-variable.h: ns3::SequentialVariable::SequentialVariable(double f, double l, double i=1, uint32_t c=1) [constructor]

   799     cls.add_constructor([param('double', 'f'), param('double', 'l'), param('double', 'i', default_value='1'), param('uint32_t', 'c', default_value='1')])

   800     ## random-variable.h: ns3::SequentialVariable::SequentialVariable(double f, double l, ns3::RandomVariable const & i, uint32_t c=1) [constructor]

   801     cls.add_constructor([param('double', 'f'), param('double', 'l'), param('ns3::RandomVariable const &', 'i'), param('uint32_t', 'c', default_value='1')])

   802     return

   804 def register_Ns3SystemCondition_methods(root_module, cls):

   805     ## system-condition.h: ns3::SystemCondition::SystemCondition(ns3::SystemCondition const & arg0) [copy constructor]

   806     cls.add_constructor([param('ns3::SystemCondition const &', 'arg0')])

   807     ## system-condition.h: ns3::SystemCondition::SystemCondition() [constructor]

   808     cls.add_constructor([])

   809     ## system-condition.h: void ns3::SystemCondition::SetCondition(bool condition) [member function]

   810     cls.add_method('SetCondition',

   811                    'void',

   812                    [param('bool', 'condition')])

   813     ## system-condition.h: bool ns3::SystemCondition::GetCondition() [member function]

   814     cls.add_method('GetCondition',

   815                    'bool',

   816                    [])

   817     ## system-condition.h: void ns3::SystemCondition::Signal() [member function]

   818     cls.add_method('Signal',

   819                    'void',

   820                    [])

   821     ## system-condition.h: void ns3::SystemCondition::Broadcast() [member function]

   822     cls.add_method('Broadcast',

   823                    'void',

   824                    [])

   825     ## system-condition.h: void ns3::SystemCondition::Wait() [member function]

   826     cls.add_method('Wait',

   827                    'void',

   828                    [])

   829     ## system-condition.h: bool ns3::SystemCondition::TimedWait(uint64_t ns) [member function]

   830     cls.add_method('TimedWait',

   831                    'bool',

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

   833     return

   835 def register_Ns3SystemMutex_methods(root_module, cls):

   836     ## system-mutex.h: ns3::SystemMutex::SystemMutex(ns3::SystemMutex const & arg0) [copy constructor]

   837     cls.add_constructor([param('ns3::SystemMutex const &', 'arg0')])

   838     ## system-mutex.h: ns3::SystemMutex::SystemMutex() [constructor]

   839     cls.add_constructor([])

   840     ## system-mutex.h: void ns3::SystemMutex::Lock() [member function]

   841     cls.add_method('Lock',

   842                    'void',

   843                    [])

   844     ## system-mutex.h: void ns3::SystemMutex::Unlock() [member function]

   845     cls.add_method('Unlock',

   846                    'void',

   847                    [])

   848     return

   850 def register_Ns3SystemThread_methods(root_module, cls):

   851     ## system-thread.h: ns3::SystemThread::SystemThread(ns3::SystemThread const & arg0) [copy constructor]

   852     cls.add_constructor([param('ns3::SystemThread const &', 'arg0')])

   853     ## system-thread.h: ns3::SystemThread::SystemThread(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [constructor]

   854     cls.add_constructor([param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')])

   855     ## system-thread.h: void ns3::SystemThread::Ref() const [member function]

   856     cls.add_method('Ref',

   857                    'void',

   858                    [],

   859                    is_const=True)

   860     ## system-thread.h: void ns3::SystemThread::Unref() const [member function]

   861     cls.add_method('Unref',

   862                    'void',

   863                    [],

   864                    is_const=True)

   865     ## system-thread.h: void ns3::SystemThread::Start() [member function]

   866     cls.add_method('Start',

   867                    'void',

   868                    [])

   869     ## system-thread.h: void ns3::SystemThread::Join() [member function]

   870     cls.add_method('Join',

   871                    'void',

   872                    [])

   873     ## system-thread.h: void ns3::SystemThread::Shutdown() [member function]

   874     cls.add_method('Shutdown',

   875                    'void',

   876                    [])

   877     ## system-thread.h: bool ns3::SystemThread::Break() [member function]

   878     cls.add_method('Break',

   879                    'bool',

   880                    [])

   881     return

   883 def register_Ns3SystemWallClockMs_methods(root_module, cls):

   884     ## system-wall-clock-ms.h: ns3::SystemWallClockMs::SystemWallClockMs(ns3::SystemWallClockMs const & arg0) [copy constructor]

   885     cls.add_constructor([param('ns3::SystemWallClockMs const &', 'arg0')])

   886     ## system-wall-clock-ms.h: ns3::SystemWallClockMs::SystemWallClockMs() [constructor]

   887     cls.add_constructor([])

   888     ## system-wall-clock-ms.h: void ns3::SystemWallClockMs::Start() [member function]

   889     cls.add_method('Start',

   890                    'void',

   891                    [])

   892     ## system-wall-clock-ms.h: long long unsigned int ns3::SystemWallClockMs::End() [member function]

   893     cls.add_method('End',

   894                    'long long unsigned int',

   895                    [])

   896     return

   898 def register_Ns3TraceSourceAccessor_methods(root_module, cls):

   899     ## trace-source-accessor.h: ns3::TraceSourceAccessor::TraceSourceAccessor(ns3::TraceSourceAccessor const & arg0) [copy constructor]

   900     cls.add_constructor([param('ns3::TraceSourceAccessor const &', 'arg0')])

   901     ## trace-source-accessor.h: ns3::TraceSourceAccessor::TraceSourceAccessor() [constructor]

   902     cls.add_constructor([])

   903     ## trace-source-accessor.h: void ns3::TraceSourceAccessor::Ref() const [member function]

   904     cls.add_method('Ref',

   905                    'void',

   906                    [],

   907                    is_const=True)

   908     ## trace-source-accessor.h: void ns3::TraceSourceAccessor::Unref() const [member function]

   909     cls.add_method('Unref',

   910                    'void',

   911                    [],

   912                    is_const=True)

   913     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::ConnectWithoutContext(ns3::ObjectBase * obj, ns3::CallbackBase const & cb) const [member function]

   914     cls.add_method('ConnectWithoutContext',

   915                    'bool',

   916                    [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase const &', 'cb')],

   917                    is_pure_virtual=True, is_const=True, is_virtual=True)

   918     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::Connect(ns3::ObjectBase * obj, std::string context, ns3::CallbackBase const & cb) const [member function]

   919     cls.add_method('Connect',

   920                    'bool',

   921                    [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')],

   922                    is_pure_virtual=True, is_const=True, is_virtual=True)

   923     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::DisconnectWithoutContext(ns3::ObjectBase * obj, ns3::CallbackBase const & cb) const [member function]

   924     cls.add_method('DisconnectWithoutContext',

   925                    'bool',

   926                    [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase const &', 'cb')],

   927                    is_pure_virtual=True, is_const=True, is_virtual=True)

   928     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::Disconnect(ns3::ObjectBase * obj, std::string context, ns3::CallbackBase const & cb) const [member function]

   929     cls.add_method('Disconnect',

   930                    'bool',

   931                    [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')],

   932                    is_pure_virtual=True, is_const=True, is_virtual=True)

   933     return

   935 def register_Ns3TriangularVariable_methods(root_module, cls):

   936     ## random-variable.h: ns3::TriangularVariable::TriangularVariable(ns3::TriangularVariable const & arg0) [copy constructor]

   937     cls.add_constructor([param('ns3::TriangularVariable const &', 'arg0')])

   938     ## random-variable.h: ns3::TriangularVariable::TriangularVariable() [constructor]

   939     cls.add_constructor([])

   940     ## random-variable.h: ns3::TriangularVariable::TriangularVariable(double s, double l, double mean) [constructor]

   941     cls.add_constructor([param('double', 's'), param('double', 'l'), param('double', 'mean')])

   942     return

   944 def register_Ns3TypeId_methods(root_module, cls):

   945     cls.add_binary_comparison_operator('!=')

   946     cls.add_binary_comparison_operator('<')

   947     cls.add_output_stream_operator()

   948     cls.add_binary_comparison_operator('==')

   949     ## type-id.h: ns3::TypeId::TypeId(char const * name) [constructor]

   950     cls.add_constructor([param('char const *', 'name')])

   951     ## type-id.h: ns3::TypeId::TypeId() [constructor]

   952     cls.add_constructor([])

   953     ## type-id.h: ns3::TypeId::TypeId(ns3::TypeId const & o) [copy constructor]

   954     cls.add_constructor([param('ns3::TypeId const &', 'o')])

   955     ## type-id.h: ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr<ns3::AttributeAccessor const> accessor, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

   956     cls.add_method('AddAttribute',

   957                    'ns3::TypeId',

   958                    [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')])

   959     ## type-id.h: ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, uint32_t flags, ns3::AttributeValue const & initialValue, ns3::Ptr<ns3::AttributeAccessor const> accessor, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

   960     cls.add_method('AddAttribute',

   961                    'ns3::TypeId',

   962                    [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')])

   963     ## type-id.h: ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr<ns3::TraceSourceAccessor const> accessor) [member function]

   964     cls.add_method('AddTraceSource',

   965                    'ns3::TypeId',

   966                    [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')])

   967     ## type-id.h: ns3::Ptr<ns3::AttributeAccessor const> ns3::TypeId::GetAttributeAccessor(uint32_t i) const [member function]

   968     cls.add_method('GetAttributeAccessor',

   969                    'ns3::Ptr< ns3::AttributeAccessor const >',

   970                    [param('uint32_t', 'i')],

   971                    is_const=True)

   972     ## type-id.h: ns3::Ptr<ns3::AttributeChecker const> ns3::TypeId::GetAttributeChecker(uint32_t i) const [member function]

   973     cls.add_method('GetAttributeChecker',

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

   975                    [param('uint32_t', 'i')],

   976                    is_const=True)

   977     ## type-id.h: uint32_t ns3::TypeId::GetAttributeFlags(uint32_t i) const [member function]

   978     cls.add_method('GetAttributeFlags',

   979                    'uint32_t',

   980                    [param('uint32_t', 'i')],

   981                    is_const=True)

   982     ## type-id.h: std::string ns3::TypeId::GetAttributeFullName(uint32_t i) const [member function]

   983     cls.add_method('GetAttributeFullName',

   984                    'std::string',

   985                    [param('uint32_t', 'i')],

   986                    is_const=True)

   987     ## type-id.h: std::string ns3::TypeId::GetAttributeHelp(uint32_t i) const [member function]

   988     cls.add_method('GetAttributeHelp',

   989                    'std::string',

   990                    [param('uint32_t', 'i')],

   991                    is_const=True)

   992     ## type-id.h: ns3::Ptr<ns3::AttributeValue const> ns3::TypeId::GetAttributeInitialValue(uint32_t i) const [member function]

   993     cls.add_method('GetAttributeInitialValue',

   994                    'ns3::Ptr< ns3::AttributeValue const >',

   995                    [param('uint32_t', 'i')],

   996                    is_const=True)

   997     ## type-id.h: uint32_t ns3::TypeId::GetAttributeN() const [member function]

   998     cls.add_method('GetAttributeN',

   999                    'uint32_t',

  1000                    [],

  1001                    is_const=True)

  1002     ## type-id.h: std::string ns3::TypeId::GetAttributeName(uint32_t i) const [member function]

  1003     cls.add_method('GetAttributeName',

  1004                    'std::string',

  1005                    [param('uint32_t', 'i')],

  1006                    is_const=True)

  1007     ## type-id.h: ns3::Callback<ns3::ObjectBase*,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ns3::TypeId::GetConstructor() const [member function]

  1008     cls.add_method('GetConstructor',

  1009                    'ns3::Callback< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >',

  1010                    [],

  1011                    is_const=True)

  1012     ## type-id.h: std::string ns3::TypeId::GetGroupName() const [member function]

  1013     cls.add_method('GetGroupName',

  1014                    'std::string',

  1015                    [],

  1016                    is_const=True)

  1017     ## type-id.h: std::string ns3::TypeId::GetName() const [member function]

  1018     cls.add_method('GetName',

  1019                    'std::string',

  1020                    [],

  1021                    is_const=True)

  1022     ## type-id.h: ns3::TypeId ns3::TypeId::GetParent() const [member function]

  1023     cls.add_method('GetParent',

  1024                    'ns3::TypeId',

  1025                    [],

  1026                    is_const=True)

  1027     ## type-id.h: static ns3::TypeId ns3::TypeId::GetRegistered(uint32_t i) [member function]

  1028     cls.add_method('GetRegistered',

  1029                    'ns3::TypeId',

  1030                    [param('uint32_t', 'i')],

  1031                    is_static=True)

  1032     ## type-id.h: static uint32_t ns3::TypeId::GetRegisteredN() [member function]

  1033     cls.add_method('GetRegisteredN',

  1034                    'uint32_t',

  1035                    [],

  1036                    is_static=True)

  1037     ## type-id.h: ns3::Ptr<ns3::TraceSourceAccessor const> ns3::TypeId::GetTraceSourceAccessor(uint32_t i) const [member function]

  1038     cls.add_method('GetTraceSourceAccessor',

  1039                    'ns3::Ptr< ns3::TraceSourceAccessor const >',

  1040                    [param('uint32_t', 'i')],

  1041                    is_const=True)

  1042     ## type-id.h: std::string ns3::TypeId::GetTraceSourceHelp(uint32_t i) const [member function]

  1043     cls.add_method('GetTraceSourceHelp',

  1044                    'std::string',

  1045                    [param('uint32_t', 'i')],

  1046                    is_const=True)

  1047     ## type-id.h: uint32_t ns3::TypeId::GetTraceSourceN() const [member function]

  1048     cls.add_method('GetTraceSourceN',

  1049                    'uint32_t',

  1050                    [],

  1051                    is_const=True)

  1052     ## type-id.h: std::string ns3::TypeId::GetTraceSourceName(uint32_t i) const [member function]

  1053     cls.add_method('GetTraceSourceName',

  1054                    'std::string',

  1055                    [param('uint32_t', 'i')],

  1056                    is_const=True)

  1057     ## type-id.h: uint16_t ns3::TypeId::GetUid() const [member function]

  1058     cls.add_method('GetUid',

  1059                    'uint16_t',

  1060                    [],

  1061                    is_const=True)

  1062     ## type-id.h: bool ns3::TypeId::HasConstructor() const [member function]

  1063     cls.add_method('HasConstructor',

  1064                    'bool',

  1065                    [],

  1066                    is_const=True)

  1067     ## type-id.h: bool ns3::TypeId::HasParent() const [member function]

  1068     cls.add_method('HasParent',

  1069                    'bool',

  1070                    [],

  1071                    is_const=True)

  1072     ## type-id.h: ns3::TypeId ns3::TypeId::HideFromDocumentation() [member function]

  1073     cls.add_method('HideFromDocumentation',

  1074                    'ns3::TypeId',

  1075                    [])

  1076     ## type-id.h: bool ns3::TypeId::IsChildOf(ns3::TypeId other) const [member function]

  1077     cls.add_method('IsChildOf',

  1078                    'bool',

  1079                    [param('ns3::TypeId', 'other')],

  1080                    is_const=True)

  1081     ## type-id.h: static bool ns3::TypeId::LookupAttributeByFullName(std::string fullName, ns3::TypeId::AttributeInfo * info) [member function]

  1082     cls.add_method('LookupAttributeByFullName',

  1083                    'bool',

  1084                    [param('std::string', 'fullName'), param('ns3::TypeId::AttributeInfo *', 'info')],

  1085                    is_static=True)

  1086     ## type-id.h: bool ns3::TypeId::LookupAttributeByName(std::string name, ns3::TypeId::AttributeInfo * info) const [member function]

  1087     cls.add_method('LookupAttributeByName',

  1088                    'bool',

  1089                    [param('std::string', 'name'), param('ns3::TypeId::AttributeInfo *', 'info', transfer_ownership=False)],

  1090                    is_const=True)

  1091     ## type-id.h: static ns3::TypeId ns3::TypeId::LookupByName(std::string name) [member function]

  1092     cls.add_method('LookupByName',

  1093                    'ns3::TypeId',

  1094                    [param('std::string', 'name')],

  1095                    is_static=True)

  1096     ## type-id.h: ns3::Ptr<ns3::TraceSourceAccessor const> ns3::TypeId::LookupTraceSourceByName(std::string name) const [member function]

  1097     cls.add_method('LookupTraceSourceByName',

  1098                    'ns3::Ptr< ns3::TraceSourceAccessor const >',

  1099                    [param('std::string', 'name')],

  1100                    is_const=True)

  1101     ## type-id.h: bool ns3::TypeId::MustHideFromDocumentation() const [member function]

  1102     cls.add_method('MustHideFromDocumentation',

  1103                    'bool',

  1104                    [],

  1105                    is_const=True)

  1106     ## type-id.h: ns3::TypeId ns3::TypeId::SetGroupName(std::string groupName) [member function]

  1107     cls.add_method('SetGroupName',

  1108                    'ns3::TypeId',

  1109                    [param('std::string', 'groupName')])

  1110     ## type-id.h: ns3::TypeId ns3::TypeId::SetParent(ns3::TypeId tid) [member function]

  1111     cls.add_method('SetParent',

  1112                    'ns3::TypeId',

  1113                    [param('ns3::TypeId', 'tid')])

  1114     ## type-id.h: void ns3::TypeId::SetUid(uint16_t tid) [member function]

  1115     cls.add_method('SetUid',

  1116                    'void',

  1117                    [param('uint16_t', 'tid')])

  1118     return

  1120 def register_Ns3TypeIdAttributeInfo_methods(root_module, cls):

  1121     ## type-id.h: ns3::TypeId::AttributeInfo::accessor [variable]

  1122     cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::AttributeAccessor const >', is_const=False)

  1123     ## type-id.h: ns3::TypeId::AttributeInfo::initialValue [variable]

  1124     cls.add_instance_attribute('initialValue', 'ns3::Ptr< ns3::AttributeValue const >', is_const=False)

  1125     ## type-id.h: ns3::TypeId::AttributeInfo::flags [variable]

  1126     cls.add_instance_attribute('flags', 'uint32_t', is_const=False)

  1127     ## type-id.h: ns3::TypeId::AttributeInfo::checker [variable]

  1128     cls.add_instance_attribute('checker', 'ns3::Ptr< ns3::AttributeChecker const >', is_const=False)

  1129     ## type-id.h: ns3::TypeId::AttributeInfo::AttributeInfo(ns3::TypeId::AttributeInfo const & arg0) [copy constructor]

  1130     cls.add_constructor([param('ns3::TypeId::AttributeInfo const &', 'arg0')])

  1131     ## type-id.h: ns3::TypeId::AttributeInfo::AttributeInfo() [constructor]

  1132     cls.add_constructor([])

  1133     return

  1135 def register_Ns3UniformVariable_methods(root_module, cls):

  1136     ## random-variable.h: ns3::UniformVariable::UniformVariable(ns3::UniformVariable const & arg0) [copy constructor]

  1137     cls.add_constructor([param('ns3::UniformVariable const &', 'arg0')])

  1138     ## random-variable.h: ns3::UniformVariable::UniformVariable() [constructor]

  1139     cls.add_constructor([])

  1140     ## random-variable.h: ns3::UniformVariable::UniformVariable(double s, double l) [constructor]

  1141     cls.add_constructor([param('double', 's'), param('double', 'l')])

  1142     ## random-variable.h: double ns3::UniformVariable::GetValue() const [member function]

  1143     cls.add_method('GetValue',

  1144                    'double',

  1145                    [],

  1146                    is_const=True)

  1147     ## random-variable.h: double ns3::UniformVariable::GetValue(double s, double l) [member function]

  1148     cls.add_method('GetValue',

  1149                    'double',

  1150                    [param('double', 's'), param('double', 'l')])

  1151     ## random-variable.h: uint32_t ns3::UniformVariable::GetInteger(uint32_t s, uint32_t l) [member function]

  1152     cls.add_method('GetInteger',

  1153                    'uint32_t',

  1154                    [param('uint32_t', 's'), param('uint32_t', 'l')])

  1155     return

  1157 def register_Ns3UnsafeAttributeList_methods(root_module, cls):

  1158     ## attribute-list.h: ns3::UnsafeAttributeList::UnsafeAttributeList() [constructor]

  1159     cls.add_constructor([])

  1160     ## attribute-list.h: ns3::UnsafeAttributeList::UnsafeAttributeList(ns3::UnsafeAttributeList const & o) [copy constructor]

  1161     cls.add_constructor([param('ns3::UnsafeAttributeList const &', 'o')])

  1162     ## attribute-list.h: void ns3::UnsafeAttributeList::Set(std::string name, ns3::AttributeValue const & param) [member function]

  1163     cls.add_method('Set',

  1164                    'void',

  1165                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'param')])

  1166     ## attribute-list.h: ns3::AttributeList ns3::UnsafeAttributeList::GetSafe(std::string name) const [member function]

  1167     cls.add_method('GetSafe',

  1168                    'ns3::AttributeList',

  1169                    [param('std::string', 'name')],

  1170                    is_const=True)

  1171     return

  1173 def register_Ns3WeibullVariable_methods(root_module, cls):

  1174     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(ns3::WeibullVariable const & arg0) [copy constructor]

  1175     cls.add_constructor([param('ns3::WeibullVariable const &', 'arg0')])

  1176     ## random-variable.h: ns3::WeibullVariable::WeibullVariable() [constructor]

  1177     cls.add_constructor([])

  1178     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(double m) [constructor]

  1179     cls.add_constructor([param('double', 'm')])

  1180     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(double m, double s) [constructor]

  1181     cls.add_constructor([param('double', 'm'), param('double', 's')])

  1182     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(double m, double s, double b) [constructor]

  1183     cls.add_constructor([param('double', 'm'), param('double', 's'), param('double', 'b')])

  1184     return

  1186 def register_Ns3ZipfVariable_methods(root_module, cls):

  1187     ## random-variable.h: ns3::ZipfVariable::ZipfVariable(ns3::ZipfVariable const & arg0) [copy constructor]

  1188     cls.add_constructor([param('ns3::ZipfVariable const &', 'arg0')])

  1189     ## random-variable.h: ns3::ZipfVariable::ZipfVariable(long int n, double alpha) [constructor]

  1190     cls.add_constructor([param('long int', 'n'), param('double', 'alpha')])

  1191     ## random-variable.h: ns3::ZipfVariable::ZipfVariable() [constructor]

  1192     cls.add_constructor([])

  1193     return

  1195 def register_Ns3Empty_methods(root_module, cls):

  1196     ## empty.h: ns3::empty::empty(ns3::empty const & arg0) [copy constructor]

  1197     cls.add_constructor([param('ns3::empty const &', 'arg0')])

  1198     ## empty.h: ns3::empty::empty() [constructor]

  1199     cls.add_constructor([])

  1200     return

  1202 def register_Ns3AttributeAccessor_methods(root_module, cls):

  1203     ## attribute.h: ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [copy constructor]

  1204     cls.add_constructor([param('ns3::AttributeAccessor const &', 'arg0')])

  1205     ## attribute.h: ns3::AttributeAccessor::AttributeAccessor() [constructor]

  1206     cls.add_constructor([])

  1207     ## attribute.h: bool ns3::AttributeAccessor::Set(ns3::ObjectBase * object, ns3::AttributeValue const & value) const [member function]

  1208     cls.add_method('Set',

  1209                    'bool',

  1210                    [param('ns3::ObjectBase *', 'object', transfer_ownership=False), param('ns3::AttributeValue const &', 'value')],

  1211                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1212     ## attribute.h: bool ns3::AttributeAccessor::Get(ns3::ObjectBase const * object, ns3::AttributeValue & attribute) const [member function]

  1213     cls.add_method('Get',

  1214                    'bool',

  1215                    [param('ns3::ObjectBase const *', 'object'), param('ns3::AttributeValue &', 'attribute')],

  1216                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1217     ## attribute.h: bool ns3::AttributeAccessor::HasGetter() const [member function]

  1218     cls.add_method('HasGetter',

  1219                    'bool',

  1220                    [],

  1221                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1222     ## attribute.h: bool ns3::AttributeAccessor::HasSetter() const [member function]

  1223     cls.add_method('HasSetter',

  1224                    'bool',

  1225                    [],

  1226                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1227     return

  1229 def register_Ns3AttributeChecker_methods(root_module, cls):

  1230     ## attribute.h: ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [copy constructor]

  1231     cls.add_constructor([param('ns3::AttributeChecker const &', 'arg0')])

  1232     ## attribute.h: ns3::AttributeChecker::AttributeChecker() [constructor]

  1233     cls.add_constructor([])

  1234     ## attribute.h: bool ns3::AttributeChecker::Check(ns3::AttributeValue const & value) const [member function]

  1235     cls.add_method('Check',

  1236                    'bool',

  1237                    [param('ns3::AttributeValue const &', 'value')],

  1238                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1239     ## attribute.h: std::string ns3::AttributeChecker::GetValueTypeName() const [member function]

  1240     cls.add_method('GetValueTypeName',

  1241                    'std::string',

  1242                    [],

  1243                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1244     ## attribute.h: bool ns3::AttributeChecker::HasUnderlyingTypeInformation() const [member function]

  1245     cls.add_method('HasUnderlyingTypeInformation',

  1246                    'bool',

  1247                    [],

  1248                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1249     ## attribute.h: std::string ns3::AttributeChecker::GetUnderlyingTypeInformation() const [member function]

  1250     cls.add_method('GetUnderlyingTypeInformation',

  1251                    'std::string',

  1252                    [],

  1253                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1254     ## attribute.h: ns3::Ptr<ns3::AttributeValue> ns3::AttributeChecker::Create() const [member function]

  1255     cls.add_method('Create',

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

  1257                    [],

  1258                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1259     ## attribute.h: bool ns3::AttributeChecker::Copy(ns3::AttributeValue const & source, ns3::AttributeValue & destination) const [member function]

  1260     cls.add_method('Copy',

  1261                    'bool',

  1262                    [param('ns3::AttributeValue const &', 'source'), param('ns3::AttributeValue &', 'destination')],

  1263                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1264     return

  1266 def register_Ns3AttributeValue_methods(root_module, cls):

  1267     ## attribute.h: ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [copy constructor]

  1268     cls.add_constructor([param('ns3::AttributeValue const &', 'arg0')])

  1269     ## attribute.h: ns3::AttributeValue::AttributeValue() [constructor]

  1270     cls.add_constructor([])

  1271     ## attribute.h: ns3::Ptr<ns3::AttributeValue> ns3::AttributeValue::Copy() const [member function]

  1272     cls.add_method('Copy',

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

  1274                    [],

  1275                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1276     ## attribute.h: std::string ns3::AttributeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

  1277     cls.add_method('SerializeToString',

  1278                    'std::string',

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

  1280                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1281     ## attribute.h: bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

  1282     cls.add_method('DeserializeFromString',

  1283                    'bool',

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

  1285                    is_pure_virtual=True, is_virtual=True)

  1286     return

  1288 def register_Ns3BooleanChecker_methods(root_module, cls):

  1289     ## boolean.h: ns3::BooleanChecker::BooleanChecker(ns3::BooleanChecker const & arg0) [copy constructor]

  1290     cls.add_constructor([param('ns3::BooleanChecker const &', 'arg0')])

  1291     ## boolean.h: ns3::BooleanChecker::BooleanChecker() [constructor]

  1292     cls.add_constructor([])

  1293     return

  1295 def register_Ns3BooleanValue_methods(root_module, cls):

  1296     cls.add_output_stream_operator()

  1297     ## boolean.h: ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [copy constructor]

  1298     cls.add_constructor([param('ns3::BooleanValue const &', 'arg0')])

  1299     ## boolean.h: ns3::BooleanValue::BooleanValue() [constructor]

  1300     cls.add_constructor([])

  1301     ## boolean.h: ns3::BooleanValue::BooleanValue(bool value) [constructor]

  1302     cls.add_constructor([param('bool', 'value')])

  1303     ## boolean.h: ns3::Ptr<ns3::AttributeValue> ns3::BooleanValue::Copy() const [member function]

  1304     cls.add_method('Copy',

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

  1306                    [],

  1307                    is_const=True, is_virtual=True)

  1308     ## boolean.h: bool ns3::BooleanValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

  1309     cls.add_method('DeserializeFromString',

  1310                    'bool',

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

  1312                    is_virtual=True)

  1313     ## boolean.h: bool ns3::BooleanValue::Get() const [member function]

  1314     cls.add_method('Get',

  1315                    'bool',

  1316                    [],

  1317                    is_const=True)

  1318     ## boolean.h: std::string ns3::BooleanValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

  1319     cls.add_method('SerializeToString',

  1320                    'std::string',

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

  1322                    is_const=True, is_virtual=True)

  1323     ## boolean.h: void ns3::BooleanValue::Set(bool value) [member function]

  1324     cls.add_method('Set',

  1325                    'void',

  1326                    [param('bool', 'value')])

  1327     return

  1329 def register_Ns3CallbackChecker_methods(root_module, cls):

  1330     ## callback.h: ns3::CallbackChecker::CallbackChecker(ns3::CallbackChecker const & arg0) [copy constructor]

  1331     cls.add_constructor([param('ns3::CallbackChecker const &', 'arg0')])

  1332     ## callback.h: ns3::CallbackChecker::CallbackChecker() [constructor]

  1333     cls.add_constructor([])

  1334     return

  1336 def register_Ns3CallbackValue_methods(root_module, cls):

  1337     ## callback.h: ns3::CallbackValue::CallbackValue(ns3::CallbackValue const & arg0) [copy constructor]

  1338     cls.add_constructor([param('ns3::CallbackValue const &', 'arg0')])

  1339     ## callback.h: ns3::CallbackValue::CallbackValue() [constructor]

  1340     cls.add_constructor([])

  1341     ## callback.h: ns3::CallbackValue::CallbackValue(ns3::CallbackBase const & base) [constructor]

  1342     cls.add_constructor([param('ns3::CallbackBase const &', 'base')])

  1343     ## callback.h: void ns3::CallbackValue::Set(ns3::CallbackBase base) [member function]

  1344     cls.add_method('Set',

  1345                    'void',

  1346                    [param('ns3::CallbackBase', 'base')])

  1347     ## callback.h: ns3::Ptr<ns3::AttributeValue> ns3::CallbackValue::Copy() const [member function]

  1348     cls.add_method('Copy',

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

  1350                    [],

  1351                    is_const=True, is_virtual=True)

  1352     ## callback.h: std::string ns3::CallbackValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

  1353     cls.add_method('SerializeToString',

  1354                    'std::string',

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

  1356                    is_const=True, is_virtual=True)

  1357     ## callback.h: bool ns3::CallbackValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

  1358     cls.add_method('DeserializeFromString',

  1359                    'bool',

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

  1361                    is_virtual=True)

  1362     return

  1364 def register_Ns3ConstantVariable_methods(root_module, cls):

  1365     ## random-variable.h: ns3::ConstantVariable::ConstantVariable(ns3::ConstantVariable const & arg0) [copy constructor]

  1366     cls.add_constructor([param('ns3::ConstantVariable const &', 'arg0')])

  1367     ## random-variable.h: ns3::ConstantVariable::ConstantVariable() [constructor]

  1368     cls.add_constructor([])

  1369     ## random-variable.h: ns3::ConstantVariable::ConstantVariable(double c) [constructor]

  1370     cls.add_constructor([param('double', 'c')])

  1371     ## random-variable.h: void ns3::ConstantVariable::SetConstant(double c) [member function]

  1372     cls.add_method('SetConstant',

  1373                    'void',

  1374                    [param('double', 'c')])

  1375     return

  1377 def register_Ns3DeterministicVariable_methods(root_module, cls):

  1378     ## random-variable.h: ns3::DeterministicVariable::DeterministicVariable(ns3::DeterministicVariable const & arg0) [copy constructor]

  1379     cls.add_constructor([param('ns3::DeterministicVariable const &', 'arg0')])

  1380     ## random-variable.h: ns3::DeterministicVariable::DeterministicVariable(double * d, uint32_t c) [constructor]

  1381     cls.add_constructor([param('double *', 'd'), param('uint32_t', 'c')])

  1382     return

  1384 def register_Ns3DoubleValue_methods(root_module, cls):

  1385     ## double.h: ns3::DoubleValue::DoubleValue(ns3::DoubleValue const & arg0) [copy constructor]

  1386     cls.add_constructor([param('ns3::DoubleValue const &', 'arg0')])

  1387     ## double.h: ns3::DoubleValue::DoubleValue() [constructor]

  1388     cls.add_constructor([])

  1389     ## double.h: ns3::DoubleValue::DoubleValue(double const & value) [constructor]

  1390     cls.add_constructor([param('double const &', 'value')])

  1391     ## double.h: void ns3::DoubleValue::Set(double const & value) [member function]

  1392     cls.add_method('Set',

  1393                    'void',

  1394                    [param('double const &', 'value')])

  1395     ## double.h: double ns3::DoubleValue::Get() const [member function]

  1396     cls.add_method('Get',

  1397                    'double',

  1398                    [],

  1399                    is_const=True)

  1400     ## double.h: ns3::Ptr<ns3::AttributeValue> ns3::DoubleValue::Copy() const [member function]

  1401     cls.add_method('Copy',

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

  1403                    [],

  1404                    is_const=True, is_virtual=True)

  1405     ## double.h: std::string ns3::DoubleValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

  1406     cls.add_method('SerializeToString',

  1407                    'std::string',

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

  1409                    is_const=True, is_virtual=True)

  1410     ## double.h: bool ns3::DoubleValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

  1411     cls.add_method('DeserializeFromString',

  1412                    'bool',

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

  1414                    is_virtual=True)

  1415     return

  1417 def register_Ns3EmpiricalVariable_methods(root_module, cls):

  1418     ## random-variable.h: ns3::EmpiricalVariable::EmpiricalVariable(ns3::EmpiricalVariable const & arg0) [copy constructor]

  1419     cls.add_constructor([param('ns3::EmpiricalVariable const &', 'arg0')])

  1420     ## random-variable.h: ns3::EmpiricalVariable::EmpiricalVariable() [constructor]

  1421     cls.add_constructor([])

  1422     ## random-variable.h: void ns3::EmpiricalVariable::CDF(double v, double c) [member function]

  1423     cls.add_method('CDF',

  1424                    'void',

  1425                    [param('double', 'v'), param('double', 'c')])

  1426     return

  1428 def register_Ns3EmptyAttributeValue_methods(root_module, cls):

  1429     ## attribute.h: ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [copy constructor]

  1430     cls.add_constructor([param('ns3::EmptyAttributeValue const &', 'arg0')])

  1431     ## attribute.h: ns3::EmptyAttributeValue::EmptyAttributeValue() [constructor]

  1432     cls.add_constructor([])

  1433     ## attribute.h: ns3::Ptr<ns3::AttributeValue> ns3::EmptyAttributeValue::Copy() const [member function]

  1434     cls.add_method('Copy',

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

  1436                    [],

  1437                    is_const=True, visibility='private', is_virtual=True)

  1438     ## attribute.h: std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

  1439     cls.add_method('SerializeToString',

  1440                    'std::string',

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

  1442                    is_const=True, visibility='private', is_virtual=True)

  1443     ## attribute.h: bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

  1444     cls.add_method('DeserializeFromString',

  1445                    'bool',

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

  1447                    visibility='private', is_virtual=True)

  1448     return

  1450 def register_Ns3EnumChecker_methods(root_module, cls):

  1451     ## enum.h: ns3::EnumChecker::EnumChecker(ns3::EnumChecker const & arg0) [copy constructor]

  1452     cls.add_constructor([param('ns3::EnumChecker const &', 'arg0')])

  1453     ## enum.h: ns3::EnumChecker::EnumChecker() [constructor]

  1454     cls.add_constructor([])

  1455     ## enum.h: void ns3::EnumChecker::AddDefault(int v, std::string name) [member function]

  1456     cls.add_method('AddDefault',

  1457                    'void',

  1458                    [param('int', 'v'), param('std::string', 'name')])

  1459     ## enum.h: void ns3::EnumChecker::Add(int v, std::string name) [member function]

  1460     cls.add_method('Add',

  1461                    'void',

  1462                    [param('int', 'v'), param('std::string', 'name')])

  1463     ## enum.h: bool ns3::EnumChecker::Check(ns3::AttributeValue const & value) const [member function]

  1464     cls.add_method('Check',

  1465                    'bool',

  1466                    [param('ns3::AttributeValue const &', 'value')],

  1467                    is_const=True, is_virtual=True)

  1468     ## enum.h: std::string ns3::EnumChecker::GetValueTypeName() const [member function]

  1469     cls.add_method('GetValueTypeName',

  1470                    'std::string',

  1471                    [],

  1472                    is_const=True, is_virtual=True)

  1473     ## enum.h: bool ns3::EnumChecker::HasUnderlyingTypeInformation() const [member function]

  1474     cls.add_method('HasUnderlyingTypeInformation',

  1475                    'bool',

  1476                    [],

  1477                    is_const=True, is_virtual=True)

  1478     ## enum.h: std::string ns3::EnumChecker::GetUnderlyingTypeInformation() const [member function]

  1479     cls.add_method('GetUnderlyingTypeInformation',

  1480                    'std::string',

  1481                    [],

  1482                    is_const=True, is_virtual=True)

  1483     ## enum.h: ns3::Ptr<ns3::AttributeValue> ns3::EnumChecker::Create() const [member function]

  1484     cls.add_method('Create',

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

  1486                    [],

  1487                    is_const=True, is_virtual=True)

  1488     ## enum.h: bool ns3::EnumChecker::Copy(ns3::AttributeValue const & src, ns3::AttributeValue & dst) const [member function]

  1489     cls.add_method('Copy',

  1490                    'bool',

  1491                    [param('ns3::AttributeValue const &', 'src'), param('ns3::AttributeValue &', 'dst')],

  1492                    is_const=True, is_virtual=True)

  1493     return

  1495 def register_Ns3EnumValue_methods(root_module, cls):

  1496     ## enum.h: ns3::EnumValue::EnumValue(ns3::EnumValue const & arg0) [copy constructor]

  1497     cls.add_constructor([param('ns3::EnumValue const &', 'arg0')])

  1498     ## enum.h: ns3::EnumValue::EnumValue() [constructor]

  1499     cls.add_constructor([])

  1500     ## enum.h: ns3::EnumValue::EnumValue(int v) [constructor]

  1501     cls.add_constructor([param('int', 'v')])

  1502     ## enum.h: void ns3::EnumValue::Set(int v) [member function]

  1503     cls.add_method('Set',

  1504                    'void',

  1505                    [param('int', 'v')])

  1506     ## enum.h: int ns3::EnumValue::Get() const [member function]

  1507     cls.add_method('Get',

  1508                    'int',

  1509                    [],

  1510                    is_const=True)

  1511     ## enum.h: ns3::Ptr<ns3::AttributeValue> ns3::EnumValue::Copy() const [member function]

  1512     cls.add_method('Copy',

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

  1514                    [],

  1515                    is_const=True, is_virtual=True)

  1516     ## enum.h: std::string ns3::EnumValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

  1517     cls.add_method('SerializeToString',

  1518                    'std::string',

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

  1520                    is_const=True, is_virtual=True)

  1521     ## enum.h: bool ns3::EnumValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

  1522     cls.add_method('DeserializeFromString',

  1523                    'bool',

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

  1525                    is_virtual=True)

  1526     return

  1528 def register_Ns3ErlangVariable_methods(root_module, cls):

  1529     ## random-variable.h: ns3::ErlangVariable::ErlangVariable(ns3::ErlangVariable const & arg0) [copy constructor]

  1530     cls.add_constructor([param('ns3::ErlangVariable const &', 'arg0')])

  1531     ## random-variable.h: ns3::ErlangVariable::ErlangVariable() [constructor]

  1532     cls.add_constructor([])

  1533     ## random-variable.h: ns3::ErlangVariable::ErlangVariable(unsigned int k, double lambda) [constructor]

  1534     cls.add_constructor([param('unsigned int', 'k'), param('double', 'lambda')])

  1535     ## random-variable.h: double ns3::ErlangVariable::GetValue() const [member function]

  1536     cls.add_method('GetValue',

  1537                    'double',

  1538                    [],

  1539                    is_const=True)

  1540     ## random-variable.h: double ns3::ErlangVariable::GetValue(unsigned int k, double lambda) const [member function]

  1541     cls.add_method('GetValue',

  1542                    'double',

  1543                    [param('unsigned int', 'k'), param('double', 'lambda')],

  1544                    is_const=True)

  1545     return

  1547 def register_Ns3ExponentialVariable_methods(root_module, cls):

  1548     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable(ns3::ExponentialVariable const & arg0) [copy constructor]

  1549     cls.add_constructor([param('ns3::ExponentialVariable const &', 'arg0')])

  1550     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable() [constructor]

  1551     cls.add_constructor([])

  1552     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable(double m) [constructor]

  1553     cls.add_constructor([param('double', 'm')])

  1554     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable(double m, double b) [constructor]

  1555     cls.add_constructor([param('double', 'm'), param('double', 'b')])

  1556     return

  1558 def register_Ns3GammaVariable_methods(root_module, cls):

  1559     ## random-variable.h: ns3::GammaVariable::GammaVariable(ns3::GammaVariable const & arg0) [copy constructor]

  1560     cls.add_constructor([param('ns3::GammaVariable const &', 'arg0')])

  1561     ## random-variable.h: ns3::GammaVariable::GammaVariable() [constructor]

  1562     cls.add_constructor([])

  1563     ## random-variable.h: ns3::GammaVariable::GammaVariable(double alpha, double beta) [constructor]

  1564     cls.add_constructor([param('double', 'alpha'), param('double', 'beta')])

  1565     ## random-variable.h: double ns3::GammaVariable::GetValue() const [member function]

  1566     cls.add_method('GetValue',

  1567                    'double',

  1568                    [],

  1569                    is_const=True)

  1570     ## random-variable.h: double ns3::GammaVariable::GetValue(double alpha, double beta) const [member function]

  1571     cls.add_method('GetValue',

  1572                    'double',

  1573                    [param('double', 'alpha'), param('double', 'beta')],

  1574                    is_const=True)

  1575     return

  1577 def register_Ns3IntEmpiricalVariable_methods(root_module, cls):

  1578     ## random-variable.h: ns3::IntEmpiricalVariable::IntEmpiricalVariable(ns3::IntEmpiricalVariable const & arg0) [copy constructor]

  1579     cls.add_constructor([param('ns3::IntEmpiricalVariable const &', 'arg0')])

  1580     ## random-variable.h: ns3::IntEmpiricalVariable::IntEmpiricalVariable() [constructor]

  1581     cls.add_constructor([])

  1582     return

  1584 def register_Ns3IntegerValue_methods(root_module, cls):

  1585     ## integer.h: ns3::IntegerValue::IntegerValue(ns3::IntegerValue const & arg0) [copy constructor]

  1586     cls.add_constructor([param('ns3::IntegerValue const &', 'arg0')])

  1587     ## integer.h: ns3::IntegerValue::IntegerValue() [constructor]

  1588     cls.add_constructor([])

  1589     ## integer.h: ns3::IntegerValue::IntegerValue(int64_t const & value) [constructor]

  1590     cls.add_constructor([param('int64_t const &', 'value')])

  1591     ## integer.h: void ns3::IntegerValue::Set(int64_t const & value) [member function]

  1592     cls.add_method('Set',

  1593                    'void',

  1594                    [param('int64_t const &', 'value')])

  1595     ## integer.h: int64_t ns3::IntegerValue::Get() const [member function]

  1596     cls.add_method('Get',

  1597                    'int64_t',

  1598                    [],

  1599                    is_const=True)

  1600     ## integer.h: ns3::Ptr<ns3::AttributeValue> ns3::IntegerValue::Copy() const [member function]

  1601     cls.add_method('Copy',

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

  1603                    [],

  1604                    is_const=True, is_virtual=True)

  1605     ## integer.h: std::string ns3::IntegerValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

  1606     cls.add_method('SerializeToString',

  1607                    'std::string',

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

  1609                    is_const=True, is_virtual=True)

  1610     ## integer.h: bool ns3::IntegerValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

  1611     cls.add_method('DeserializeFromString',

  1612                    'bool',

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

  1614                    is_virtual=True)

  1615     return

  1617 def register_Ns3LogNormalVariable_methods(root_module, cls):

  1618     ## random-variable.h: ns3::LogNormalVariable::LogNormalVariable(ns3::LogNormalVariable const & arg0) [copy constructor]

  1619     cls.add_constructor([param('ns3::LogNormalVariable const &', 'arg0')])

  1620     ## random-variable.h: ns3::LogNormalVariable::LogNormalVariable(double mu, double sigma) [constructor]

  1621     cls.add_constructor([param('double', 'mu'), param('double', 'sigma')])

  1622     return

  1624 def register_Ns3NormalVariable_methods(root_module, cls):

  1625     ## random-variable.h: ns3::NormalVariable::NormalVariable(ns3::NormalVariable const & arg0) [copy constructor]

  1626     cls.add_constructor([param('ns3::NormalVariable const &', 'arg0')])

  1627     ## random-variable.h: ns3::NormalVariable::NormalVariable() [constructor]

  1628     cls.add_constructor([])

  1629     ## random-variable.h: ns3::NormalVariable::NormalVariable(double m, double v) [constructor]

  1630     cls.add_constructor([param('double', 'm'), param('double', 'v')])

  1631     ## random-variable.h: ns3::NormalVariable::NormalVariable(double m, double v, double b) [constructor]

  1632     cls.add_constructor([param('double', 'm'), param('double', 'v'), param('double', 'b')])

  1633     return

  1635 def register_Ns3Object_methods(root_module, cls):

  1636     ## object.h: static ns3::TypeId ns3::Object::GetTypeId() [member function]

  1637     cls.add_method('GetTypeId',

  1638                    'ns3::TypeId',

  1639                    [],

  1640                    is_static=True)

  1641     ## object.h: ns3::Object::Object() [constructor]

  1642     cls.add_constructor([])

  1643     ## object.h: ns3::TypeId ns3::Object::GetInstanceTypeId() const [member function]

  1644     cls.add_method('GetInstanceTypeId',

  1645                    'ns3::TypeId',

  1646                    [],

  1647                    is_const=True, is_virtual=True)

  1648     ## object.h: ns3::Ptr<ns3::Object> ns3::Object::GetObject(ns3::TypeId tid) const [member function]

  1649     cls.add_method('GetObject',

  1650                    'ns3::Ptr< ns3::Object >',

  1651                    [param('ns3::TypeId', 'tid')],

  1652                    is_const=True, template_parameters=['ns3::Object'], custom_template_method_name='GetObject')

  1653     ## object.h: void ns3::Object::Dispose() [member function]

  1654     cls.add_method('Dispose',

  1655                    'void',

  1656                    [])

  1657     ## object.h: void ns3::Object::AggregateObject(ns3::Ptr<ns3::Object> other) [member function]

  1658     cls.add_method('AggregateObject',

  1659                    'void',

  1660                    [param('ns3::Ptr< ns3::Object >', 'other')])

  1661     ## object.h: ns3::Object::AggregateIterator ns3::Object::GetAggregateIterator() const [member function]

  1662     cls.add_method('GetAggregateIterator',

  1663                    'ns3::Object::AggregateIterator',

  1664                    [],

  1665                    is_const=True)

  1666     ## object.h: void ns3::Object::NotifyNewAggregate() [member function]

  1667     cls.add_method('NotifyNewAggregate',

  1668                    'void',

  1669                    [],

  1670                    visibility='protected', is_virtual=True)

  1671     ## object.h: void ns3::Object::DoDispose() [member function]

  1672     cls.add_method('DoDispose',

  1673                    'void',

  1674                    [],

  1675                    visibility='protected', is_virtual=True)

  1676     ## object.h: ns3::Object::Object(ns3::Object const & o) [copy constructor]

  1677     cls.add_constructor([param('ns3::Object const &', 'o')],

  1678                         visibility='protected')

  1679     return

  1681 def register_Ns3ObjectAggregateIterator_methods(root_module, cls):

  1682     ## object.h: ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [copy constructor]

  1683     cls.add_constructor([param('ns3::Object::AggregateIterator const &', 'arg0')])

  1684     ## object.h: ns3::Object::AggregateIterator::AggregateIterator() [constructor]

  1685     cls.add_constructor([])

  1686     ## object.h: bool ns3::Object::AggregateIterator::HasNext() const [member function]

  1687     cls.add_method('HasNext',

  1688                    'bool',

  1689                    [],

  1690                    is_const=True)

  1691     ## object.h: ns3::Ptr<ns3::Object const> ns3::Object::AggregateIterator::Next() [member function]

  1692     cls.add_method('Next',

  1693                    'ns3::Ptr< ns3::Object const >',

  1694                    [])

  1695     return

  1697 def register_Ns3ObjectFactoryChecker_methods(root_module, cls):

  1698     ## object-factory.h: ns3::ObjectFactoryChecker::ObjectFactoryChecker(ns3::ObjectFactoryChecker const & arg0) [copy constructor]

  1699     cls.add_constructor([param('ns3::ObjectFactoryChecker const &', 'arg0')])

  1700     ## object-factory.h: ns3::ObjectFactoryChecker::ObjectFactoryChecker() [constructor]

  1701     cls.add_constructor([])

  1702     return

  1704 def register_Ns3ObjectFactoryValue_methods(root_module, cls):

  1705     ## object-factory.h: ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactoryValue const & arg0) [copy constructor]

  1706     cls.add_constructor([param('ns3::ObjectFactoryValue const &', 'arg0')])

  1707     ## object-factory.h: ns3::ObjectFactoryValue::ObjectFactoryValue() [constructor]

  1708     cls.add_constructor([])

  1709     ## object-factory.h: ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactory const & value) [constructor]

  1710     cls.add_constructor([param('ns3::ObjectFactory const &', 'value')])

  1711     ## object-factory.h: void ns3::ObjectFactoryValue::Set(ns3::ObjectFactory const & value) [member function]

  1712     cls.add_method('Set',

  1713                    'void',

  1714                    [param('ns3::ObjectFactory const &', 'value')])

  1715     ## object-factory.h: ns3::ObjectFactory ns3::ObjectFactoryValue::Get() const [member function]

  1716     cls.add_method('Get',

  1717                    'ns3::ObjectFactory',

  1718                    [],

  1719                    is_const=True)

  1720     ## object-factory.h: ns3::Ptr<ns3::AttributeValue> ns3::ObjectFactoryValue::Copy() const [member function]

  1721     cls.add_method('Copy',

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

  1723                    [],

  1724                    is_const=True, is_virtual=True)

  1725     ## object-factory.h: std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

  1726     cls.add_method('SerializeToString',

  1727                    'std::string',

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

  1729                    is_const=True, is_virtual=True)

  1730     ## object-factory.h: bool ns3::ObjectFactoryValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

  1731     cls.add_method('DeserializeFromString',

  1732                    'bool',

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

  1734                    is_virtual=True)

  1735     return

  1737 def register_Ns3ObjectVectorAccessor_methods(root_module, cls):

  1738     ## object-vector.h: ns3::ObjectVectorAccessor::ObjectVectorAccessor(ns3::ObjectVectorAccessor const & arg0) [copy constructor]

  1739     cls.add_constructor([param('ns3::ObjectVectorAccessor const &', 'arg0')])

  1740     ## object-vector.h: ns3::ObjectVectorAccessor::ObjectVectorAccessor() [constructor]

  1741     cls.add_constructor([])

  1742     ## object-vector.h: bool ns3::ObjectVectorAccessor::Set(ns3::ObjectBase * object, ns3::AttributeValue const & value) const [member function]

  1743     cls.add_method('Set',

  1744                    'bool',

  1745                    [param('ns3::ObjectBase *', 'object'), param('ns3::AttributeValue const &', 'value')],

  1746                    is_const=True, is_virtual=True)

  1747     ## object-vector.h: bool ns3::ObjectVectorAccessor::Get(ns3::ObjectBase const * object, ns3::AttributeValue & value) const [member function]

  1748     cls.add_method('Get',

  1749                    'bool',

  1750                    [param('ns3::ObjectBase const *', 'object'), param('ns3::AttributeValue &', 'value')],

  1751                    is_const=True, is_virtual=True)

  1752     ## object-vector.h: bool ns3::ObjectVectorAccessor::HasGetter() const [member function]

  1753     cls.add_method('HasGetter',

  1754                    'bool',

  1755                    [],

  1756                    is_const=True, is_virtual=True)

  1757     ## object-vector.h: bool ns3::ObjectVectorAccessor::HasSetter() const [member function]

  1758     cls.add_method('HasSetter',

  1759                    'bool',

  1760                    [],

  1761                    is_const=True, is_virtual=True)

  1762     ## object-vector.h: bool ns3::ObjectVectorAccessor::DoGetN(ns3::ObjectBase const * object, uint32_t * n) const [member function]

  1763     cls.add_method('DoGetN',

  1764                    'bool',

  1765                    [param('ns3::ObjectBase const *', 'object'), param('uint32_t *', 'n')],

  1766                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)

  1767     ## object-vector.h: ns3::Ptr<ns3::Object> ns3::ObjectVectorAccessor::DoGet(ns3::ObjectBase const * object, uint32_t i) const [member function]

  1768     cls.add_method('DoGet',

  1769                    'ns3::Ptr< ns3::Object >',

  1770                    [param('ns3::ObjectBase const *', 'object'), param('uint32_t', 'i')],

  1771                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)

  1772     return

  1774 def register_Ns3ObjectVectorChecker_methods(root_module, cls):

  1775     ## object-vector.h: ns3::ObjectVectorChecker::ObjectVectorChecker(ns3::ObjectVectorChecker const & arg0) [copy constructor]

  1776     cls.add_constructor([param('ns3::ObjectVectorChecker const &', 'arg0')])

  1777     ## object-vector.h: ns3::ObjectVectorChecker::ObjectVectorChecker() [constructor]

  1778     cls.add_constructor([])

  1779     ## object-vector.h: ns3::TypeId ns3::ObjectVectorChecker::GetItemTypeId() const [member function]

  1780     cls.add_method('GetItemTypeId',

  1781                    'ns3::TypeId',

  1782                    [],

  1783                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1784     return

  1786 def register_Ns3ObjectVectorValue_methods(root_module, cls):

  1787     ## object-vector.h: ns3::ObjectVectorValue::ObjectVectorValue(ns3::ObjectVectorValue const & arg0) [copy constructor]

  1788     cls.add_constructor([param('ns3::ObjectVectorValue const &', 'arg0')])

  1789     ## object-vector.h: ns3::ObjectVectorValue::ObjectVectorValue() [constructor]

  1790     cls.add_constructor([])

  1791     ## object-vector.h: __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Object>*,std::vector<ns3::Ptr<ns3::Object>, std::allocator<ns3::Ptr<ns3::Object> > > > ns3::ObjectVectorValue::Begin() const [member function]

  1792     cls.add_method('Begin',

  1793                    '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Object > const, std::vector< ns3::Ptr< ns3::Object > > >',

  1794                    [],

  1795                    is_const=True)

  1796     ## object-vector.h: __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Object>*,std::vector<ns3::Ptr<ns3::Object>, std::allocator<ns3::Ptr<ns3::Object> > > > ns3::ObjectVectorValue::End() const [member function]

  1797     cls.add_method('End',

  1798                    '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Object > const, std::vector< ns3::Ptr< ns3::Object > > >',

  1799                    [],

  1800                    is_const=True)

  1801     ## object-vector.h: uint32_t ns3::ObjectVectorValue::GetN() const [member function]

  1802     cls.add_method('GetN',

  1803                    'uint32_t',

  1804                    [],

  1805                    is_const=True)

  1806     ## object-vector.h: ns3::Ptr<ns3::Object> ns3::ObjectVectorValue::Get(uint32_t i) const [member function]

  1807     cls.add_method('Get',

  1808                    'ns3::Ptr< ns3::Object >',

  1809                    [param('uint32_t', 'i')],

  1810                    is_const=True)

  1811     ## object-vector.h: ns3::Ptr<ns3::AttributeValue> ns3::ObjectVectorValue::Copy() const [member function]

  1812     cls.add_method('Copy',

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

  1814                    [],

  1815                    is_const=True, is_virtual=True)

  1816     ## object-vector.h: std::string ns3::ObjectVectorValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

  1817     cls.add_method('SerializeToString',

  1818                    'std::string',

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

  1820                    is_const=True, is_virtual=True)

  1821     ## object-vector.h: bool ns3::ObjectVectorValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

  1822     cls.add_method('DeserializeFromString',

  1823                    'bool',

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

  1825                    is_virtual=True)

  1826     return

  1828 def register_Ns3ParetoVariable_methods(root_module, cls):

  1829     ## random-variable.h: ns3::ParetoVariable::ParetoVariable(ns3::ParetoVariable const & arg0) [copy constructor]

  1830     cls.add_constructor([param('ns3::ParetoVariable const &', 'arg0')])

  1831     ## random-variable.h: ns3::ParetoVariable::ParetoVariable() [constructor]

  1832     cls.add_constructor([])

  1833     ## random-variable.h: ns3::ParetoVariable::ParetoVariable(double m) [constructor]

  1834     cls.add_constructor([param('double', 'm')])

  1835     ## random-variable.h: ns3::ParetoVariable::ParetoVariable(double m, double s) [constructor]

  1836     cls.add_constructor([param('double', 'm'), param('double', 's')])

  1837     ## random-variable.h: ns3::ParetoVariable::ParetoVariable(double m, double s, double b) [constructor]

  1838     cls.add_constructor([param('double', 'm'), param('double', 's'), param('double', 'b')])

  1839     return

  1841 def register_Ns3PointerChecker_methods(root_module, cls):

  1842     ## pointer.h: ns3::PointerChecker::PointerChecker(ns3::PointerChecker const & arg0) [copy constructor]

  1843     cls.add_constructor([param('ns3::PointerChecker const &', 'arg0')])

  1844     ## pointer.h: ns3::PointerChecker::PointerChecker() [constructor]

  1845     cls.add_constructor([])

  1846     ## pointer.h: ns3::TypeId ns3::PointerChecker::GetPointeeTypeId() const [member function]

  1847     cls.add_method('GetPointeeTypeId',

  1848                    'ns3::TypeId',

  1849                    [],

  1850                    is_pure_virtual=True, is_const=True, is_virtual=True)

  1851     return

  1853 def register_Ns3PointerValue_methods(root_module, cls):

  1854     ## pointer.h: ns3::PointerValue::PointerValue(ns3::PointerValue const & arg0) [copy constructor]

  1855     cls.add_constructor([param('ns3::PointerValue const &', 'arg0')])

  1856     ## pointer.h: ns3::PointerValue::PointerValue() [constructor]

  1857     cls.add_constructor([])

  1858     ## pointer.h: ns3::PointerValue::PointerValue(ns3::Ptr<ns3::Object> object) [constructor]

  1859     cls.add_constructor([param('ns3::Ptr< ns3::Object >', 'object')])

  1860     ## pointer.h: void ns3::PointerValue::SetObject(ns3::Ptr<ns3::Object> object) [member function]

  1861     cls.add_method('SetObject',

  1862                    'void',

  1863                    [param('ns3::Ptr< ns3::Object >', 'object')])

  1864     ## pointer.h: ns3::Ptr<ns3::Object> ns3::PointerValue::GetObject() const [member function]

  1865     cls.add_method('GetObject',

  1866                    'ns3::Ptr< ns3::Object >',

  1867                    [],

  1868                    is_const=True)

  1869     ## pointer.h: ns3::Ptr<ns3::AttributeValue> ns3::PointerValue::Copy() const [member function]

  1870     cls.add_method('Copy',

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

  1872                    [],

  1873                    is_const=True, is_virtual=True)

  1874     ## pointer.h: std::string ns3::PointerValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

  1875     cls.add_method('SerializeToString',

  1876                    'std::string',

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

  1878                    is_const=True, is_virtual=True)

  1879     ## pointer.h: bool ns3::PointerValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

  1880     cls.add_method('DeserializeFromString',

  1881                    'bool',

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

  1883                    is_virtual=True)

  1884     return

  1886 def register_Ns3RandomVariableChecker_methods(root_module, cls):

  1887     ## random-variable.h: ns3::RandomVariableChecker::RandomVariableChecker(ns3::RandomVariableChecker const & arg0) [copy constructor]

  1888     cls.add_constructor([param('ns3::RandomVariableChecker const &', 'arg0')])

  1889     ## random-variable.h: ns3::RandomVariableChecker::RandomVariableChecker() [constructor]

  1890     cls.add_constructor([])

  1891     return

  1893 def register_Ns3RandomVariableValue_methods(root_module, cls):

  1894     ## random-variable.h: ns3::RandomVariableValue::RandomVariableValue(ns3::RandomVariableValue const & arg0) [copy constructor]

  1895     cls.add_constructor([param('ns3::RandomVariableValue const &', 'arg0')])

  1896     ## random-variable.h: ns3::RandomVariableValue::RandomVariableValue() [constructor]

  1897     cls.add_constructor([])

  1898     ## random-variable.h: ns3::RandomVariableValue::RandomVariableValue(ns3::RandomVariable const & value) [constructor]

  1899     cls.add_constructor([param('ns3::RandomVariable const &', 'value')])

  1900     ## random-variable.h: void ns3::RandomVariableValue::Set(ns3::RandomVariable const & value) [member function]

  1901     cls.add_method('Set',

  1902                    'void',

  1903                    [param('ns3::RandomVariable const &', 'value')])

  1904     ## random-variable.h: ns3::RandomVariable ns3::RandomVariableValue::Get() const [member function]

  1905     cls.add_method('Get',

  1906                    'ns3::RandomVariable',

  1907                    [],

  1908                    is_const=True)

  1909     ## random-variable.h: ns3::Ptr<ns3::AttributeValue> ns3::RandomVariableValue::Copy() const [member function]

  1910     cls.add_method('Copy',

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

  1912                    [],

  1913                    is_const=True, is_virtual=True)

  1914     ## random-variable.h: std::string ns3::RandomVariableValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

  1915     cls.add_method('SerializeToString',

  1916                    'std::string',

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

  1918                    is_const=True, is_virtual=True)

  1919     ## random-variable.h: bool ns3::RandomVariableValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

  1920     cls.add_method('DeserializeFromString',

  1921                    'bool',

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

  1923                    is_virtual=True)

  1924     return

  1926 def register_Ns3StringChecker_methods(root_module, cls):

  1927     ## string.h: ns3::StringChecker::StringChecker(ns3::StringChecker const & arg0) [copy constructor]

  1928     cls.add_constructor([param('ns3::StringChecker const &', 'arg0')])

  1929     ## string.h: ns3::StringChecker::StringChecker() [constructor]

  1930     cls.add_constructor([])

  1931     return

  1933 def register_Ns3StringValue_methods(root_module, cls):

  1934     ## string.h: ns3::StringValue::StringValue(ns3::StringValue const & arg0) [copy constructor]

  1935     cls.add_constructor([param('ns3::StringValue const &', 'arg0')])

  1936     ## string.h: ns3::StringValue::StringValue() [constructor]

  1937     cls.add_constructor([])

  1938     ## string.h: ns3::StringValue::StringValue(std::string const & value) [constructor]

  1939     cls.add_constructor([param('std::string const &', 'value')])

  1940     ## string.h: void ns3::StringValue::Set(std::string const & value) [member function]

  1941     cls.add_method('Set',

  1942                    'void',

  1943                    [param('std::string const &', 'value')])

  1944     ## string.h: std::string ns3::StringValue::Get() const [member function]

  1945     cls.add_method('Get',

  1946                    'std::string',

  1947                    [],

  1948                    is_const=True)

  1949     ## string.h: ns3::Ptr<ns3::AttributeValue> ns3::StringValue::Copy() const [member function]

  1950     cls.add_method('Copy',

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

  1952                    [],

  1953                    is_const=True, is_virtual=True)

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

  1955     cls.add_method('SerializeToString',

  1956                    'std::string',

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

  1958                    is_const=True, is_virtual=True)

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

  1960     cls.add_method('DeserializeFromString',

  1961                    'bool',

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

  1963                    is_virtual=True)

  1964     return

  1966 def register_Ns3TypeIdChecker_methods(root_module, cls):

  1967     ## type-id.h: ns3::TypeIdChecker::TypeIdChecker(ns3::TypeIdChecker const & arg0) [copy constructor]

  1968     cls.add_constructor([param('ns3::TypeIdChecker const &', 'arg0')])

  1969     ## type-id.h: ns3::TypeIdChecker::TypeIdChecker() [constructor]

  1970     cls.add_constructor([])

  1971     return

  1973 def register_Ns3TypeIdValue_methods(root_module, cls):

  1974     ## type-id.h: ns3::TypeIdValue::TypeIdValue(ns3::TypeIdValue const & arg0) [copy constructor]

  1975     cls.add_constructor([param('ns3::TypeIdValue const &', 'arg0')])

  1976     ## type-id.h: ns3::TypeIdValue::TypeIdValue() [constructor]

  1977     cls.add_constructor([])

  1978     ## type-id.h: ns3::TypeIdValue::TypeIdValue(ns3::TypeId const & value) [constructor]

  1979     cls.add_constructor([param('ns3::TypeId const &', 'value')])

  1980     ## type-id.h: void ns3::TypeIdValue::Set(ns3::TypeId const & value) [member function]

  1981     cls.add_method('Set',

  1982                    'void',

  1983                    [param('ns3::TypeId const &', 'value')])

  1984     ## type-id.h: ns3::TypeId ns3::TypeIdValue::Get() const [member function]

  1985     cls.add_method('Get',

  1986                    'ns3::TypeId',

  1987                    [],

  1988                    is_const=True)

  1989     ## type-id.h: ns3::Ptr<ns3::AttributeValue> ns3::TypeIdValue::Copy() const [member function]

  1990     cls.add_method('Copy',

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

  1992                    [],

  1993                    is_const=True, is_virtual=True)

  1994     ## type-id.h: std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

  1995     cls.add_method('SerializeToString',

  1996                    'std::string',

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

  1998                    is_const=True, is_virtual=True)

  1999     ## type-id.h: bool ns3::TypeIdValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

  2000     cls.add_method('DeserializeFromString',

  2001                    'bool',

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

  2003                    is_virtual=True)

  2004     return

  2006 def register_Ns3UintegerValue_methods(root_module, cls):

  2007     ## uinteger.h: ns3::UintegerValue::UintegerValue(ns3::UintegerValue const & arg0) [copy constructor]

  2008     cls.add_constructor([param('ns3::UintegerValue const &', 'arg0')])

  2009     ## uinteger.h: ns3::UintegerValue::UintegerValue() [constructor]

  2010     cls.add_constructor([])

  2011     ## uinteger.h: ns3::UintegerValue::UintegerValue(uint64_t const & value) [constructor]

  2012     cls.add_constructor([param('uint64_t const &', 'value')])

  2013     ## uinteger.h: void ns3::UintegerValue::Set(uint64_t const & value) [member function]

  2014     cls.add_method('Set',

  2015                    'void',

  2016                    [param('uint64_t const &', 'value')])

  2017     ## uinteger.h: uint64_t ns3::UintegerValue::Get() const [member function]

  2018     cls.add_method('Get',

  2019                    'uint64_t',

  2020                    [],

  2021                    is_const=True)

  2022     ## uinteger.h: ns3::Ptr<ns3::AttributeValue> ns3::UintegerValue::Copy() const [member function]

  2023     cls.add_method('Copy',

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

  2025                    [],

  2026                    is_const=True, is_virtual=True)

  2027     ## uinteger.h: std::string ns3::UintegerValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

  2028     cls.add_method('SerializeToString',

  2029                    'std::string',

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

  2031                    is_const=True, is_virtual=True)

  2032     ## uinteger.h: bool ns3::UintegerValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

  2033     cls.add_method('DeserializeFromString',

  2034                    'bool',

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

  2036                    is_virtual=True)

  2037     return

  2039 def register_Ns3TracedValue__Unsigned_int_methods(root_module, cls):

  2040     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue() [constructor]

  2041     cls.add_constructor([])

  2042     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::TracedValue<unsigned int> const & o) [copy constructor]

  2043     cls.add_constructor([param('ns3::TracedValue< unsigned int > const &', 'o')])

  2044     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(unsigned int const & v) [constructor]

  2045     cls.add_constructor([param('unsigned int const &', 'v')])

  2046     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::IntegerValue const & value) [constructor]

  2047     cls.add_constructor([param('ns3::IntegerValue const &', 'value')])

  2048     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::UintegerValue const & value) [constructor]

  2049     cls.add_constructor([param('ns3::UintegerValue const &', 'value')])

  2050     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::BooleanValue const & value) [constructor]

  2051     cls.add_constructor([param('ns3::BooleanValue const &', 'value')])

  2052     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::EnumValue const & value) [constructor]

  2053     cls.add_constructor([param('ns3::EnumValue const &', 'value')])

  2054     ## traced-value.h: void ns3::TracedValue<unsigned int>::ConnectWithoutContext(ns3::CallbackBase const & cb) [member function]

  2055     cls.add_method('ConnectWithoutContext',

  2056                    'void',

  2057                    [param('ns3::CallbackBase const &', 'cb')])

  2058     ## traced-value.h: void ns3::TracedValue<unsigned int>::Connect(ns3::CallbackBase const & cb, std::string path) [member function]

  2059     cls.add_method('Connect',

  2060                    'void',

  2061                    [param('ns3::CallbackBase const &', 'cb'), param('std::string', 'path')])

  2062     ## traced-value.h: void ns3::TracedValue<unsigned int>::DisconnectWithoutContext(ns3::CallbackBase const & cb) [member function]

  2063     cls.add_method('DisconnectWithoutContext',

  2064                    'void',

  2065                    [param('ns3::CallbackBase const &', 'cb')])

  2066     ## traced-value.h: void ns3::TracedValue<unsigned int>::Disconnect(ns3::CallbackBase const & cb, std::string path) [member function]

  2067     cls.add_method('Disconnect',

  2068                    'void',

  2069                    [param('ns3::CallbackBase const &', 'cb'), param('std::string', 'path')])

  2070     ## traced-value.h: void ns3::TracedValue<unsigned int>::Set(unsigned int const & v) [member function]

  2071     cls.add_method('Set',

  2072                    'void',

  2073                    [param('unsigned int const &', 'v')])

  2074     ## traced-value.h: unsigned int ns3::TracedValue<unsigned int>::Get() const [member function]

  2075     cls.add_method('Get',

  2076                    'unsigned int',

  2077                    [],

  2078                    is_const=True)

  2079     return

  2081 def register_Ns3ConfigMatchContainer_methods(root_module, cls):

  2082     ## config.h: ns3::Config::MatchContainer::MatchContainer(ns3::Config::MatchContainer const & arg0) [copy constructor]

  2083     cls.add_constructor([param('ns3::Config::MatchContainer const &', 'arg0')])

  2084     ## config.h: ns3::Config::MatchContainer::MatchContainer() [constructor]

  2085     cls.add_constructor([])

  2086     ## config.h: ns3::Config::MatchContainer::MatchContainer(std::vector<ns3::Ptr<ns3::Object>, std::allocator<ns3::Ptr<ns3::Object> > > const & objects, std::vector<std::string, std::allocator<std::string> > const & contexts, std::string path) [constructor]

  2087     cls.add_constructor([param('std::vector< ns3::Ptr< ns3::Object > > const &', 'objects'), param('std::vector< std::string > const &', 'contexts'), param('std::string', 'path')])

  2088     ## config.h: __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Object>*,std::vector<ns3::Ptr<ns3::Object>, std::allocator<ns3::Ptr<ns3::Object> > > > ns3::Config::MatchContainer::Begin() const [member function]

  2089     cls.add_method('Begin',

  2090                    '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Object > const, std::vector< ns3::Ptr< ns3::Object > > >',

  2091                    [],

  2092                    is_const=True)

  2093     ## config.h: __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Object>*,std::vector<ns3::Ptr<ns3::Object>, std::allocator<ns3::Ptr<ns3::Object> > > > ns3::Config::MatchContainer::End() const [member function]

  2094     cls.add_method('End',

  2095                    '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Object > const, std::vector< ns3::Ptr< ns3::Object > > >',

  2096                    [],

  2097                    is_const=True)

  2098     ## config.h: uint32_t ns3::Config::MatchContainer::GetN() const [member function]

  2099     cls.add_method('GetN',

  2100                    'uint32_t',

  2101                    [],

  2102                    is_const=True)

  2103     ## config.h: ns3::Ptr<ns3::Object> ns3::Config::MatchContainer::Get(uint32_t i) const [member function]

  2104     cls.add_method('Get',

  2105                    'ns3::Ptr< ns3::Object >',

  2106                    [param('uint32_t', 'i')],

  2107                    is_const=True)

  2108     ## config.h: std::string ns3::Config::MatchContainer::GetMatchedPath(uint32_t i) const [member function]

  2109     cls.add_method('GetMatchedPath',

  2110                    'std::string',

  2111                    [param('uint32_t', 'i')],

  2112                    is_const=True)

  2113     ## config.h: std::string ns3::Config::MatchContainer::GetPath() const [member function]

  2114     cls.add_method('GetPath',

  2115                    'std::string',

  2116                    [],

  2117                    is_const=True)

  2118     ## config.h: void ns3::Config::MatchContainer::Set(std::string name, ns3::AttributeValue const & value) [member function]

  2119     cls.add_method('Set',

  2120                    'void',

  2121                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])

  2122     ## config.h: void ns3::Config::MatchContainer::Connect(std::string name, ns3::CallbackBase const & cb) [member function]

  2123     cls.add_method('Connect',

  2124                    'void',

  2125                    [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])

  2126     ## config.h: void ns3::Config::MatchContainer::ConnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]

  2127     cls.add_method('ConnectWithoutContext',

  2128                    'void',

  2129                    [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])

  2130     ## config.h: void ns3::Config::MatchContainer::Disconnect(std::string name, ns3::CallbackBase const & cb) [member function]

  2131     cls.add_method('Disconnect',

  2132                    'void',

  2133                    [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])

  2134     ## config.h: void ns3::Config::MatchContainer::DisconnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]

  2135     cls.add_method('DisconnectWithoutContext',

  2136                    'void',

  2137                    [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])

  2138     return

  2140 def register_functions(root_module):

  2141     module = root_module

  2142     ## breakpoint.h: extern void ns3::BreakpointFallback() [free function]

  2143     module.add_function('BreakpointFallback',

  2144                         'void',

  2145                         [])

  2146     ## ptr.h: extern ns3::Ptr<ns3::ObjectVectorValue> ns3::Create() [free function]

  2147     module.add_function('Create',

  2148                         'ns3::Ptr< ns3::ObjectVectorValue >',

  2149                         [],

  2150                         template_parameters=['ns3::ObjectVectorValue'])

  2151     ## ptr.h: extern ns3::Ptr<ns3::PointerValue> ns3::Create() [free function]

  2152     module.add_function('Create',

  2153                         'ns3::Ptr< ns3::PointerValue >',

  2154                         [],

  2155                         template_parameters=['ns3::PointerValue'])

  2156     ## log.h: extern void ns3::LogComponentDisable(char const * name, ns3::LogLevel level) [free function]

  2157     module.add_function('LogComponentDisable',

  2158                         'void',

  2159                         [param('char const *', 'name'), param('ns3::LogLevel', 'level')])

  2160     ## log.h: extern void ns3::LogComponentDisableAll(ns3::LogLevel level) [free function]

  2161     module.add_function('LogComponentDisableAll',

  2162                         'void',

  2163                         [param('ns3::LogLevel', 'level')])

  2164     ## log.h: extern void ns3::LogComponentEnable(char const * name, ns3::LogLevel level) [free function]

  2165     module.add_function('LogComponentEnable',

  2166                         'void',

  2167                         [param('char const *', 'name'), param('ns3::LogLevel', 'level')])

  2168     ## log.h: extern void ns3::LogComponentEnableAll(ns3::LogLevel level) [free function]

  2169     module.add_function('LogComponentEnableAll',

  2170                         'void',

  2171                         [param('ns3::LogLevel', 'level')])

  2172     ## boolean.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeBooleanChecker() [free function]

  2173     module.add_function('MakeBooleanChecker',

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

  2175                         [])

  2176     ## callback.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeCallbackChecker() [free function]

  2177     module.add_function('MakeCallbackChecker',

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

  2179                         [])

  2180     ## enum.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeEnumChecker(int v1, std::string n1, int v2=0, std::string n2="", int v3=0, std::string n3="", int v4=0, std::string n4="", int v5=0, std::string n5="", int v6=0, std::string n6="", int v7=0, std::string n7="", int v8=0, std::string n8="", int v9=0, std::string n9="", int v10=0, std::string n10="", int v11=0, std::string n11="", int v12=0, std::string n12="") [free function]

  2181     module.add_function('MakeEnumChecker',

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

  2183                         [param('int', 'v1'), param('std::string', 'n1'), param('int', 'v2', default_value='0'), param('std::string', 'n2', default_value='""'), param('int', 'v3', default_value='0'), param('std::string', 'n3', default_value='""'), param('int', 'v4', default_value='0'), param('std::string', 'n4', default_value='""'), param('int', 'v5', default_value='0'), param('std::string', 'n5', default_value='""'), param('int', 'v6', default_value='0'), param('std::string', 'n6', default_value='""'), param('int', 'v7', default_value='0'), param('std::string', 'n7', default_value='""'), param('int', 'v8', default_value='0'), param('std::string', 'n8', default_value='""'), param('int', 'v9', default_value='0'), param('std::string', 'n9', default_value='""'), param('int', 'v10', default_value='0'), param('std::string', 'n10', default_value='""'), param('int', 'v11', default_value='0'), param('std::string', 'n11', default_value='""'), param('int', 'v12', default_value='0'), param('std::string', 'n12', default_value='""')])

  2184     ## object-factory.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeObjectFactoryChecker() [free function]

  2185     module.add_function('MakeObjectFactoryChecker',

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

  2187                         [])

  2188     ## random-variable.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeRandomVariableChecker() [free function]

  2189     module.add_function('MakeRandomVariableChecker',

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

  2191                         [])

  2192     ## string.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeStringChecker() [free function]

  2193     module.add_function('MakeStringChecker',

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

  2195                         [])

  2196     ## type-id.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeTypeIdChecker() [free function]

  2197     module.add_function('MakeTypeIdChecker',

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

  2199                         [])

  2200     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]

  2201     module.add_function('TypeNameGet',

  2202                         'std::string',

  2203                         [],

  2204                         template_parameters=['double'])

  2205     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]

  2206     module.add_function('TypeNameGet',

  2207                         'std::string',

  2208                         [],

  2209                         template_parameters=['float'])

  2210     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]

  2211     module.add_function('TypeNameGet',

  2212                         'std::string',

  2213                         [],

  2214                         template_parameters=['long long'])

  2215     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]

  2216     module.add_function('TypeNameGet',

  2217                         'std::string',

  2218                         [],

  2219                         template_parameters=['int'])

  2220     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]

  2221     module.add_function('TypeNameGet',

  2222                         'std::string',

  2223                         [],

  2224                         template_parameters=['short'])

  2225     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]

  2226     module.add_function('TypeNameGet',

  2227                         'std::string',

  2228                         [],

  2229                         template_parameters=['signed char'])

  2230     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]

  2231     module.add_function('TypeNameGet',

  2232                         'std::string',

  2233                         [],

  2234                         template_parameters=['unsigned long long'])

  2235     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]

  2236     module.add_function('TypeNameGet',

  2237                         'std::string',

  2238                         [],

  2239                         template_parameters=['unsigned int'])

  2240     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]

  2241     module.add_function('TypeNameGet',

  2242                         'std::string',

  2243                         [],

  2244                         template_parameters=['unsigned short'])

  2245     ## type-name.h: extern std::string ns3::TypeNameGet() [free function]

  2246     module.add_function('TypeNameGet',

  2247                         'std::string',

  2248                         [],

  2249                         template_parameters=['unsigned char'])

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

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

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

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

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

  2255     return

  2257 def register_functions_ns3_Config(module, root_module):

  2258     ## config.h: extern void ns3::Config::Connect(std::string path, ns3::CallbackBase const & cb) [free function]

  2259     module.add_function('Connect',

  2260                         'void',

  2261                         [param('std::string', 'path'), param('ns3::CallbackBase const &', 'cb')])

  2262     ## config.h: extern void ns3::Config::ConnectWithoutContext(std::string path, ns3::CallbackBase const & cb) [free function]

  2263     module.add_function('ConnectWithoutContext',

  2264                         'void',

  2265                         [param('std::string', 'path'), param('ns3::CallbackBase const &', 'cb')])

  2266     ## config.h: extern void ns3::Config::Disconnect(std::string path, ns3::CallbackBase const & cb) [free function]

  2267     module.add_function('Disconnect',

  2268                         'void',

  2269                         [param('std::string', 'path'), param('ns3::CallbackBase const &', 'cb')])

  2270     ## config.h: extern void ns3::Config::DisconnectWithoutContext(std::string path, ns3::CallbackBase const & cb) [free function]

  2271     module.add_function('DisconnectWithoutContext',

  2272                         'void',

  2273                         [param('std::string', 'path'), param('ns3::CallbackBase const &', 'cb')])

  2274     ## config.h: extern ns3::Ptr<ns3::Object> ns3::Config::GetRootNamespaceObject(uint32_t i) [free function]

  2275     module.add_function('GetRootNamespaceObject',

  2276                         'ns3::Ptr< ns3::Object >',

  2277                         [param('uint32_t', 'i')])

  2278     ## config.h: extern uint32_t ns3::Config::GetRootNamespaceObjectN() [free function]

  2279     module.add_function('GetRootNamespaceObjectN',

  2280                         'uint32_t',

  2281                         [])

  2282     ## config.h: extern ns3::Config::MatchContainer ns3::Config::LookupMatches(std::string path) [free function]

  2283     module.add_function('LookupMatches',

  2284                         'ns3::Config::MatchContainer',

  2285                         [param('std::string', 'path')])

  2286     ## config.h: extern void ns3::Config::RegisterRootNamespaceObject(ns3::Ptr<ns3::Object> obj) [free function]

  2287     module.add_function('RegisterRootNamespaceObject',

  2288                         'void',

  2289                         [param('ns3::Ptr< ns3::Object >', 'obj')])

  2290     ## config.h: extern void ns3::Config::Set(std::string path, ns3::AttributeValue const & value) [free function]

  2291     module.add_function('Set',

  2292                         'void',

  2293                         [param('std::string', 'path'), param('ns3::AttributeValue const &', 'value')])

  2294     ## config.h: extern void ns3::Config::SetDefault(std::string name, ns3::AttributeValue const & value) [free function]

  2295     module.add_function('SetDefault',

  2296                         'void',

  2297                         [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])

  2298     ## config.h: extern bool ns3::Config::SetDefaultFailSafe(std::string name, ns3::AttributeValue const & value) [free function]

  2299     module.add_function('SetDefaultFailSafe',

  2300                         'bool',

  2301                         [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])

  2302     ## config.h: extern void ns3::Config::SetGlobal(std::string name, ns3::AttributeValue const & value) [free function]

  2303     module.add_function('SetGlobal',

  2304                         'void',

  2305                         [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])

  2306     ## config.h: extern bool ns3::Config::SetGlobalFailSafe(std::string name, ns3::AttributeValue const & value) [free function]

  2307     module.add_function('SetGlobalFailSafe',

  2308                         'bool',

  2309                         [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])

  2310     ## config.h: extern void ns3::Config::UnregisterRootNamespaceObject(ns3::Ptr<ns3::Object> obj) [free function]

  2311     module.add_function('UnregisterRootNamespaceObject',

  2312                         'void',

  2313                         [param('ns3::Ptr< ns3::Object >', 'obj')])

  2314     return

  2316 def register_functions_ns3_TimeStepPrecision(module, root_module):

  2317     return

  2319 def register_functions_ns3_addressUtils(module, root_module):

  2320     return

  2322 def register_functions_ns3_internal(module, root_module):

  2323     ## double.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::internal::MakeDoubleChecker(double min, double max, std::string name) [free function]

  2324     module.add_function('MakeDoubleChecker',

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

  2326                         [param('double', 'min'), param('double', 'max'), param('std::string', 'name')])

  2327     ## integer.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::internal::MakeIntegerChecker(int64_t min, int64_t max, std::string name) [free function]

  2328     module.add_function('MakeIntegerChecker',

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

  2330                         [param('int64_t', 'min'), param('int64_t', 'max'), param('std::string', 'name')])

  2331     ## uinteger.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::internal::MakeUintegerChecker(uint64_t min, uint64_t max, std::string name) [free function]

  2332     module.add_function('MakeUintegerChecker',

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

  2334                         [param('uint64_t', 'min'), param('uint64_t', 'max'), param('std::string', 'name')])

  2335     return

  2337 def register_functions_ns3_olsr(module, root_module):

  2338     return

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