--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/propagation/bindings/modulegen__gcc_LP64.py Tue Mar 22 15:41:38 2011 +0000
@@ -0,0 +1,1894 @@
+from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandlers
+
+
+import pybindgen.settings
+import warnings
+
+class ErrorHandler(pybindgen.settings.ErrorHandler):
+ def handle_error(self, wrapper, exception, traceback_):
+ warnings.warn("exception %r in wrapper %s" % (exception, wrapper))
+ return True
+pybindgen.settings.error_handler = ErrorHandler()
+
+
+import sys
+
+def module_init():
+ root_module = Module('ns.propagation', cpp_namespace='::ns3')
+ return root_module
+
+def register_types(module):
+ root_module = module.get_root()
+
+ ## attribute-list.h (module 'core'): ns3::AttributeList [class]
+ module.add_class('AttributeList', import_from_module='ns.core')
+ ## callback.h (module 'core'): ns3::CallbackBase [class]
+ module.add_class('CallbackBase', import_from_module='ns.core')
+ ## high-precision-128.h (module 'core'): ns3::HighPrecision [class]
+ module.add_class('HighPrecision', import_from_module='ns.core')
+ ## object-base.h (module 'core'): ns3::ObjectBase [class]
+ module.add_class('ObjectBase', allow_subclassing=True, import_from_module='ns.core')
+ ## object.h (module 'core'): ns3::ObjectDeleter [struct]
+ module.add_class('ObjectDeleter', import_from_module='ns.core')
+ ## random-variable.h (module 'core'): ns3::RandomVariable [class]
+ module.add_class('RandomVariable', import_from_module='ns.core')
+ ## random-variable.h (module 'core'): ns3::SeedManager [class]
+ module.add_class('SeedManager', import_from_module='ns.core')
+ ## random-variable.h (module 'core'): ns3::SequentialVariable [class]
+ module.add_class('SequentialVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
+ ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter> [class]
+ module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::Object', 'ns3::ObjectBase', 'ns3::ObjectDeleter'], parent=root_module['ns3::ObjectBase'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
+ ## nstime.h (module 'core'): ns3::Time [class]
+ module.add_class('Time', import_from_module='ns.core')
+ ## nstime.h (module 'core'): ns3::Time::Unit [enumeration]
+ module.add_enum('Unit', ['S', 'MS', 'US', 'NS', 'PS', 'FS', 'LAST'], outer_class=root_module['ns3::Time'], import_from_module='ns.core')
+ ## random-variable.h (module 'core'): ns3::TriangularVariable [class]
+ module.add_class('TriangularVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
+ ## type-id.h (module 'core'): ns3::TypeId [class]
+ module.add_class('TypeId', import_from_module='ns.core')
+ ## type-id.h (module 'core'): ns3::TypeId::AttributeFlag [enumeration]
+ module.add_enum('AttributeFlag', ['ATTR_GET', 'ATTR_SET', 'ATTR_CONSTRUCT', 'ATTR_SGC'], outer_class=root_module['ns3::TypeId'], import_from_module='ns.core')
+ ## type-id.h (module 'core'): ns3::TypeId::AttributeInfo [struct]
+ module.add_class('AttributeInfo', import_from_module='ns.core', outer_class=root_module['ns3::TypeId'])
+ ## random-variable.h (module 'core'): ns3::UniformVariable [class]
+ module.add_class('UniformVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
+ ## attribute-list.h (module 'core'): ns3::UnsafeAttributeList [class]
+ module.add_class('UnsafeAttributeList', import_from_module='ns.core')
+ ## random-variable.h (module 'core'): ns3::WeibullVariable [class]
+ module.add_class('WeibullVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
+ ## random-variable.h (module 'core'): ns3::ZetaVariable [class]
+ module.add_class('ZetaVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
+ ## random-variable.h (module 'core'): ns3::ZipfVariable [class]
+ module.add_class('ZipfVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
+ ## empty.h (module 'core'): ns3::empty [class]
+ module.add_class('empty', import_from_module='ns.core')
+ ## random-variable.h (module 'core'): ns3::ConstantVariable [class]
+ module.add_class('ConstantVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
+ ## random-variable.h (module 'core'): ns3::DeterministicVariable [class]
+ module.add_class('DeterministicVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
+ ## random-variable.h (module 'core'): ns3::EmpiricalVariable [class]
+ module.add_class('EmpiricalVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
+ ## random-variable.h (module 'core'): ns3::ErlangVariable [class]
+ module.add_class('ErlangVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
+ ## random-variable.h (module 'core'): ns3::ExponentialVariable [class]
+ module.add_class('ExponentialVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
+ ## random-variable.h (module 'core'): ns3::GammaVariable [class]
+ module.add_class('GammaVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
+ ## random-variable.h (module 'core'): ns3::IntEmpiricalVariable [class]
+ module.add_class('IntEmpiricalVariable', import_from_module='ns.core', parent=root_module['ns3::EmpiricalVariable'])
+ ## random-variable.h (module 'core'): ns3::LogNormalVariable [class]
+ module.add_class('LogNormalVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
+ ## random-variable.h (module 'core'): ns3::NormalVariable [class]
+ module.add_class('NormalVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
+ ## object.h (module 'core'): ns3::Object [class]
+ module.add_class('Object', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter >'])
+ ## object.h (module 'core'): ns3::Object::AggregateIterator [class]
+ module.add_class('AggregateIterator', import_from_module='ns.core', outer_class=root_module['ns3::Object'])
+ ## random-variable.h (module 'core'): ns3::ParetoVariable [class]
+ module.add_class('ParetoVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
+ ## propagation-delay-model.h (module 'propagation'): ns3::PropagationDelayModel [class]
+ module.add_class('PropagationDelayModel', parent=root_module['ns3::Object'])
+ ## propagation-loss-model.h (module 'propagation'): ns3::PropagationLossModel [class]
+ module.add_class('PropagationLossModel', parent=root_module['ns3::Object'])
+ ## propagation-delay-model.h (module 'propagation'): ns3::RandomPropagationDelayModel [class]
+ module.add_class('RandomPropagationDelayModel', parent=root_module['ns3::PropagationDelayModel'])
+ ## propagation-loss-model.h (module 'propagation'): ns3::RandomPropagationLossModel [class]
+ module.add_class('RandomPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
+ ## propagation-loss-model.h (module 'propagation'): ns3::RangePropagationLossModel [class]
+ module.add_class('RangePropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
+ ## nstime.h (module 'core'): ns3::Scalar [class]
+ module.add_class('Scalar', import_from_module='ns.core')
+ ## nstime.h (module 'core'): ns3::Scalar [class]
+ root_module['ns3::Scalar'].implicitly_converts_to(root_module['ns3::Time'])
+ ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> > [class]
+ module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::AttributeAccessor', 'ns3::empty', 'ns3::DefaultDeleter<ns3::AttributeAccessor>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
+ ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> > [class]
+ module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::AttributeChecker', 'ns3::empty', 'ns3::DefaultDeleter<ns3::AttributeChecker>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
+ ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> > [class]
+ module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::AttributeValue', 'ns3::empty', 'ns3::DefaultDeleter<ns3::AttributeValue>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
+ ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> > [class]
+ module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::CallbackImplBase', 'ns3::empty', 'ns3::DefaultDeleter<ns3::CallbackImplBase>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
+ ## propagation-loss-model.h (module 'propagation'): ns3::ThreeLogDistancePropagationLossModel [class]
+ module.add_class('ThreeLogDistancePropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
+ ## propagation-loss-model.h (module 'propagation'): ns3::TwoRayGroundPropagationLossModel [class]
+ module.add_class('TwoRayGroundPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
+ ## attribute.h (module 'core'): ns3::AttributeAccessor [class]
+ module.add_class('AttributeAccessor', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >'])
+ ## attribute.h (module 'core'): ns3::AttributeChecker [class]
+ module.add_class('AttributeChecker', allow_subclassing=False, automatic_type_narrowing=True, import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> >'])
+ ## attribute.h (module 'core'): ns3::AttributeValue [class]
+ module.add_class('AttributeValue', allow_subclassing=False, automatic_type_narrowing=True, import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> >'])
+ ## callback.h (module 'core'): ns3::CallbackChecker [class]
+ module.add_class('CallbackChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])
+ ## callback.h (module 'core'): ns3::CallbackImplBase [class]
+ module.add_class('CallbackImplBase', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> >'])
+ ## callback.h (module 'core'): ns3::CallbackValue [class]
+ module.add_class('CallbackValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
+ ## propagation-delay-model.h (module 'propagation'): ns3::ConstantSpeedPropagationDelayModel [class]
+ module.add_class('ConstantSpeedPropagationDelayModel', parent=root_module['ns3::PropagationDelayModel'])
+ ## cost231-propagation-loss-model.h (module 'propagation'): ns3::Cost231PropagationLossModel [class]
+ module.add_class('Cost231PropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
+ ## cost231-propagation-loss-model.h (module 'propagation'): ns3::Cost231PropagationLossModel::Environment [enumeration]
+ module.add_enum('Environment', ['SubUrban', 'MediumCity', 'Metropolitan'], outer_class=root_module['ns3::Cost231PropagationLossModel'])
+ ## attribute.h (module 'core'): ns3::EmptyAttributeValue [class]
+ module.add_class('EmptyAttributeValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
+ ## propagation-loss-model.h (module 'propagation'): ns3::FixedRssLossModel [class]
+ module.add_class('FixedRssLossModel', parent=root_module['ns3::PropagationLossModel'])
+ ## propagation-loss-model.h (module 'propagation'): ns3::FriisPropagationLossModel [class]
+ module.add_class('FriisPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
+ ## jakes-propagation-loss-model.h (module 'propagation'): ns3::JakesPropagationLossModel [class]
+ module.add_class('JakesPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
+ ## propagation-loss-model.h (module 'propagation'): ns3::LogDistancePropagationLossModel [class]
+ module.add_class('LogDistancePropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
+ ## propagation-loss-model.h (module 'propagation'): ns3::MatrixPropagationLossModel [class]
+ module.add_class('MatrixPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
+ ## propagation-loss-model.h (module 'propagation'): ns3::NakagamiPropagationLossModel [class]
+ module.add_class('NakagamiPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])
+ ## random-variable.h (module 'core'): ns3::RandomVariableChecker [class]
+ module.add_class('RandomVariableChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])
+ ## random-variable.h (module 'core'): ns3::RandomVariableValue [class]
+ module.add_class('RandomVariableValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
+ ## nstime.h (module 'core'): ns3::TimeChecker [class]
+ module.add_class('TimeChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])
+ ## nstime.h (module 'core'): ns3::TimeValue [class]
+ module.add_class('TimeValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
+ ## type-id.h (module 'core'): ns3::TypeIdChecker [class]
+ module.add_class('TypeIdChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])
+ ## type-id.h (module 'core'): ns3::TypeIdValue [class]
+ module.add_class('TypeIdValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
+ typehandlers.add_type_alias('ns3::Time', 'ns3::TimeSquare')
+ typehandlers.add_type_alias('ns3::Time*', 'ns3::TimeSquare*')
+ typehandlers.add_type_alias('ns3::Time&', 'ns3::TimeSquare&')
+ module.add_typedef(root_module['ns3::Time'], 'TimeSquare')
+ typehandlers.add_type_alias('ns3::Time', 'ns3::TimeInvert')
+ typehandlers.add_type_alias('ns3::Time*', 'ns3::TimeInvert*')
+ typehandlers.add_type_alias('ns3::Time&', 'ns3::TimeInvert&')
+ module.add_typedef(root_module['ns3::Time'], 'TimeInvert')
+
+ ## Register a nested module for the namespace FatalImpl
+
+ nested_module = module.add_cpp_namespace('FatalImpl')
+ register_types_ns3_FatalImpl(nested_module)
+
+
+def register_types_ns3_FatalImpl(module):
+ root_module = module.get_root()
+
+
+def register_methods(root_module):
+ register_Ns3AttributeList_methods(root_module, root_module['ns3::AttributeList'])
+ register_Ns3CallbackBase_methods(root_module, root_module['ns3::CallbackBase'])
+ register_Ns3HighPrecision_methods(root_module, root_module['ns3::HighPrecision'])
+ register_Ns3ObjectBase_methods(root_module, root_module['ns3::ObjectBase'])
+ register_Ns3ObjectDeleter_methods(root_module, root_module['ns3::ObjectDeleter'])
+ register_Ns3RandomVariable_methods(root_module, root_module['ns3::RandomVariable'])
+ register_Ns3SeedManager_methods(root_module, root_module['ns3::SeedManager'])
+ register_Ns3SequentialVariable_methods(root_module, root_module['ns3::SequentialVariable'])
+ register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods(root_module, root_module['ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter >'])
+ register_Ns3Time_methods(root_module, root_module['ns3::Time'])
+ register_Ns3TriangularVariable_methods(root_module, root_module['ns3::TriangularVariable'])
+ register_Ns3TypeId_methods(root_module, root_module['ns3::TypeId'])
+ register_Ns3TypeIdAttributeInfo_methods(root_module, root_module['ns3::TypeId::AttributeInfo'])
+ register_Ns3UniformVariable_methods(root_module, root_module['ns3::UniformVariable'])
+ register_Ns3UnsafeAttributeList_methods(root_module, root_module['ns3::UnsafeAttributeList'])
+ register_Ns3WeibullVariable_methods(root_module, root_module['ns3::WeibullVariable'])
+ register_Ns3ZetaVariable_methods(root_module, root_module['ns3::ZetaVariable'])
+ register_Ns3ZipfVariable_methods(root_module, root_module['ns3::ZipfVariable'])
+ register_Ns3Empty_methods(root_module, root_module['ns3::empty'])
+ register_Ns3ConstantVariable_methods(root_module, root_module['ns3::ConstantVariable'])
+ register_Ns3DeterministicVariable_methods(root_module, root_module['ns3::DeterministicVariable'])
+ register_Ns3EmpiricalVariable_methods(root_module, root_module['ns3::EmpiricalVariable'])
+ register_Ns3ErlangVariable_methods(root_module, root_module['ns3::ErlangVariable'])
+ register_Ns3ExponentialVariable_methods(root_module, root_module['ns3::ExponentialVariable'])
+ register_Ns3GammaVariable_methods(root_module, root_module['ns3::GammaVariable'])
+ register_Ns3IntEmpiricalVariable_methods(root_module, root_module['ns3::IntEmpiricalVariable'])
+ register_Ns3LogNormalVariable_methods(root_module, root_module['ns3::LogNormalVariable'])
+ register_Ns3NormalVariable_methods(root_module, root_module['ns3::NormalVariable'])
+ register_Ns3Object_methods(root_module, root_module['ns3::Object'])
+ register_Ns3ObjectAggregateIterator_methods(root_module, root_module['ns3::Object::AggregateIterator'])
+ register_Ns3ParetoVariable_methods(root_module, root_module['ns3::ParetoVariable'])
+ register_Ns3PropagationDelayModel_methods(root_module, root_module['ns3::PropagationDelayModel'])
+ register_Ns3PropagationLossModel_methods(root_module, root_module['ns3::PropagationLossModel'])
+ register_Ns3RandomPropagationDelayModel_methods(root_module, root_module['ns3::RandomPropagationDelayModel'])
+ register_Ns3RandomPropagationLossModel_methods(root_module, root_module['ns3::RandomPropagationLossModel'])
+ register_Ns3RangePropagationLossModel_methods(root_module, root_module['ns3::RangePropagationLossModel'])
+ register_Ns3Scalar_methods(root_module, root_module['ns3::Scalar'])
+ register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >'])
+ register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeChecker__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> >'])
+ register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeValue__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> >'])
+ register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__lt__ns3CallbackImplBase__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> >'])
+ register_Ns3ThreeLogDistancePropagationLossModel_methods(root_module, root_module['ns3::ThreeLogDistancePropagationLossModel'])
+ register_Ns3TwoRayGroundPropagationLossModel_methods(root_module, root_module['ns3::TwoRayGroundPropagationLossModel'])
+ register_Ns3AttributeAccessor_methods(root_module, root_module['ns3::AttributeAccessor'])
+ register_Ns3AttributeChecker_methods(root_module, root_module['ns3::AttributeChecker'])
+ register_Ns3AttributeValue_methods(root_module, root_module['ns3::AttributeValue'])
+ register_Ns3CallbackChecker_methods(root_module, root_module['ns3::CallbackChecker'])
+ register_Ns3CallbackImplBase_methods(root_module, root_module['ns3::CallbackImplBase'])
+ register_Ns3CallbackValue_methods(root_module, root_module['ns3::CallbackValue'])
+ register_Ns3ConstantSpeedPropagationDelayModel_methods(root_module, root_module['ns3::ConstantSpeedPropagationDelayModel'])
+ register_Ns3Cost231PropagationLossModel_methods(root_module, root_module['ns3::Cost231PropagationLossModel'])
+ register_Ns3EmptyAttributeValue_methods(root_module, root_module['ns3::EmptyAttributeValue'])
+ register_Ns3FixedRssLossModel_methods(root_module, root_module['ns3::FixedRssLossModel'])
+ register_Ns3FriisPropagationLossModel_methods(root_module, root_module['ns3::FriisPropagationLossModel'])
+ register_Ns3JakesPropagationLossModel_methods(root_module, root_module['ns3::JakesPropagationLossModel'])
+ register_Ns3LogDistancePropagationLossModel_methods(root_module, root_module['ns3::LogDistancePropagationLossModel'])
+ register_Ns3MatrixPropagationLossModel_methods(root_module, root_module['ns3::MatrixPropagationLossModel'])
+ register_Ns3NakagamiPropagationLossModel_methods(root_module, root_module['ns3::NakagamiPropagationLossModel'])
+ register_Ns3RandomVariableChecker_methods(root_module, root_module['ns3::RandomVariableChecker'])
+ register_Ns3RandomVariableValue_methods(root_module, root_module['ns3::RandomVariableValue'])
+ register_Ns3TimeChecker_methods(root_module, root_module['ns3::TimeChecker'])
+ register_Ns3TimeValue_methods(root_module, root_module['ns3::TimeValue'])
+ register_Ns3TypeIdChecker_methods(root_module, root_module['ns3::TypeIdChecker'])
+ register_Ns3TypeIdValue_methods(root_module, root_module['ns3::TypeIdValue'])
+ return
+
+def register_Ns3AttributeList_methods(root_module, cls):
+ ## attribute-list.h (module 'core'): ns3::AttributeList::AttributeList() [constructor]
+ cls.add_constructor([])
+ ## attribute-list.h (module 'core'): ns3::AttributeList::AttributeList(ns3::AttributeList const & o) [copy constructor]
+ cls.add_constructor([param('ns3::AttributeList const &', 'o')])
+ ## attribute-list.h (module 'core'): bool ns3::AttributeList::DeserializeFromString(std::string value) [member function]
+ cls.add_method('DeserializeFromString',
+ 'bool',
+ [param('std::string', 'value')])
+ ## attribute-list.h (module 'core'): static ns3::AttributeList * ns3::AttributeList::GetGlobal() [member function]
+ cls.add_method('GetGlobal',
+ 'ns3::AttributeList *',
+ [],
+ is_static=True)
+ ## attribute-list.h (module 'core'): void ns3::AttributeList::Reset() [member function]
+ cls.add_method('Reset',
+ 'void',
+ [])
+ ## attribute-list.h (module 'core'): std::string ns3::AttributeList::SerializeToString() const [member function]
+ cls.add_method('SerializeToString',
+ 'std::string',
+ [],
+ is_const=True)
+ ## attribute-list.h (module 'core'): void ns3::AttributeList::Set(std::string name, ns3::AttributeValue const & value) [member function]
+ cls.add_method('Set',
+ 'void',
+ [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
+ ## attribute-list.h (module 'core'): bool ns3::AttributeList::SetFailSafe(std::string name, ns3::AttributeValue const & value) [member function]
+ cls.add_method('SetFailSafe',
+ 'bool',
+ [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
+ ## attribute-list.h (module 'core'): void ns3::AttributeList::SetWithTid(ns3::TypeId tid, std::string name, ns3::AttributeValue const & value) [member function]
+ cls.add_method('SetWithTid',
+ 'void',
+ [param('ns3::TypeId', 'tid'), param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
+ return
+
+def register_Ns3CallbackBase_methods(root_module, cls):
+ ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::CallbackBase const &', 'arg0')])
+ ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase() [constructor]
+ cls.add_constructor([])
+ ## callback.h (module 'core'): ns3::Ptr<ns3::CallbackImplBase> ns3::CallbackBase::GetImpl() const [member function]
+ cls.add_method('GetImpl',
+ 'ns3::Ptr< ns3::CallbackImplBase >',
+ [],
+ is_const=True)
+ ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::Ptr<ns3::CallbackImplBase> impl) [constructor]
+ cls.add_constructor([param('ns3::Ptr< ns3::CallbackImplBase >', 'impl')],
+ visibility='protected')
+ ## callback.h (module 'core'): static std::string ns3::CallbackBase::Demangle(std::string const & mangled) [member function]
+ cls.add_method('Demangle',
+ 'std::string',
+ [param('std::string const &', 'mangled')],
+ is_static=True, visibility='protected')
+ return
+
+def register_Ns3HighPrecision_methods(root_module, cls):
+ cls.add_output_stream_operator()
+ ## high-precision-128.h (module 'core'): ns3::HighPrecision::HighPrecision(ns3::HighPrecision const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::HighPrecision const &', 'arg0')])
+ ## high-precision-128.h (module 'core'): ns3::HighPrecision::HighPrecision(int64_t high, uint64_t low) [constructor]
+ cls.add_constructor([param('int64_t', 'high'), param('uint64_t', 'low')])
+ ## high-precision-128.h (module 'core'): ns3::HighPrecision::HighPrecision() [constructor]
+ cls.add_constructor([])
+ ## high-precision-128.h (module 'core'): ns3::HighPrecision::HighPrecision(int64_t value, bool dummy) [constructor]
+ cls.add_constructor([param('int64_t', 'value'), param('bool', 'dummy')])
+ ## high-precision-128.h (module 'core'): ns3::HighPrecision::HighPrecision(double value) [constructor]
+ cls.add_constructor([param('double', 'value')])
+ ## high-precision-128.h (module 'core'): void ns3::HighPrecision::Add(ns3::HighPrecision const & o) [member function]
+ cls.add_method('Add',
+ 'void',
+ [param('ns3::HighPrecision const &', 'o')])
+ ## high-precision-128.h (module 'core'): int ns3::HighPrecision::Compare(ns3::HighPrecision const & o) const [member function]
+ cls.add_method('Compare',
+ 'int',
+ [param('ns3::HighPrecision const &', 'o')],
+ is_const=True)
+ ## high-precision-128.h (module 'core'): void ns3::HighPrecision::Div(ns3::HighPrecision const & o) [member function]
+ cls.add_method('Div',
+ 'void',
+ [param('ns3::HighPrecision const &', 'o')])
+ ## high-precision-128.h (module 'core'): double ns3::HighPrecision::GetDouble() const [member function]
+ cls.add_method('GetDouble',
+ 'double',
+ [],
+ is_const=True)
+ ## high-precision-128.h (module 'core'): int64_t ns3::HighPrecision::GetHigh() const [member function]
+ cls.add_method('GetHigh',
+ 'int64_t',
+ [],
+ is_const=True)
+ ## high-precision-128.h (module 'core'): int64_t ns3::HighPrecision::GetInteger() const [member function]
+ cls.add_method('GetInteger',
+ 'int64_t',
+ [],
+ is_const=True)
+ ## high-precision-128.h (module 'core'): uint64_t ns3::HighPrecision::GetLow() const [member function]
+ cls.add_method('GetLow',
+ 'uint64_t',
+ [],
+ is_const=True)
+ ## high-precision-128.h (module 'core'): static ns3::HighPrecision ns3::HighPrecision::Invert(uint64_t v) [member function]
+ cls.add_method('Invert',
+ 'ns3::HighPrecision',
+ [param('uint64_t', 'v')],
+ is_static=True)
+ ## high-precision-128.h (module 'core'): void ns3::HighPrecision::Mul(ns3::HighPrecision const & o) [member function]
+ cls.add_method('Mul',
+ 'void',
+ [param('ns3::HighPrecision const &', 'o')])
+ ## high-precision-128.h (module 'core'): void ns3::HighPrecision::MulByInvert(ns3::HighPrecision const & o) [member function]
+ cls.add_method('MulByInvert',
+ 'void',
+ [param('ns3::HighPrecision const &', 'o')])
+ ## high-precision-128.h (module 'core'): void ns3::HighPrecision::Sub(ns3::HighPrecision const & o) [member function]
+ cls.add_method('Sub',
+ 'void',
+ [param('ns3::HighPrecision const &', 'o')])
+ ## high-precision-128.h (module 'core'): static ns3::HighPrecision ns3::HighPrecision::Zero() [member function]
+ cls.add_method('Zero',
+ 'ns3::HighPrecision',
+ [],
+ is_static=True)
+ return
+
+def register_Ns3ObjectBase_methods(root_module, cls):
+ ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase() [constructor]
+ cls.add_constructor([])
+ ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::ObjectBase const &', 'arg0')])
+ ## object-base.h (module 'core'): void ns3::ObjectBase::GetAttribute(std::string name, ns3::AttributeValue & value) const [member function]
+ cls.add_method('GetAttribute',
+ 'void',
+ [param('std::string', 'name'), param('ns3::AttributeValue &', 'value')],
+ is_const=True)
+ ## object-base.h (module 'core'): bool ns3::ObjectBase::GetAttributeFailSafe(std::string name, ns3::AttributeValue & attribute) const [member function]
+ cls.add_method('GetAttributeFailSafe',
+ 'bool',
+ [param('std::string', 'name'), param('ns3::AttributeValue &', 'attribute')],
+ is_const=True)
+ ## object-base.h (module 'core'): ns3::TypeId ns3::ObjectBase::GetInstanceTypeId() const [member function]
+ cls.add_method('GetInstanceTypeId',
+ 'ns3::TypeId',
+ [],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## object-base.h (module 'core'): static ns3::TypeId ns3::ObjectBase::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## object-base.h (module 'core'): void ns3::ObjectBase::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function]
+ cls.add_method('SetAttribute',
+ 'void',
+ [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
+ ## object-base.h (module 'core'): bool ns3::ObjectBase::SetAttributeFailSafe(std::string name, ns3::AttributeValue const & value) [member function]
+ cls.add_method('SetAttributeFailSafe',
+ 'bool',
+ [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
+ ## object-base.h (module 'core'): bool ns3::ObjectBase::TraceConnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function]
+ cls.add_method('TraceConnect',
+ 'bool',
+ [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')])
+ ## object-base.h (module 'core'): bool ns3::ObjectBase::TraceConnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]
+ cls.add_method('TraceConnectWithoutContext',
+ 'bool',
+ [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])
+ ## object-base.h (module 'core'): bool ns3::ObjectBase::TraceDisconnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function]
+ cls.add_method('TraceDisconnect',
+ 'bool',
+ [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')])
+ ## object-base.h (module 'core'): bool ns3::ObjectBase::TraceDisconnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]
+ cls.add_method('TraceDisconnectWithoutContext',
+ 'bool',
+ [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])
+ ## object-base.h (module 'core'): void ns3::ObjectBase::ConstructSelf(ns3::AttributeList const & attributes) [member function]
+ cls.add_method('ConstructSelf',
+ 'void',
+ [param('ns3::AttributeList const &', 'attributes')],
+ visibility='protected')
+ ## object-base.h (module 'core'): void ns3::ObjectBase::NotifyConstructionCompleted() [member function]
+ cls.add_method('NotifyConstructionCompleted',
+ 'void',
+ [],
+ visibility='protected', is_virtual=True)
+ return
+
+def register_Ns3ObjectDeleter_methods(root_module, cls):
+ ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter() [constructor]
+ cls.add_constructor([])
+ ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter(ns3::ObjectDeleter const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::ObjectDeleter const &', 'arg0')])
+ ## object.h (module 'core'): static void ns3::ObjectDeleter::Delete(ns3::Object * object) [member function]
+ cls.add_method('Delete',
+ 'void',
+ [param('ns3::Object *', 'object')],
+ is_static=True)
+ return
+
+def register_Ns3RandomVariable_methods(root_module, cls):
+ cls.add_output_stream_operator()
+ ## random-variable.h (module 'core'): ns3::RandomVariable::RandomVariable() [constructor]
+ cls.add_constructor([])
+ ## random-variable.h (module 'core'): ns3::RandomVariable::RandomVariable(ns3::RandomVariable const & o) [copy constructor]
+ cls.add_constructor([param('ns3::RandomVariable const &', 'o')])
+ ## random-variable.h (module 'core'): uint32_t ns3::RandomVariable::GetInteger() const [member function]
+ cls.add_method('GetInteger',
+ 'uint32_t',
+ [],
+ is_const=True)
+ ## random-variable.h (module 'core'): double ns3::RandomVariable::GetValue() const [member function]
+ cls.add_method('GetValue',
+ 'double',
+ [],
+ is_const=True)
+ return
+
+def register_Ns3SeedManager_methods(root_module, cls):
+ ## random-variable.h (module 'core'): ns3::SeedManager::SeedManager() [constructor]
+ cls.add_constructor([])
+ ## random-variable.h (module 'core'): ns3::SeedManager::SeedManager(ns3::SeedManager const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::SeedManager const &', 'arg0')])
+ ## random-variable.h (module 'core'): static bool ns3::SeedManager::CheckSeed(uint32_t seed) [member function]
+ cls.add_method('CheckSeed',
+ 'bool',
+ [param('uint32_t', 'seed')],
+ is_static=True)
+ ## random-variable.h (module 'core'): static uint32_t ns3::SeedManager::GetRun() [member function]
+ cls.add_method('GetRun',
+ 'uint32_t',
+ [],
+ is_static=True)
+ ## random-variable.h (module 'core'): static uint32_t ns3::SeedManager::GetSeed() [member function]
+ cls.add_method('GetSeed',
+ 'uint32_t',
+ [],
+ is_static=True)
+ ## random-variable.h (module 'core'): static void ns3::SeedManager::SetRun(uint32_t run) [member function]
+ cls.add_method('SetRun',
+ 'void',
+ [param('uint32_t', 'run')],
+ is_static=True)
+ ## random-variable.h (module 'core'): static void ns3::SeedManager::SetSeed(uint32_t seed) [member function]
+ cls.add_method('SetSeed',
+ 'void',
+ [param('uint32_t', 'seed')],
+ is_static=True)
+ return
+
+def register_Ns3SequentialVariable_methods(root_module, cls):
+ ## random-variable.h (module 'core'): ns3::SequentialVariable::SequentialVariable(ns3::SequentialVariable const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::SequentialVariable const &', 'arg0')])
+ ## random-variable.h (module 'core'): ns3::SequentialVariable::SequentialVariable(double f, double l, double i=1, uint32_t c=1) [constructor]
+ cls.add_constructor([param('double', 'f'), param('double', 'l'), param('double', 'i', default_value='1'), param('uint32_t', 'c', default_value='1')])
+ ## random-variable.h (module 'core'): ns3::SequentialVariable::SequentialVariable(double f, double l, ns3::RandomVariable const & i, uint32_t c=1) [constructor]
+ cls.add_constructor([param('double', 'f'), param('double', 'l'), param('ns3::RandomVariable const &', 'i'), param('uint32_t', 'c', default_value='1')])
+ return
+
+def register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods(root_module, cls):
+ ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter>::SimpleRefCount() [constructor]
+ cls.add_constructor([])
+ ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter>::SimpleRefCount(ns3::SimpleRefCount<ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter> const & o) [copy constructor]
+ cls.add_constructor([param('ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter > const &', 'o')])
+ ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount<ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter>::Cleanup() [member function]
+ cls.add_method('Cleanup',
+ 'void',
+ [],
+ is_static=True)
+ return
+
+def register_Ns3Time_methods(root_module, cls):
+ cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', 'right'))
+ cls.add_binary_numeric_operator('+', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', 'right'))
+ cls.add_binary_numeric_operator('-', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', 'right'))
+ cls.add_binary_numeric_operator('/', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', 'right'))
+ cls.add_binary_comparison_operator('<')
+ cls.add_binary_comparison_operator('>')
+ cls.add_binary_comparison_operator('!=')
+ cls.add_inplace_numeric_operator('*=', param('ns3::Time const &', 'right'))
+ cls.add_inplace_numeric_operator('+=', param('ns3::Time const &', 'right'))
+ cls.add_inplace_numeric_operator('-=', param('ns3::Time const &', 'right'))
+ cls.add_inplace_numeric_operator('/=', param('ns3::Time const &', 'right'))
+ cls.add_output_stream_operator()
+ cls.add_binary_comparison_operator('<=')
+ cls.add_binary_comparison_operator('==')
+ cls.add_binary_comparison_operator('>=')
+ ## nstime.h (module 'core'): ns3::Time::Time() [constructor]
+ cls.add_constructor([])
+ ## nstime.h (module 'core'): ns3::Time::Time(ns3::Time const & o) [copy constructor]
+ cls.add_constructor([param('ns3::Time const &', 'o')])
+ ## nstime.h (module 'core'): ns3::Time::Time(ns3::HighPrecision const & data) [constructor]
+ cls.add_constructor([param('ns3::HighPrecision const &', 'data')])
+ ## nstime.h (module 'core'): ns3::Time::Time(std::string const & s) [constructor]
+ cls.add_constructor([param('std::string const &', 's')])
+ ## nstime.h (module 'core'): int ns3::Time::Compare(ns3::Time const & o) const [member function]
+ cls.add_method('Compare',
+ 'int',
+ [param('ns3::Time const &', 'o')],
+ is_const=True)
+ ## nstime.h (module 'core'): static ns3::Time ns3::Time::FromDouble(double value, ns3::Time::Unit timeUnit) [member function]
+ cls.add_method('FromDouble',
+ 'ns3::Time',
+ [param('double', 'value'), param('ns3::Time::Unit', 'timeUnit')],
+ is_static=True)
+ ## nstime.h (module 'core'): static ns3::Time ns3::Time::FromInteger(uint64_t value, ns3::Time::Unit timeUnit) [member function]
+ cls.add_method('FromInteger',
+ 'ns3::Time',
+ [param('uint64_t', 'value'), param('ns3::Time::Unit', 'timeUnit')],
+ is_static=True)
+ ## nstime.h (module 'core'): int64_t ns3::Time::GetFemtoSeconds() const [member function]
+ cls.add_method('GetFemtoSeconds',
+ 'int64_t',
+ [],
+ is_const=True)
+ ## nstime.h (module 'core'): ns3::HighPrecision const & ns3::Time::GetHighPrecision() const [member function]
+ cls.add_method('GetHighPrecision',
+ 'ns3::HighPrecision const &',
+ [],
+ is_const=True)
+ ## nstime.h (module 'core'): int64_t ns3::Time::GetMicroSeconds() const [member function]
+ cls.add_method('GetMicroSeconds',
+ 'int64_t',
+ [],
+ is_const=True)
+ ## nstime.h (module 'core'): int64_t ns3::Time::GetMilliSeconds() const [member function]
+ cls.add_method('GetMilliSeconds',
+ 'int64_t',
+ [],
+ is_const=True)
+ ## nstime.h (module 'core'): int64_t ns3::Time::GetNanoSeconds() const [member function]
+ cls.add_method('GetNanoSeconds',
+ 'int64_t',
+ [],
+ is_const=True)
+ ## nstime.h (module 'core'): int64_t ns3::Time::GetPicoSeconds() const [member function]
+ cls.add_method('GetPicoSeconds',
+ 'int64_t',
+ [],
+ is_const=True)
+ ## nstime.h (module 'core'): static ns3::Time::Unit ns3::Time::GetResolution() [member function]
+ cls.add_method('GetResolution',
+ 'ns3::Time::Unit',
+ [],
+ is_static=True)
+ ## nstime.h (module 'core'): double ns3::Time::GetSeconds() const [member function]
+ cls.add_method('GetSeconds',
+ 'double',
+ [],
+ is_const=True)
+ ## nstime.h (module 'core'): int64_t ns3::Time::GetTimeStep() const [member function]
+ cls.add_method('GetTimeStep',
+ 'int64_t',
+ [],
+ is_const=True)
+ ## nstime.h (module 'core'): bool ns3::Time::IsNegative() const [member function]
+ cls.add_method('IsNegative',
+ 'bool',
+ [],
+ is_const=True)
+ ## nstime.h (module 'core'): bool ns3::Time::IsPositive() const [member function]
+ cls.add_method('IsPositive',
+ 'bool',
+ [],
+ is_const=True)
+ ## nstime.h (module 'core'): bool ns3::Time::IsStrictlyNegative() const [member function]
+ cls.add_method('IsStrictlyNegative',
+ 'bool',
+ [],
+ is_const=True)
+ ## nstime.h (module 'core'): bool ns3::Time::IsStrictlyPositive() const [member function]
+ cls.add_method('IsStrictlyPositive',
+ 'bool',
+ [],
+ is_const=True)
+ ## nstime.h (module 'core'): bool ns3::Time::IsZero() const [member function]
+ cls.add_method('IsZero',
+ 'bool',
+ [],
+ is_const=True)
+ ## nstime.h (module 'core'): ns3::HighPrecision * ns3::Time::PeekHighPrecision() [member function]
+ cls.add_method('PeekHighPrecision',
+ 'ns3::HighPrecision *',
+ [])
+ ## nstime.h (module 'core'): static void ns3::Time::SetResolution(ns3::Time::Unit resolution) [member function]
+ cls.add_method('SetResolution',
+ 'void',
+ [param('ns3::Time::Unit', 'resolution')],
+ is_static=True)
+ ## nstime.h (module 'core'): static double ns3::Time::ToDouble(ns3::Time const & time, ns3::Time::Unit timeUnit) [member function]
+ cls.add_method('ToDouble',
+ 'double',
+ [param('ns3::Time const &', 'time'), param('ns3::Time::Unit', 'timeUnit')],
+ is_static=True)
+ ## nstime.h (module 'core'): static uint64_t ns3::Time::ToInteger(ns3::Time const & time, ns3::Time::Unit timeUnit) [member function]
+ cls.add_method('ToInteger',
+ 'uint64_t',
+ [param('ns3::Time const &', 'time'), param('ns3::Time::Unit', 'timeUnit')],
+ is_static=True)
+ return
+
+def register_Ns3TriangularVariable_methods(root_module, cls):
+ ## random-variable.h (module 'core'): ns3::TriangularVariable::TriangularVariable(ns3::TriangularVariable const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::TriangularVariable const &', 'arg0')])
+ ## random-variable.h (module 'core'): ns3::TriangularVariable::TriangularVariable() [constructor]
+ cls.add_constructor([])
+ ## random-variable.h (module 'core'): ns3::TriangularVariable::TriangularVariable(double s, double l, double mean) [constructor]
+ cls.add_constructor([param('double', 's'), param('double', 'l'), param('double', 'mean')])
+ return
+
+def register_Ns3TypeId_methods(root_module, cls):
+ cls.add_binary_comparison_operator('<')
+ cls.add_binary_comparison_operator('!=')
+ cls.add_output_stream_operator()
+ cls.add_binary_comparison_operator('==')
+ ## type-id.h (module 'core'): ns3::TypeId::TypeId(char const * name) [constructor]
+ cls.add_constructor([param('char const *', 'name')])
+ ## type-id.h (module 'core'): ns3::TypeId::TypeId() [constructor]
+ cls.add_constructor([])
+ ## type-id.h (module 'core'): ns3::TypeId::TypeId(ns3::TypeId const & o) [copy constructor]
+ cls.add_constructor([param('ns3::TypeId const &', 'o')])
+ ## type-id.h (module 'core'): 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]
+ cls.add_method('AddAttribute',
+ 'ns3::TypeId',
+ [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')])
+ ## type-id.h (module 'core'): 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]
+ cls.add_method('AddAttribute',
+ 'ns3::TypeId',
+ [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')])
+ ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr<const ns3::TraceSourceAccessor> accessor) [member function]
+ cls.add_method('AddTraceSource',
+ 'ns3::TypeId',
+ [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')])
+ ## type-id.h (module 'core'): ns3::Ptr<ns3::AttributeAccessor const> ns3::TypeId::GetAttributeAccessor(uint32_t i) const [member function]
+ cls.add_method('GetAttributeAccessor',
+ 'ns3::Ptr< ns3::AttributeAccessor const >',
+ [param('uint32_t', 'i')],
+ is_const=True)
+ ## type-id.h (module 'core'): ns3::Ptr<ns3::AttributeChecker const> ns3::TypeId::GetAttributeChecker(uint32_t i) const [member function]
+ cls.add_method('GetAttributeChecker',
+ 'ns3::Ptr< ns3::AttributeChecker const >',
+ [param('uint32_t', 'i')],
+ is_const=True)
+ ## type-id.h (module 'core'): uint32_t ns3::TypeId::GetAttributeFlags(uint32_t i) const [member function]
+ cls.add_method('GetAttributeFlags',
+ 'uint32_t',
+ [param('uint32_t', 'i')],
+ is_const=True)
+ ## type-id.h (module 'core'): std::string ns3::TypeId::GetAttributeFullName(uint32_t i) const [member function]
+ cls.add_method('GetAttributeFullName',
+ 'std::string',
+ [param('uint32_t', 'i')],
+ is_const=True)
+ ## type-id.h (module 'core'): std::string ns3::TypeId::GetAttributeHelp(uint32_t i) const [member function]
+ cls.add_method('GetAttributeHelp',
+ 'std::string',
+ [param('uint32_t', 'i')],
+ is_const=True)
+ ## type-id.h (module 'core'): ns3::Ptr<ns3::AttributeValue const> ns3::TypeId::GetAttributeInitialValue(uint32_t i) const [member function]
+ cls.add_method('GetAttributeInitialValue',
+ 'ns3::Ptr< ns3::AttributeValue const >',
+ [param('uint32_t', 'i')],
+ is_const=True)
+ ## type-id.h (module 'core'): uint32_t ns3::TypeId::GetAttributeN() const [member function]
+ cls.add_method('GetAttributeN',
+ 'uint32_t',
+ [],
+ is_const=True)
+ ## type-id.h (module 'core'): std::string ns3::TypeId::GetAttributeName(uint32_t i) const [member function]
+ cls.add_method('GetAttributeName',
+ 'std::string',
+ [param('uint32_t', 'i')],
+ is_const=True)
+ ## type-id.h (module 'core'): 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]
+ cls.add_method('GetConstructor',
+ 'ns3::Callback< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >',
+ [],
+ is_const=True)
+ ## type-id.h (module 'core'): std::string ns3::TypeId::GetGroupName() const [member function]
+ cls.add_method('GetGroupName',
+ 'std::string',
+ [],
+ is_const=True)
+ ## type-id.h (module 'core'): std::string ns3::TypeId::GetName() const [member function]
+ cls.add_method('GetName',
+ 'std::string',
+ [],
+ is_const=True)
+ ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::GetParent() const [member function]
+ cls.add_method('GetParent',
+ 'ns3::TypeId',
+ [],
+ is_const=True)
+ ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::GetRegistered(uint32_t i) [member function]
+ cls.add_method('GetRegistered',
+ 'ns3::TypeId',
+ [param('uint32_t', 'i')],
+ is_static=True)
+ ## type-id.h (module 'core'): static uint32_t ns3::TypeId::GetRegisteredN() [member function]
+ cls.add_method('GetRegisteredN',
+ 'uint32_t',
+ [],
+ is_static=True)
+ ## type-id.h (module 'core'): ns3::Ptr<const ns3::TraceSourceAccessor> ns3::TypeId::GetTraceSourceAccessor(uint32_t i) const [member function]
+ cls.add_method('GetTraceSourceAccessor',
+ 'ns3::Ptr< ns3::TraceSourceAccessor const >',
+ [param('uint32_t', 'i')],
+ is_const=True)
+ ## type-id.h (module 'core'): std::string ns3::TypeId::GetTraceSourceHelp(uint32_t i) const [member function]
+ cls.add_method('GetTraceSourceHelp',
+ 'std::string',
+ [param('uint32_t', 'i')],
+ is_const=True)
+ ## type-id.h (module 'core'): uint32_t ns3::TypeId::GetTraceSourceN() const [member function]
+ cls.add_method('GetTraceSourceN',
+ 'uint32_t',
+ [],
+ is_const=True)
+ ## type-id.h (module 'core'): std::string ns3::TypeId::GetTraceSourceName(uint32_t i) const [member function]
+ cls.add_method('GetTraceSourceName',
+ 'std::string',
+ [param('uint32_t', 'i')],
+ is_const=True)
+ ## type-id.h (module 'core'): uint16_t ns3::TypeId::GetUid() const [member function]
+ cls.add_method('GetUid',
+ 'uint16_t',
+ [],
+ is_const=True)
+ ## type-id.h (module 'core'): bool ns3::TypeId::HasConstructor() const [member function]
+ cls.add_method('HasConstructor',
+ 'bool',
+ [],
+ is_const=True)
+ ## type-id.h (module 'core'): bool ns3::TypeId::HasParent() const [member function]
+ cls.add_method('HasParent',
+ 'bool',
+ [],
+ is_const=True)
+ ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::HideFromDocumentation() [member function]
+ cls.add_method('HideFromDocumentation',
+ 'ns3::TypeId',
+ [])
+ ## type-id.h (module 'core'): bool ns3::TypeId::IsChildOf(ns3::TypeId other) const [member function]
+ cls.add_method('IsChildOf',
+ 'bool',
+ [param('ns3::TypeId', 'other')],
+ is_const=True)
+ ## type-id.h (module 'core'): static bool ns3::TypeId::LookupAttributeByFullName(std::string fullName, ns3::TypeId::AttributeInfo * info) [member function]
+ cls.add_method('LookupAttributeByFullName',
+ 'bool',
+ [param('std::string', 'fullName'), param('ns3::TypeId::AttributeInfo *', 'info')],
+ is_static=True)
+ ## type-id.h (module 'core'): bool ns3::TypeId::LookupAttributeByName(std::string name, ns3::TypeId::AttributeInfo * info) const [member function]
+ cls.add_method('LookupAttributeByName',
+ 'bool',
+ [param('std::string', 'name'), param('ns3::TypeId::AttributeInfo *', 'info', transfer_ownership=False)],
+ is_const=True)
+ ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::LookupByName(std::string name) [member function]
+ cls.add_method('LookupByName',
+ 'ns3::TypeId',
+ [param('std::string', 'name')],
+ is_static=True)
+ ## type-id.h (module 'core'): ns3::Ptr<const ns3::TraceSourceAccessor> ns3::TypeId::LookupTraceSourceByName(std::string name) const [member function]
+ cls.add_method('LookupTraceSourceByName',
+ 'ns3::Ptr< ns3::TraceSourceAccessor const >',
+ [param('std::string', 'name')],
+ is_const=True)
+ ## type-id.h (module 'core'): bool ns3::TypeId::MustHideFromDocumentation() const [member function]
+ cls.add_method('MustHideFromDocumentation',
+ 'bool',
+ [],
+ is_const=True)
+ ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::SetGroupName(std::string groupName) [member function]
+ cls.add_method('SetGroupName',
+ 'ns3::TypeId',
+ [param('std::string', 'groupName')])
+ ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::SetParent(ns3::TypeId tid) [member function]
+ cls.add_method('SetParent',
+ 'ns3::TypeId',
+ [param('ns3::TypeId', 'tid')])
+ ## type-id.h (module 'core'): void ns3::TypeId::SetUid(uint16_t tid) [member function]
+ cls.add_method('SetUid',
+ 'void',
+ [param('uint16_t', 'tid')])
+ return
+
+def register_Ns3TypeIdAttributeInfo_methods(root_module, cls):
+ ## type-id.h (module 'core'): ns3::TypeId::AttributeInfo::AttributeInfo() [constructor]
+ cls.add_constructor([])
+ ## type-id.h (module 'core'): ns3::TypeId::AttributeInfo::AttributeInfo(ns3::TypeId::AttributeInfo const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::TypeId::AttributeInfo const &', 'arg0')])
+ ## type-id.h (module 'core'): ns3::TypeId::AttributeInfo::accessor [variable]
+ cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::AttributeAccessor const >', is_const=False)
+ ## type-id.h (module 'core'): ns3::TypeId::AttributeInfo::checker [variable]
+ cls.add_instance_attribute('checker', 'ns3::Ptr< ns3::AttributeChecker const >', is_const=False)
+ ## type-id.h (module 'core'): ns3::TypeId::AttributeInfo::flags [variable]
+ cls.add_instance_attribute('flags', 'uint32_t', is_const=False)
+ ## type-id.h (module 'core'): ns3::TypeId::AttributeInfo::initialValue [variable]
+ cls.add_instance_attribute('initialValue', 'ns3::Ptr< ns3::AttributeValue const >', is_const=False)
+ return
+
+def register_Ns3UniformVariable_methods(root_module, cls):
+ ## random-variable.h (module 'core'): ns3::UniformVariable::UniformVariable(ns3::UniformVariable const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::UniformVariable const &', 'arg0')])
+ ## random-variable.h (module 'core'): ns3::UniformVariable::UniformVariable() [constructor]
+ cls.add_constructor([])
+ ## random-variable.h (module 'core'): ns3::UniformVariable::UniformVariable(double s, double l) [constructor]
+ cls.add_constructor([param('double', 's'), param('double', 'l')])
+ ## random-variable.h (module 'core'): uint32_t ns3::UniformVariable::GetInteger(uint32_t s, uint32_t l) [member function]
+ cls.add_method('GetInteger',
+ 'uint32_t',
+ [param('uint32_t', 's'), param('uint32_t', 'l')])
+ ## random-variable.h (module 'core'): double ns3::UniformVariable::GetValue() const [member function]
+ cls.add_method('GetValue',
+ 'double',
+ [],
+ is_const=True)
+ ## random-variable.h (module 'core'): double ns3::UniformVariable::GetValue(double s, double l) [member function]
+ cls.add_method('GetValue',
+ 'double',
+ [param('double', 's'), param('double', 'l')])
+ return
+
+def register_Ns3UnsafeAttributeList_methods(root_module, cls):
+ ## attribute-list.h (module 'core'): ns3::UnsafeAttributeList::UnsafeAttributeList() [constructor]
+ cls.add_constructor([])
+ ## attribute-list.h (module 'core'): ns3::UnsafeAttributeList::UnsafeAttributeList(ns3::UnsafeAttributeList const & o) [copy constructor]
+ cls.add_constructor([param('ns3::UnsafeAttributeList const &', 'o')])
+ ## attribute-list.h (module 'core'): ns3::AttributeList ns3::UnsafeAttributeList::GetSafe(std::string name) const [member function]
+ cls.add_method('GetSafe',
+ 'ns3::AttributeList',
+ [param('std::string', 'name')],
+ is_const=True)
+ ## attribute-list.h (module 'core'): void ns3::UnsafeAttributeList::Set(std::string name, ns3::AttributeValue const & param) [member function]
+ cls.add_method('Set',
+ 'void',
+ [param('std::string', 'name'), param('ns3::AttributeValue const &', 'param')])
+ return
+
+def register_Ns3WeibullVariable_methods(root_module, cls):
+ ## random-variable.h (module 'core'): ns3::WeibullVariable::WeibullVariable(ns3::WeibullVariable const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::WeibullVariable const &', 'arg0')])
+ ## random-variable.h (module 'core'): ns3::WeibullVariable::WeibullVariable() [constructor]
+ cls.add_constructor([])
+ ## random-variable.h (module 'core'): ns3::WeibullVariable::WeibullVariable(double m) [constructor]
+ cls.add_constructor([param('double', 'm')])
+ ## random-variable.h (module 'core'): ns3::WeibullVariable::WeibullVariable(double m, double s) [constructor]
+ cls.add_constructor([param('double', 'm'), param('double', 's')])
+ ## random-variable.h (module 'core'): ns3::WeibullVariable::WeibullVariable(double m, double s, double b) [constructor]
+ cls.add_constructor([param('double', 'm'), param('double', 's'), param('double', 'b')])
+ return
+
+def register_Ns3ZetaVariable_methods(root_module, cls):
+ ## random-variable.h (module 'core'): ns3::ZetaVariable::ZetaVariable(ns3::ZetaVariable const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::ZetaVariable const &', 'arg0')])
+ ## random-variable.h (module 'core'): ns3::ZetaVariable::ZetaVariable(double alpha) [constructor]
+ cls.add_constructor([param('double', 'alpha')])
+ ## random-variable.h (module 'core'): ns3::ZetaVariable::ZetaVariable() [constructor]
+ cls.add_constructor([])
+ return
+
+def register_Ns3ZipfVariable_methods(root_module, cls):
+ ## random-variable.h (module 'core'): ns3::ZipfVariable::ZipfVariable(ns3::ZipfVariable const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::ZipfVariable const &', 'arg0')])
+ ## random-variable.h (module 'core'): ns3::ZipfVariable::ZipfVariable(long int N, double alpha) [constructor]
+ cls.add_constructor([param('long int', 'N'), param('double', 'alpha')])
+ ## random-variable.h (module 'core'): ns3::ZipfVariable::ZipfVariable() [constructor]
+ cls.add_constructor([])
+ return
+
+def register_Ns3Empty_methods(root_module, cls):
+ ## empty.h (module 'core'): ns3::empty::empty() [constructor]
+ cls.add_constructor([])
+ ## empty.h (module 'core'): ns3::empty::empty(ns3::empty const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::empty const &', 'arg0')])
+ return
+
+def register_Ns3ConstantVariable_methods(root_module, cls):
+ ## random-variable.h (module 'core'): ns3::ConstantVariable::ConstantVariable(ns3::ConstantVariable const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::ConstantVariable const &', 'arg0')])
+ ## random-variable.h (module 'core'): ns3::ConstantVariable::ConstantVariable() [constructor]
+ cls.add_constructor([])
+ ## random-variable.h (module 'core'): ns3::ConstantVariable::ConstantVariable(double c) [constructor]
+ cls.add_constructor([param('double', 'c')])
+ ## random-variable.h (module 'core'): void ns3::ConstantVariable::SetConstant(double c) [member function]
+ cls.add_method('SetConstant',
+ 'void',
+ [param('double', 'c')])
+ return
+
+def register_Ns3DeterministicVariable_methods(root_module, cls):
+ ## random-variable.h (module 'core'): ns3::DeterministicVariable::DeterministicVariable(ns3::DeterministicVariable const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::DeterministicVariable const &', 'arg0')])
+ ## random-variable.h (module 'core'): ns3::DeterministicVariable::DeterministicVariable(double * d, uint32_t c) [constructor]
+ cls.add_constructor([param('double *', 'd'), param('uint32_t', 'c')])
+ return
+
+def register_Ns3EmpiricalVariable_methods(root_module, cls):
+ ## random-variable.h (module 'core'): ns3::EmpiricalVariable::EmpiricalVariable(ns3::EmpiricalVariable const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::EmpiricalVariable const &', 'arg0')])
+ ## random-variable.h (module 'core'): ns3::EmpiricalVariable::EmpiricalVariable() [constructor]
+ cls.add_constructor([])
+ ## random-variable.h (module 'core'): void ns3::EmpiricalVariable::CDF(double v, double c) [member function]
+ cls.add_method('CDF',
+ 'void',
+ [param('double', 'v'), param('double', 'c')])
+ return
+
+def register_Ns3ErlangVariable_methods(root_module, cls):
+ ## random-variable.h (module 'core'): ns3::ErlangVariable::ErlangVariable(ns3::ErlangVariable const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::ErlangVariable const &', 'arg0')])
+ ## random-variable.h (module 'core'): ns3::ErlangVariable::ErlangVariable() [constructor]
+ cls.add_constructor([])
+ ## random-variable.h (module 'core'): ns3::ErlangVariable::ErlangVariable(unsigned int k, double lambda) [constructor]
+ cls.add_constructor([param('unsigned int', 'k'), param('double', 'lambda')])
+ ## random-variable.h (module 'core'): double ns3::ErlangVariable::GetValue() const [member function]
+ cls.add_method('GetValue',
+ 'double',
+ [],
+ is_const=True)
+ ## random-variable.h (module 'core'): double ns3::ErlangVariable::GetValue(unsigned int k, double lambda) const [member function]
+ cls.add_method('GetValue',
+ 'double',
+ [param('unsigned int', 'k'), param('double', 'lambda')],
+ is_const=True)
+ return
+
+def register_Ns3ExponentialVariable_methods(root_module, cls):
+ ## random-variable.h (module 'core'): ns3::ExponentialVariable::ExponentialVariable(ns3::ExponentialVariable const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::ExponentialVariable const &', 'arg0')])
+ ## random-variable.h (module 'core'): ns3::ExponentialVariable::ExponentialVariable() [constructor]
+ cls.add_constructor([])
+ ## random-variable.h (module 'core'): ns3::ExponentialVariable::ExponentialVariable(double m) [constructor]
+ cls.add_constructor([param('double', 'm')])
+ ## random-variable.h (module 'core'): ns3::ExponentialVariable::ExponentialVariable(double m, double b) [constructor]
+ cls.add_constructor([param('double', 'm'), param('double', 'b')])
+ return
+
+def register_Ns3GammaVariable_methods(root_module, cls):
+ ## random-variable.h (module 'core'): ns3::GammaVariable::GammaVariable(ns3::GammaVariable const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::GammaVariable const &', 'arg0')])
+ ## random-variable.h (module 'core'): ns3::GammaVariable::GammaVariable() [constructor]
+ cls.add_constructor([])
+ ## random-variable.h (module 'core'): ns3::GammaVariable::GammaVariable(double alpha, double beta) [constructor]
+ cls.add_constructor([param('double', 'alpha'), param('double', 'beta')])
+ ## random-variable.h (module 'core'): double ns3::GammaVariable::GetValue() const [member function]
+ cls.add_method('GetValue',
+ 'double',
+ [],
+ is_const=True)
+ ## random-variable.h (module 'core'): double ns3::GammaVariable::GetValue(double alpha, double beta) const [member function]
+ cls.add_method('GetValue',
+ 'double',
+ [param('double', 'alpha'), param('double', 'beta')],
+ is_const=True)
+ return
+
+def register_Ns3IntEmpiricalVariable_methods(root_module, cls):
+ ## random-variable.h (module 'core'): ns3::IntEmpiricalVariable::IntEmpiricalVariable(ns3::IntEmpiricalVariable const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::IntEmpiricalVariable const &', 'arg0')])
+ ## random-variable.h (module 'core'): ns3::IntEmpiricalVariable::IntEmpiricalVariable() [constructor]
+ cls.add_constructor([])
+ return
+
+def register_Ns3LogNormalVariable_methods(root_module, cls):
+ ## random-variable.h (module 'core'): ns3::LogNormalVariable::LogNormalVariable(ns3::LogNormalVariable const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::LogNormalVariable const &', 'arg0')])
+ ## random-variable.h (module 'core'): ns3::LogNormalVariable::LogNormalVariable(double mu, double sigma) [constructor]
+ cls.add_constructor([param('double', 'mu'), param('double', 'sigma')])
+ return
+
+def register_Ns3NormalVariable_methods(root_module, cls):
+ ## random-variable.h (module 'core'): ns3::NormalVariable::NormalVariable(ns3::NormalVariable const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::NormalVariable const &', 'arg0')])
+ ## random-variable.h (module 'core'): ns3::NormalVariable::NormalVariable() [constructor]
+ cls.add_constructor([])
+ ## random-variable.h (module 'core'): ns3::NormalVariable::NormalVariable(double m, double v) [constructor]
+ cls.add_constructor([param('double', 'm'), param('double', 'v')])
+ ## random-variable.h (module 'core'): ns3::NormalVariable::NormalVariable(double m, double v, double b) [constructor]
+ cls.add_constructor([param('double', 'm'), param('double', 'v'), param('double', 'b')])
+ return
+
+def register_Ns3Object_methods(root_module, cls):
+ ## object.h (module 'core'): ns3::Object::Object() [constructor]
+ cls.add_constructor([])
+ ## object.h (module 'core'): void ns3::Object::AggregateObject(ns3::Ptr<ns3::Object> other) [member function]
+ cls.add_method('AggregateObject',
+ 'void',
+ [param('ns3::Ptr< ns3::Object >', 'other')])
+ ## object.h (module 'core'): void ns3::Object::Dispose() [member function]
+ cls.add_method('Dispose',
+ 'void',
+ [])
+ ## object.h (module 'core'): ns3::Object::AggregateIterator ns3::Object::GetAggregateIterator() const [member function]
+ cls.add_method('GetAggregateIterator',
+ 'ns3::Object::AggregateIterator',
+ [],
+ is_const=True)
+ ## object.h (module 'core'): ns3::TypeId ns3::Object::GetInstanceTypeId() const [member function]
+ cls.add_method('GetInstanceTypeId',
+ 'ns3::TypeId',
+ [],
+ is_const=True, is_virtual=True)
+ ## object.h (module 'core'): static ns3::TypeId ns3::Object::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## object.h (module 'core'): void ns3::Object::Start() [member function]
+ cls.add_method('Start',
+ 'void',
+ [])
+ ## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
+ cls.add_constructor([param('ns3::Object const &', 'o')],
+ visibility='protected')
+ ## object.h (module 'core'): void ns3::Object::DoDispose() [member function]
+ cls.add_method('DoDispose',
+ 'void',
+ [],
+ visibility='protected', is_virtual=True)
+ ## object.h (module 'core'): void ns3::Object::DoStart() [member function]
+ cls.add_method('DoStart',
+ 'void',
+ [],
+ visibility='protected', is_virtual=True)
+ ## object.h (module 'core'): void ns3::Object::NotifyNewAggregate() [member function]
+ cls.add_method('NotifyNewAggregate',
+ 'void',
+ [],
+ visibility='protected', is_virtual=True)
+ return
+
+def register_Ns3ObjectAggregateIterator_methods(root_module, cls):
+ ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::Object::AggregateIterator const &', 'arg0')])
+ ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator() [constructor]
+ cls.add_constructor([])
+ ## object.h (module 'core'): bool ns3::Object::AggregateIterator::HasNext() const [member function]
+ cls.add_method('HasNext',
+ 'bool',
+ [],
+ is_const=True)
+ ## object.h (module 'core'): ns3::Ptr<ns3::Object const> ns3::Object::AggregateIterator::Next() [member function]
+ cls.add_method('Next',
+ 'ns3::Ptr< ns3::Object const >',
+ [])
+ return
+
+def register_Ns3ParetoVariable_methods(root_module, cls):
+ ## random-variable.h (module 'core'): ns3::ParetoVariable::ParetoVariable(ns3::ParetoVariable const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::ParetoVariable const &', 'arg0')])
+ ## random-variable.h (module 'core'): ns3::ParetoVariable::ParetoVariable() [constructor]
+ cls.add_constructor([])
+ ## random-variable.h (module 'core'): ns3::ParetoVariable::ParetoVariable(double m) [constructor]
+ cls.add_constructor([param('double', 'm')])
+ ## random-variable.h (module 'core'): ns3::ParetoVariable::ParetoVariable(double m, double s) [constructor]
+ cls.add_constructor([param('double', 'm'), param('double', 's')])
+ ## random-variable.h (module 'core'): ns3::ParetoVariable::ParetoVariable(double m, double s, double b) [constructor]
+ cls.add_constructor([param('double', 'm'), param('double', 's'), param('double', 'b')])
+ ## random-variable.h (module 'core'): ns3::ParetoVariable::ParetoVariable(std::pair<double,double> params) [constructor]
+ cls.add_constructor([param('std::pair< double, double >', 'params')])
+ ## random-variable.h (module 'core'): ns3::ParetoVariable::ParetoVariable(std::pair<double,double> params, double b) [constructor]
+ cls.add_constructor([param('std::pair< double, double >', 'params'), param('double', 'b')])
+ return
+
+def register_Ns3PropagationDelayModel_methods(root_module, cls):
+ ## propagation-delay-model.h (module 'propagation'): ns3::PropagationDelayModel::PropagationDelayModel() [constructor]
+ cls.add_constructor([])
+ ## propagation-delay-model.h (module 'propagation'): ns3::PropagationDelayModel::PropagationDelayModel(ns3::PropagationDelayModel const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::PropagationDelayModel const &', 'arg0')])
+ ## propagation-delay-model.h (module 'propagation'): ns3::Time ns3::PropagationDelayModel::GetDelay(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+ cls.add_method('GetDelay',
+ 'ns3::Time',
+ [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## propagation-delay-model.h (module 'propagation'): static ns3::TypeId ns3::PropagationDelayModel::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ return
+
+def register_Ns3PropagationLossModel_methods(root_module, cls):
+ ## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::PropagationLossModel::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## propagation-loss-model.h (module 'propagation'): ns3::PropagationLossModel::PropagationLossModel() [constructor]
+ cls.add_constructor([])
+ ## propagation-loss-model.h (module 'propagation'): void ns3::PropagationLossModel::SetNext(ns3::Ptr<ns3::PropagationLossModel> next) [member function]
+ cls.add_method('SetNext',
+ 'void',
+ [param('ns3::Ptr< ns3::PropagationLossModel >', 'next')])
+ ## propagation-loss-model.h (module 'propagation'): double ns3::PropagationLossModel::CalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+ cls.add_method('CalcRxPower',
+ 'double',
+ [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
+ is_const=True)
+ ## propagation-loss-model.h (module 'propagation'): double ns3::PropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+ cls.add_method('DoCalcRxPower',
+ 'double',
+ [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
+ is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
+ return
+
+def register_Ns3RandomPropagationDelayModel_methods(root_module, cls):
+ ## propagation-delay-model.h (module 'propagation'): ns3::RandomPropagationDelayModel::RandomPropagationDelayModel(ns3::RandomPropagationDelayModel const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::RandomPropagationDelayModel const &', 'arg0')])
+ ## propagation-delay-model.h (module 'propagation'): ns3::RandomPropagationDelayModel::RandomPropagationDelayModel() [constructor]
+ cls.add_constructor([])
+ ## propagation-delay-model.h (module 'propagation'): ns3::Time ns3::RandomPropagationDelayModel::GetDelay(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+ cls.add_method('GetDelay',
+ 'ns3::Time',
+ [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
+ is_const=True, is_virtual=True)
+ ## propagation-delay-model.h (module 'propagation'): static ns3::TypeId ns3::RandomPropagationDelayModel::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ return
+
+def register_Ns3RandomPropagationLossModel_methods(root_module, cls):
+ ## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::RandomPropagationLossModel::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## propagation-loss-model.h (module 'propagation'): ns3::RandomPropagationLossModel::RandomPropagationLossModel() [constructor]
+ cls.add_constructor([])
+ ## propagation-loss-model.h (module 'propagation'): double ns3::RandomPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+ cls.add_method('DoCalcRxPower',
+ 'double',
+ [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
+ is_const=True, visibility='private', is_virtual=True)
+ return
+
+def register_Ns3RangePropagationLossModel_methods(root_module, cls):
+ ## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::RangePropagationLossModel::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## propagation-loss-model.h (module 'propagation'): ns3::RangePropagationLossModel::RangePropagationLossModel() [constructor]
+ cls.add_constructor([])
+ ## propagation-loss-model.h (module 'propagation'): double ns3::RangePropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+ cls.add_method('DoCalcRxPower',
+ 'double',
+ [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
+ is_const=True, visibility='private', is_virtual=True)
+ return
+
+def register_Ns3Scalar_methods(root_module, cls):
+ ## nstime.h (module 'core'): ns3::Scalar::Scalar(ns3::Scalar const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::Scalar const &', 'arg0')])
+ ## nstime.h (module 'core'): ns3::Scalar::Scalar() [constructor]
+ cls.add_constructor([])
+ ## nstime.h (module 'core'): ns3::Scalar::Scalar(double v) [constructor]
+ cls.add_constructor([param('double', 'v')])
+ ## nstime.h (module 'core'): ns3::Scalar::Scalar(uint32_t v) [constructor]
+ cls.add_constructor([param('uint32_t', 'v')])
+ ## nstime.h (module 'core'): ns3::Scalar::Scalar(int32_t v) [constructor]
+ cls.add_constructor([param('int32_t', 'v')])
+ ## nstime.h (module 'core'): ns3::Scalar::Scalar(uint64_t v) [constructor]
+ cls.add_constructor([param('uint64_t', 'v')])
+ ## nstime.h (module 'core'): ns3::Scalar::Scalar(int64_t v) [constructor]
+ cls.add_constructor([param('int64_t', 'v')])
+ ## nstime.h (module 'core'): ns3::Scalar::Scalar(ns3::Time t) [constructor]
+ cls.add_constructor([param('ns3::Time', 't')])
+ ## nstime.h (module 'core'): double ns3::Scalar::GetDouble() const [member function]
+ cls.add_method('GetDouble',
+ 'double',
+ [],
+ is_const=True)
+ return
+
+def register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, cls):
+ ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >::SimpleRefCount() [constructor]
+ cls.add_constructor([])
+ ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >::SimpleRefCount(ns3::SimpleRefCount<ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> > const & o) [copy constructor]
+ cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter< ns3::AttributeAccessor > > const &', 'o')])
+ ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount<ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >::Cleanup() [member function]
+ cls.add_method('Cleanup',
+ 'void',
+ [],
+ is_static=True)
+ return
+
+def register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeChecker__gt___methods(root_module, cls):
+ ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> >::SimpleRefCount() [constructor]
+ cls.add_constructor([])
+ ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> >::SimpleRefCount(ns3::SimpleRefCount<ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> > const & o) [copy constructor]
+ cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter< ns3::AttributeChecker > > const &', 'o')])
+ ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount<ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> >::Cleanup() [member function]
+ cls.add_method('Cleanup',
+ 'void',
+ [],
+ is_static=True)
+ return
+
+def register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeValue__gt___methods(root_module, cls):
+ ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> >::SimpleRefCount() [constructor]
+ cls.add_constructor([])
+ ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> >::SimpleRefCount(ns3::SimpleRefCount<ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> > const & o) [copy constructor]
+ cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter< ns3::AttributeValue > > const &', 'o')])
+ ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount<ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> >::Cleanup() [member function]
+ cls.add_method('Cleanup',
+ 'void',
+ [],
+ is_static=True)
+ return
+
+def register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__lt__ns3CallbackImplBase__gt___methods(root_module, cls):
+ ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> >::SimpleRefCount() [constructor]
+ cls.add_constructor([])
+ ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> >::SimpleRefCount(ns3::SimpleRefCount<ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> > const & o) [copy constructor]
+ cls.add_constructor([param('ns3::SimpleRefCount< ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter< ns3::CallbackImplBase > > const &', 'o')])
+ ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount<ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> >::Cleanup() [member function]
+ cls.add_method('Cleanup',
+ 'void',
+ [],
+ is_static=True)
+ return
+
+def register_Ns3ThreeLogDistancePropagationLossModel_methods(root_module, cls):
+ ## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::ThreeLogDistancePropagationLossModel::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## propagation-loss-model.h (module 'propagation'): ns3::ThreeLogDistancePropagationLossModel::ThreeLogDistancePropagationLossModel() [constructor]
+ cls.add_constructor([])
+ ## propagation-loss-model.h (module 'propagation'): double ns3::ThreeLogDistancePropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+ cls.add_method('DoCalcRxPower',
+ 'double',
+ [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
+ is_const=True, visibility='private', is_virtual=True)
+ return
+
+def register_Ns3TwoRayGroundPropagationLossModel_methods(root_module, cls):
+ ## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::TwoRayGroundPropagationLossModel::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## propagation-loss-model.h (module 'propagation'): ns3::TwoRayGroundPropagationLossModel::TwoRayGroundPropagationLossModel() [constructor]
+ cls.add_constructor([])
+ ## propagation-loss-model.h (module 'propagation'): void ns3::TwoRayGroundPropagationLossModel::SetLambda(double frequency, double speed) [member function]
+ cls.add_method('SetLambda',
+ 'void',
+ [param('double', 'frequency'), param('double', 'speed')])
+ ## propagation-loss-model.h (module 'propagation'): void ns3::TwoRayGroundPropagationLossModel::SetLambda(double lambda) [member function]
+ cls.add_method('SetLambda',
+ 'void',
+ [param('double', 'lambda')])
+ ## propagation-loss-model.h (module 'propagation'): void ns3::TwoRayGroundPropagationLossModel::SetSystemLoss(double systemLoss) [member function]
+ cls.add_method('SetSystemLoss',
+ 'void',
+ [param('double', 'systemLoss')])
+ ## propagation-loss-model.h (module 'propagation'): void ns3::TwoRayGroundPropagationLossModel::SetMinDistance(double minDistance) [member function]
+ cls.add_method('SetMinDistance',
+ 'void',
+ [param('double', 'minDistance')])
+ ## propagation-loss-model.h (module 'propagation'): double ns3::TwoRayGroundPropagationLossModel::GetMinDistance() const [member function]
+ cls.add_method('GetMinDistance',
+ 'double',
+ [],
+ is_const=True)
+ ## propagation-loss-model.h (module 'propagation'): double ns3::TwoRayGroundPropagationLossModel::GetLambda() const [member function]
+ cls.add_method('GetLambda',
+ 'double',
+ [],
+ is_const=True)
+ ## propagation-loss-model.h (module 'propagation'): double ns3::TwoRayGroundPropagationLossModel::GetSystemLoss() const [member function]
+ cls.add_method('GetSystemLoss',
+ 'double',
+ [],
+ is_const=True)
+ ## propagation-loss-model.h (module 'propagation'): void ns3::TwoRayGroundPropagationLossModel::SetHeightAboveZ(double heightAboveZ) [member function]
+ cls.add_method('SetHeightAboveZ',
+ 'void',
+ [param('double', 'heightAboveZ')])
+ ## propagation-loss-model.h (module 'propagation'): double ns3::TwoRayGroundPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+ cls.add_method('DoCalcRxPower',
+ 'double',
+ [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
+ is_const=True, visibility='private', is_virtual=True)
+ return
+
+def register_Ns3AttributeAccessor_methods(root_module, cls):
+ ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::AttributeAccessor const &', 'arg0')])
+ ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor() [constructor]
+ cls.add_constructor([])
+ ## attribute.h (module 'core'): bool ns3::AttributeAccessor::Get(ns3::ObjectBase const * object, ns3::AttributeValue & attribute) const [member function]
+ cls.add_method('Get',
+ 'bool',
+ [param('ns3::ObjectBase const *', 'object'), param('ns3::AttributeValue &', 'attribute')],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## attribute.h (module 'core'): bool ns3::AttributeAccessor::HasGetter() const [member function]
+ cls.add_method('HasGetter',
+ 'bool',
+ [],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## attribute.h (module 'core'): bool ns3::AttributeAccessor::HasSetter() const [member function]
+ cls.add_method('HasSetter',
+ 'bool',
+ [],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## attribute.h (module 'core'): bool ns3::AttributeAccessor::Set(ns3::ObjectBase * object, ns3::AttributeValue const & value) const [member function]
+ cls.add_method('Set',
+ 'bool',
+ [param('ns3::ObjectBase *', 'object', transfer_ownership=False), param('ns3::AttributeValue const &', 'value')],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ return
+
+def register_Ns3AttributeChecker_methods(root_module, cls):
+ ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::AttributeChecker const &', 'arg0')])
+ ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker() [constructor]
+ cls.add_constructor([])
+ ## attribute.h (module 'core'): bool ns3::AttributeChecker::Check(ns3::AttributeValue const & value) const [member function]
+ cls.add_method('Check',
+ 'bool',
+ [param('ns3::AttributeValue const &', 'value')],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## attribute.h (module 'core'): bool ns3::AttributeChecker::Copy(ns3::AttributeValue const & source, ns3::AttributeValue & destination) const [member function]
+ cls.add_method('Copy',
+ 'bool',
+ [param('ns3::AttributeValue const &', 'source'), param('ns3::AttributeValue &', 'destination')],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## attribute.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::AttributeChecker::Create() const [member function]
+ cls.add_method('Create',
+ 'ns3::Ptr< ns3::AttributeValue >',
+ [],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## attribute.h (module 'core'): std::string ns3::AttributeChecker::GetUnderlyingTypeInformation() const [member function]
+ cls.add_method('GetUnderlyingTypeInformation',
+ 'std::string',
+ [],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## attribute.h (module 'core'): std::string ns3::AttributeChecker::GetValueTypeName() const [member function]
+ cls.add_method('GetValueTypeName',
+ 'std::string',
+ [],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## attribute.h (module 'core'): bool ns3::AttributeChecker::HasUnderlyingTypeInformation() const [member function]
+ cls.add_method('HasUnderlyingTypeInformation',
+ 'bool',
+ [],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ return
+
+def register_Ns3AttributeValue_methods(root_module, cls):
+ ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::AttributeValue const &', 'arg0')])
+ ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue() [constructor]
+ cls.add_constructor([])
+ ## attribute.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::AttributeValue::Copy() const [member function]
+ cls.add_method('Copy',
+ 'ns3::Ptr< ns3::AttributeValue >',
+ [],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## attribute.h (module 'core'): bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
+ cls.add_method('DeserializeFromString',
+ 'bool',
+ [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
+ is_pure_virtual=True, is_virtual=True)
+ ## attribute.h (module 'core'): std::string ns3::AttributeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
+ cls.add_method('SerializeToString',
+ 'std::string',
+ [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ return
+
+def register_Ns3CallbackChecker_methods(root_module, cls):
+ ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker() [constructor]
+ cls.add_constructor([])
+ ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker(ns3::CallbackChecker const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::CallbackChecker const &', 'arg0')])
+ return
+
+def register_Ns3CallbackImplBase_methods(root_module, cls):
+ ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase() [constructor]
+ cls.add_constructor([])
+ ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase(ns3::CallbackImplBase const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::CallbackImplBase const &', 'arg0')])
+ ## callback.h (module 'core'): bool ns3::CallbackImplBase::IsEqual(ns3::Ptr<ns3::CallbackImplBase const> other) const [member function]
+ cls.add_method('IsEqual',
+ 'bool',
+ [param('ns3::Ptr< ns3::CallbackImplBase const >', 'other')],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ return
+
+def register_Ns3CallbackValue_methods(root_module, cls):
+ ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackValue const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::CallbackValue const &', 'arg0')])
+ ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue() [constructor]
+ cls.add_constructor([])
+ ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackBase const & base) [constructor]
+ cls.add_constructor([param('ns3::CallbackBase const &', 'base')])
+ ## callback.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::CallbackValue::Copy() const [member function]
+ cls.add_method('Copy',
+ 'ns3::Ptr< ns3::AttributeValue >',
+ [],
+ is_const=True, is_virtual=True)
+ ## callback.h (module 'core'): bool ns3::CallbackValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
+ cls.add_method('DeserializeFromString',
+ 'bool',
+ [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
+ is_virtual=True)
+ ## callback.h (module 'core'): std::string ns3::CallbackValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
+ cls.add_method('SerializeToString',
+ 'std::string',
+ [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
+ is_const=True, is_virtual=True)
+ ## callback.h (module 'core'): void ns3::CallbackValue::Set(ns3::CallbackBase base) [member function]
+ cls.add_method('Set',
+ 'void',
+ [param('ns3::CallbackBase', 'base')])
+ return
+
+def register_Ns3ConstantSpeedPropagationDelayModel_methods(root_module, cls):
+ ## propagation-delay-model.h (module 'propagation'): ns3::ConstantSpeedPropagationDelayModel::ConstantSpeedPropagationDelayModel(ns3::ConstantSpeedPropagationDelayModel const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::ConstantSpeedPropagationDelayModel const &', 'arg0')])
+ ## propagation-delay-model.h (module 'propagation'): ns3::ConstantSpeedPropagationDelayModel::ConstantSpeedPropagationDelayModel() [constructor]
+ cls.add_constructor([])
+ ## propagation-delay-model.h (module 'propagation'): ns3::Time ns3::ConstantSpeedPropagationDelayModel::GetDelay(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+ cls.add_method('GetDelay',
+ 'ns3::Time',
+ [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
+ is_const=True, is_virtual=True)
+ ## propagation-delay-model.h (module 'propagation'): double ns3::ConstantSpeedPropagationDelayModel::GetSpeed() const [member function]
+ cls.add_method('GetSpeed',
+ 'double',
+ [],
+ is_const=True)
+ ## propagation-delay-model.h (module 'propagation'): static ns3::TypeId ns3::ConstantSpeedPropagationDelayModel::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## propagation-delay-model.h (module 'propagation'): void ns3::ConstantSpeedPropagationDelayModel::SetSpeed(double speed) [member function]
+ cls.add_method('SetSpeed',
+ 'void',
+ [param('double', 'speed')])
+ return
+
+def register_Ns3Cost231PropagationLossModel_methods(root_module, cls):
+ ## cost231-propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::Cost231PropagationLossModel::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## cost231-propagation-loss-model.h (module 'propagation'): ns3::Cost231PropagationLossModel::Cost231PropagationLossModel() [constructor]
+ cls.add_constructor([])
+ ## cost231-propagation-loss-model.h (module 'propagation'): double ns3::Cost231PropagationLossModel::GetLoss(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+ cls.add_method('GetLoss',
+ 'double',
+ [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
+ is_const=True)
+ ## cost231-propagation-loss-model.h (module 'propagation'): void ns3::Cost231PropagationLossModel::SetBSAntennaHeight(double height) [member function]
+ cls.add_method('SetBSAntennaHeight',
+ 'void',
+ [param('double', 'height')])
+ ## cost231-propagation-loss-model.h (module 'propagation'): void ns3::Cost231PropagationLossModel::SetSSAntennaHeight(double height) [member function]
+ cls.add_method('SetSSAntennaHeight',
+ 'void',
+ [param('double', 'height')])
+ ## cost231-propagation-loss-model.h (module 'propagation'): void ns3::Cost231PropagationLossModel::SetEnvironment(ns3::Cost231PropagationLossModel::Environment env) [member function]
+ cls.add_method('SetEnvironment',
+ 'void',
+ [param('ns3::Cost231PropagationLossModel::Environment', 'env')])
+ ## cost231-propagation-loss-model.h (module 'propagation'): void ns3::Cost231PropagationLossModel::SetLambda(double lambda) [member function]
+ cls.add_method('SetLambda',
+ 'void',
+ [param('double', 'lambda')])
+ ## cost231-propagation-loss-model.h (module 'propagation'): void ns3::Cost231PropagationLossModel::SetMinDistance(double minDistance) [member function]
+ cls.add_method('SetMinDistance',
+ 'void',
+ [param('double', 'minDistance')])
+ ## cost231-propagation-loss-model.h (module 'propagation'): double ns3::Cost231PropagationLossModel::GetBSAntennaHeight() const [member function]
+ cls.add_method('GetBSAntennaHeight',
+ 'double',
+ [],
+ is_const=True)
+ ## cost231-propagation-loss-model.h (module 'propagation'): double ns3::Cost231PropagationLossModel::GetSSAntennaHeight() const [member function]
+ cls.add_method('GetSSAntennaHeight',
+ 'double',
+ [],
+ is_const=True)
+ ## cost231-propagation-loss-model.h (module 'propagation'): ns3::Cost231PropagationLossModel::Environment ns3::Cost231PropagationLossModel::GetEnvironment() const [member function]
+ cls.add_method('GetEnvironment',
+ 'ns3::Cost231PropagationLossModel::Environment',
+ [],
+ is_const=True)
+ ## cost231-propagation-loss-model.h (module 'propagation'): double ns3::Cost231PropagationLossModel::GetMinDistance() const [member function]
+ cls.add_method('GetMinDistance',
+ 'double',
+ [],
+ is_const=True)
+ ## cost231-propagation-loss-model.h (module 'propagation'): double ns3::Cost231PropagationLossModel::GetLambda() const [member function]
+ cls.add_method('GetLambda',
+ 'double',
+ [],
+ is_const=True)
+ ## cost231-propagation-loss-model.h (module 'propagation'): void ns3::Cost231PropagationLossModel::SetLambda(double frequency, double speed) [member function]
+ cls.add_method('SetLambda',
+ 'void',
+ [param('double', 'frequency'), param('double', 'speed')])
+ ## cost231-propagation-loss-model.h (module 'propagation'): double ns3::Cost231PropagationLossModel::GetShadowing() [member function]
+ cls.add_method('GetShadowing',
+ 'double',
+ [])
+ ## cost231-propagation-loss-model.h (module 'propagation'): void ns3::Cost231PropagationLossModel::SetShadowing(double shadowing) [member function]
+ cls.add_method('SetShadowing',
+ 'void',
+ [param('double', 'shadowing')])
+ ## cost231-propagation-loss-model.h (module 'propagation'): double ns3::Cost231PropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+ cls.add_method('DoCalcRxPower',
+ 'double',
+ [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
+ is_const=True, visibility='private', is_virtual=True)
+ return
+
+def register_Ns3EmptyAttributeValue_methods(root_module, cls):
+ ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::EmptyAttributeValue const &', 'arg0')])
+ ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue() [constructor]
+ cls.add_constructor([])
+ ## attribute.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::EmptyAttributeValue::Copy() const [member function]
+ cls.add_method('Copy',
+ 'ns3::Ptr< ns3::AttributeValue >',
+ [],
+ is_const=True, visibility='private', is_virtual=True)
+ ## attribute.h (module 'core'): bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
+ cls.add_method('DeserializeFromString',
+ 'bool',
+ [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
+ visibility='private', is_virtual=True)
+ ## attribute.h (module 'core'): std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
+ cls.add_method('SerializeToString',
+ 'std::string',
+ [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
+ is_const=True, visibility='private', is_virtual=True)
+ return
+
+def register_Ns3FixedRssLossModel_methods(root_module, cls):
+ ## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::FixedRssLossModel::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## propagation-loss-model.h (module 'propagation'): ns3::FixedRssLossModel::FixedRssLossModel() [constructor]
+ cls.add_constructor([])
+ ## propagation-loss-model.h (module 'propagation'): void ns3::FixedRssLossModel::SetRss(double rss) [member function]
+ cls.add_method('SetRss',
+ 'void',
+ [param('double', 'rss')])
+ ## propagation-loss-model.h (module 'propagation'): double ns3::FixedRssLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+ cls.add_method('DoCalcRxPower',
+ 'double',
+ [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
+ is_const=True, visibility='private', is_virtual=True)
+ return
+
+def register_Ns3FriisPropagationLossModel_methods(root_module, cls):
+ ## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::FriisPropagationLossModel::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## propagation-loss-model.h (module 'propagation'): ns3::FriisPropagationLossModel::FriisPropagationLossModel() [constructor]
+ cls.add_constructor([])
+ ## propagation-loss-model.h (module 'propagation'): void ns3::FriisPropagationLossModel::SetLambda(double frequency, double speed) [member function]
+ cls.add_method('SetLambda',
+ 'void',
+ [param('double', 'frequency'), param('double', 'speed')])
+ ## propagation-loss-model.h (module 'propagation'): void ns3::FriisPropagationLossModel::SetLambda(double lambda) [member function]
+ cls.add_method('SetLambda',
+ 'void',
+ [param('double', 'lambda')])
+ ## propagation-loss-model.h (module 'propagation'): void ns3::FriisPropagationLossModel::SetSystemLoss(double systemLoss) [member function]
+ cls.add_method('SetSystemLoss',
+ 'void',
+ [param('double', 'systemLoss')])
+ ## propagation-loss-model.h (module 'propagation'): void ns3::FriisPropagationLossModel::SetMinDistance(double minDistance) [member function]
+ cls.add_method('SetMinDistance',
+ 'void',
+ [param('double', 'minDistance')])
+ ## propagation-loss-model.h (module 'propagation'): double ns3::FriisPropagationLossModel::GetMinDistance() const [member function]
+ cls.add_method('GetMinDistance',
+ 'double',
+ [],
+ is_const=True)
+ ## propagation-loss-model.h (module 'propagation'): double ns3::FriisPropagationLossModel::GetLambda() const [member function]
+ cls.add_method('GetLambda',
+ 'double',
+ [],
+ is_const=True)
+ ## propagation-loss-model.h (module 'propagation'): double ns3::FriisPropagationLossModel::GetSystemLoss() const [member function]
+ cls.add_method('GetSystemLoss',
+ 'double',
+ [],
+ is_const=True)
+ ## propagation-loss-model.h (module 'propagation'): double ns3::FriisPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+ cls.add_method('DoCalcRxPower',
+ 'double',
+ [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
+ is_const=True, visibility='private', is_virtual=True)
+ return
+
+def register_Ns3JakesPropagationLossModel_methods(root_module, cls):
+ ## jakes-propagation-loss-model.h (module 'propagation'): ns3::JakesPropagationLossModel::JakesPropagationLossModel() [constructor]
+ cls.add_constructor([])
+ ## jakes-propagation-loss-model.h (module 'propagation'): uint8_t ns3::JakesPropagationLossModel::GetNOscillators() const [member function]
+ cls.add_method('GetNOscillators',
+ 'uint8_t',
+ [],
+ is_const=True)
+ ## jakes-propagation-loss-model.h (module 'propagation'): uint8_t ns3::JakesPropagationLossModel::GetNRays() const [member function]
+ cls.add_method('GetNRays',
+ 'uint8_t',
+ [],
+ is_const=True)
+ ## jakes-propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::JakesPropagationLossModel::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## jakes-propagation-loss-model.h (module 'propagation'): void ns3::JakesPropagationLossModel::SetNOscillators(uint8_t nOscillators) [member function]
+ cls.add_method('SetNOscillators',
+ 'void',
+ [param('uint8_t', 'nOscillators')])
+ ## jakes-propagation-loss-model.h (module 'propagation'): void ns3::JakesPropagationLossModel::SetNRays(uint8_t nRays) [member function]
+ cls.add_method('SetNRays',
+ 'void',
+ [param('uint8_t', 'nRays')])
+ ## jakes-propagation-loss-model.h (module 'propagation'): double ns3::JakesPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+ cls.add_method('DoCalcRxPower',
+ 'double',
+ [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
+ is_const=True, visibility='private', is_virtual=True)
+ return
+
+def register_Ns3LogDistancePropagationLossModel_methods(root_module, cls):
+ ## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::LogDistancePropagationLossModel::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## propagation-loss-model.h (module 'propagation'): ns3::LogDistancePropagationLossModel::LogDistancePropagationLossModel() [constructor]
+ cls.add_constructor([])
+ ## propagation-loss-model.h (module 'propagation'): void ns3::LogDistancePropagationLossModel::SetPathLossExponent(double n) [member function]
+ cls.add_method('SetPathLossExponent',
+ 'void',
+ [param('double', 'n')])
+ ## propagation-loss-model.h (module 'propagation'): double ns3::LogDistancePropagationLossModel::GetPathLossExponent() const [member function]
+ cls.add_method('GetPathLossExponent',
+ 'double',
+ [],
+ is_const=True)
+ ## propagation-loss-model.h (module 'propagation'): void ns3::LogDistancePropagationLossModel::SetReference(double referenceDistance, double referenceLoss) [member function]
+ cls.add_method('SetReference',
+ 'void',
+ [param('double', 'referenceDistance'), param('double', 'referenceLoss')])
+ ## propagation-loss-model.h (module 'propagation'): double ns3::LogDistancePropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+ cls.add_method('DoCalcRxPower',
+ 'double',
+ [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
+ is_const=True, visibility='private', is_virtual=True)
+ return
+
+def register_Ns3MatrixPropagationLossModel_methods(root_module, cls):
+ ## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::MatrixPropagationLossModel::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## propagation-loss-model.h (module 'propagation'): ns3::MatrixPropagationLossModel::MatrixPropagationLossModel() [constructor]
+ cls.add_constructor([])
+ ## propagation-loss-model.h (module 'propagation'): void ns3::MatrixPropagationLossModel::SetLoss(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b, double loss, bool symmetric=true) [member function]
+ cls.add_method('SetLoss',
+ 'void',
+ [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b'), param('double', 'loss'), param('bool', 'symmetric', default_value='true')])
+ ## propagation-loss-model.h (module 'propagation'): void ns3::MatrixPropagationLossModel::SetDefaultLoss(double arg0) [member function]
+ cls.add_method('SetDefaultLoss',
+ 'void',
+ [param('double', 'arg0')])
+ ## propagation-loss-model.h (module 'propagation'): double ns3::MatrixPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+ cls.add_method('DoCalcRxPower',
+ 'double',
+ [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
+ is_const=True, visibility='private', is_virtual=True)
+ return
+
+def register_Ns3NakagamiPropagationLossModel_methods(root_module, cls):
+ ## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::NakagamiPropagationLossModel::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## propagation-loss-model.h (module 'propagation'): ns3::NakagamiPropagationLossModel::NakagamiPropagationLossModel() [constructor]
+ cls.add_constructor([])
+ ## propagation-loss-model.h (module 'propagation'): double ns3::NakagamiPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
+ cls.add_method('DoCalcRxPower',
+ 'double',
+ [param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
+ is_const=True, visibility='private', is_virtual=True)
+ return
+
+def register_Ns3RandomVariableChecker_methods(root_module, cls):
+ ## random-variable.h (module 'core'): ns3::RandomVariableChecker::RandomVariableChecker() [constructor]
+ cls.add_constructor([])
+ ## random-variable.h (module 'core'): ns3::RandomVariableChecker::RandomVariableChecker(ns3::RandomVariableChecker const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::RandomVariableChecker const &', 'arg0')])
+ return
+
+def register_Ns3RandomVariableValue_methods(root_module, cls):
+ ## random-variable.h (module 'core'): ns3::RandomVariableValue::RandomVariableValue() [constructor]
+ cls.add_constructor([])
+ ## random-variable.h (module 'core'): ns3::RandomVariableValue::RandomVariableValue(ns3::RandomVariableValue const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::RandomVariableValue const &', 'arg0')])
+ ## random-variable.h (module 'core'): ns3::RandomVariableValue::RandomVariableValue(ns3::RandomVariable const & value) [constructor]
+ cls.add_constructor([param('ns3::RandomVariable const &', 'value')])
+ ## random-variable.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::RandomVariableValue::Copy() const [member function]
+ cls.add_method('Copy',
+ 'ns3::Ptr< ns3::AttributeValue >',
+ [],
+ is_const=True, is_virtual=True)
+ ## random-variable.h (module 'core'): bool ns3::RandomVariableValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
+ cls.add_method('DeserializeFromString',
+ 'bool',
+ [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
+ is_virtual=True)
+ ## random-variable.h (module 'core'): ns3::RandomVariable ns3::RandomVariableValue::Get() const [member function]
+ cls.add_method('Get',
+ 'ns3::RandomVariable',
+ [],
+ is_const=True)
+ ## random-variable.h (module 'core'): std::string ns3::RandomVariableValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
+ cls.add_method('SerializeToString',
+ 'std::string',
+ [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
+ is_const=True, is_virtual=True)
+ ## random-variable.h (module 'core'): void ns3::RandomVariableValue::Set(ns3::RandomVariable const & value) [member function]
+ cls.add_method('Set',
+ 'void',
+ [param('ns3::RandomVariable const &', 'value')])
+ return
+
+def register_Ns3TimeChecker_methods(root_module, cls):
+ ## nstime.h (module 'core'): ns3::TimeChecker::TimeChecker() [constructor]
+ cls.add_constructor([])
+ ## nstime.h (module 'core'): ns3::TimeChecker::TimeChecker(ns3::TimeChecker const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::TimeChecker const &', 'arg0')])
+ return
+
+def register_Ns3TimeValue_methods(root_module, cls):
+ ## nstime.h (module 'core'): ns3::TimeValue::TimeValue() [constructor]
+ cls.add_constructor([])
+ ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::TimeValue const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::TimeValue const &', 'arg0')])
+ ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::Time const & value) [constructor]
+ cls.add_constructor([param('ns3::Time const &', 'value')])
+ ## nstime.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::TimeValue::Copy() const [member function]
+ cls.add_method('Copy',
+ 'ns3::Ptr< ns3::AttributeValue >',
+ [],
+ is_const=True, is_virtual=True)
+ ## nstime.h (module 'core'): bool ns3::TimeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
+ cls.add_method('DeserializeFromString',
+ 'bool',
+ [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
+ is_virtual=True)
+ ## nstime.h (module 'core'): ns3::Time ns3::TimeValue::Get() const [member function]
+ cls.add_method('Get',
+ 'ns3::Time',
+ [],
+ is_const=True)
+ ## nstime.h (module 'core'): std::string ns3::TimeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
+ cls.add_method('SerializeToString',
+ 'std::string',
+ [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
+ is_const=True, is_virtual=True)
+ ## nstime.h (module 'core'): void ns3::TimeValue::Set(ns3::Time const & value) [member function]
+ cls.add_method('Set',
+ 'void',
+ [param('ns3::Time const &', 'value')])
+ return
+
+def register_Ns3TypeIdChecker_methods(root_module, cls):
+ ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker() [constructor]
+ cls.add_constructor([])
+ ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker(ns3::TypeIdChecker const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::TypeIdChecker const &', 'arg0')])
+ return
+
+def register_Ns3TypeIdValue_methods(root_module, cls):
+ ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue() [constructor]
+ cls.add_constructor([])
+ ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeIdValue const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::TypeIdValue const &', 'arg0')])
+ ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeId const & value) [constructor]
+ cls.add_constructor([param('ns3::TypeId const &', 'value')])
+ ## type-id.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::TypeIdValue::Copy() const [member function]
+ cls.add_method('Copy',
+ 'ns3::Ptr< ns3::AttributeValue >',
+ [],
+ is_const=True, is_virtual=True)
+ ## type-id.h (module 'core'): bool ns3::TypeIdValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
+ cls.add_method('DeserializeFromString',
+ 'bool',
+ [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
+ is_virtual=True)
+ ## type-id.h (module 'core'): ns3::TypeId ns3::TypeIdValue::Get() const [member function]
+ cls.add_method('Get',
+ 'ns3::TypeId',
+ [],
+ is_const=True)
+ ## type-id.h (module 'core'): std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
+ cls.add_method('SerializeToString',
+ 'std::string',
+ [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
+ is_const=True, is_virtual=True)
+ ## type-id.h (module 'core'): void ns3::TypeIdValue::Set(ns3::TypeId const & value) [member function]
+ cls.add_method('Set',
+ 'void',
+ [param('ns3::TypeId const &', 'value')])
+ return
+
+def register_functions(root_module):
+ module = root_module
+ register_functions_ns3_FatalImpl(module.get_submodule('FatalImpl'), root_module)
+ return
+
+def register_functions_ns3_FatalImpl(module, root_module):
+ return
+
+def main():
+ out = FileCodeSink(sys.stdout)
+ root_module = module_init()
+ register_types(root_module)
+ register_methods(root_module)
+ register_functions(root_module)
+ root_module.generate(out)
+
+if __name__ == '__main__':
+ main()
+