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()

    ## propagation-environment.h (module 'propagation'): ns3::CitySize [enumeration]

    module.add_enum('CitySize', ['SmallCity', 'MediumCity', 'LargeCity'])

    ## propagation-environment.h (module 'propagation'): ns3::EnvironmentType [enumeration]

    module.add_enum('EnvironmentType', ['UrbanEnvironment', 'SubUrbanEnvironment', 'OpenAreasEnvironment'])

    ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList [class]

    module.add_class('AttributeConstructionList', import_from_module='ns.core')

    ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item [struct]

    module.add_class('Item', import_from_module='ns.core', outer_class=root_module['ns3::AttributeConstructionList'])

    ## callback.h (module 'core'): ns3::CallbackBase [class]

    module.add_class('CallbackBase', import_from_module='ns.core')

    ## hash.h (module 'core'): ns3::Hasher [class]

    module.add_class('Hasher', 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')

    ## propagation-cache.h (module 'propagation'): ns3::PropagationCache<ns3::JakesProcess> [class]

    module.add_class('PropagationCache', template_parameters=['ns3::JakesProcess'])

    ## 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'))

    ## 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::AttributeInformation [struct]

    module.add_class('AttributeInformation', import_from_module='ns.core', outer_class=root_module['ns3::TypeId'])

    ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation [struct]

    module.add_class('TraceSourceInformation', import_from_module='ns.core', outer_class=root_module['ns3::TypeId'])

    ## vector.h (module 'core'): ns3::Vector2D [class]

    module.add_class('Vector2D', import_from_module='ns.core')

    ## vector.h (module 'core'): ns3::Vector3D [class]

    module.add_class('Vector3D', import_from_module='ns.core')

    ## empty.h (module 'core'): ns3::empty [class]

    module.add_class('empty', import_from_module='ns.core')

    ## int64x64-double.h (module 'core'): ns3::int64x64_t [class]

    module.add_class('int64x64_t', import_from_module='ns.core')

    ## 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'])

    ## 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'])

    ## random-variable-stream.h (module 'core'): ns3::RandomVariableStream [class]

    module.add_class('RandomVariableStream', import_from_module='ns.core', parent=root_module['ns3::Object'])

    ## propagation-loss-model.h (module 'propagation'): ns3::RangePropagationLossModel [class]

    module.add_class('RangePropagationLossModel', parent=root_module['ns3::PropagationLossModel'])

    ## random-variable-stream.h (module 'core'): ns3::SequentialRandomVariable [class]

    module.add_class('SequentialRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream'])

    ## 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'))

    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::Hash::Implementation, ns3::empty, ns3::DefaultDeleter<ns3::Hash::Implementation> > [class]

    module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::Hash::Implementation', 'ns3::empty', 'ns3::DefaultDeleter<ns3::Hash::Implementation>'], 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::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> > [class]

    module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::TraceSourceAccessor', 'ns3::empty', 'ns3::DefaultDeleter<ns3::TraceSourceAccessor>'], 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'])

    ## 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', ['Y', 'D', 'H', 'MIN', 'S', 'MS', 'US', 'NS', 'PS', 'FS', 'LAST'], outer_class=root_module['ns3::Time'], import_from_module='ns.core')

    ## nstime.h (module 'core'): ns3::Time [class]

    root_module['ns3::Time'].implicitly_converts_to(root_module['ns3::int64x64_t'])

    ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor [class]

    module.add_class('TraceSourceAccessor', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> >'])

    ## random-variable-stream.h (module 'core'): ns3::TriangularRandomVariable [class]

    module.add_class('TriangularRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream'])

    ## propagation-loss-model.h (module 'propagation'): ns3::TwoRayGroundPropagationLossModel [class]

    module.add_class('TwoRayGroundPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])

    ## random-variable-stream.h (module 'core'): ns3::UniformRandomVariable [class]

    module.add_class('UniformRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream'])

    ## random-variable-stream.h (module 'core'): ns3::WeibullRandomVariable [class]

    module.add_class('WeibullRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream'])

    ## random-variable-stream.h (module 'core'): ns3::ZetaRandomVariable [class]

    module.add_class('ZetaRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream'])

    ## random-variable-stream.h (module 'core'): ns3::ZipfRandomVariable [class]

    module.add_class('ZipfRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream'])

    ## 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'])

    ## random-variable-stream.h (module 'core'): ns3::ConstantRandomVariable [class]

    module.add_class('ConstantRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream'])

    ## 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'])

    ## random-variable-stream.h (module 'core'): ns3::DeterministicRandomVariable [class]

    module.add_class('DeterministicRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream'])

    ## random-variable-stream.h (module 'core'): ns3::EmpiricalRandomVariable [class]

    module.add_class('EmpiricalRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream'])

    ## attribute.h (module 'core'): ns3::EmptyAttributeValue [class]

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

    ## random-variable-stream.h (module 'core'): ns3::ErlangRandomVariable [class]

    module.add_class('ErlangRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream'])

    ## random-variable-stream.h (module 'core'): ns3::ExponentialRandomVariable [class]

    module.add_class('ExponentialRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream'])

    ## 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'])

    ## random-variable-stream.h (module 'core'): ns3::GammaRandomVariable [class]

    module.add_class('GammaRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream'])

    ## itu-r-1411-los-propagation-loss-model.h (module 'propagation'): ns3::ItuR1411LosPropagationLossModel [class]

    module.add_class('ItuR1411LosPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])

    ## itu-r-1411-nlos-over-rooftop-propagation-loss-model.h (module 'propagation'): ns3::ItuR1411NlosOverRooftopPropagationLossModel [class]

    module.add_class('ItuR1411NlosOverRooftopPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])

    ## jakes-process.h (module 'propagation'): ns3::JakesProcess [class]

    module.add_class('JakesProcess', parent=root_module['ns3::Object'])

    ## jakes-propagation-loss-model.h (module 'propagation'): ns3::JakesPropagationLossModel [class]

    module.add_class('JakesPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])

    ## kun-2600-mhz-propagation-loss-model.h (module 'propagation'): ns3::Kun2600MhzPropagationLossModel [class]

    module.add_class('Kun2600MhzPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])

    ## propagation-loss-model.h (module 'propagation'): ns3::LogDistancePropagationLossModel [class]

    module.add_class('LogDistancePropagationLossModel', parent=root_module['ns3::PropagationLossModel'])

    ## random-variable-stream.h (module 'core'): ns3::LogNormalRandomVariable [class]

    module.add_class('LogNormalRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream'])

    ## propagation-loss-model.h (module 'propagation'): ns3::MatrixPropagationLossModel [class]

    module.add_class('MatrixPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])

    ## mobility-model.h (module 'mobility'): ns3::MobilityModel [class]

    module.add_class('MobilityModel', import_from_module='ns.mobility', parent=root_module['ns3::Object'])

    ## propagation-loss-model.h (module 'propagation'): ns3::NakagamiPropagationLossModel [class]

    module.add_class('NakagamiPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])

    ## random-variable-stream.h (module 'core'): ns3::NormalRandomVariable [class]

    module.add_class('NormalRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream'])

    ## okumura-hata-propagation-loss-model.h (module 'propagation'): ns3::OkumuraHataPropagationLossModel [class]

    module.add_class('OkumuraHataPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])

    ## random-variable-stream.h (module 'core'): ns3::ParetoRandomVariable [class]

    module.add_class('ParetoRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream'])

    ## 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'])

    ## vector.h (module 'core'): ns3::Vector2DChecker [class]

    module.add_class('Vector2DChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])

    ## vector.h (module 'core'): ns3::Vector2DValue [class]

    module.add_class('Vector2DValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])

    ## vector.h (module 'core'): ns3::Vector3DChecker [class]

    module.add_class('Vector3DChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])

    ## vector.h (module 'core'): ns3::Vector3DValue [class]

    module.add_class('Vector3DValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])

    typehandlers.add_type_alias('ns3::Vector3D', 'ns3::Vector')

    typehandlers.add_type_alias('ns3::Vector3D*', 'ns3::Vector*')

    typehandlers.add_type_alias('ns3::Vector3D&', 'ns3::Vector&')

    module.add_typedef(root_module['ns3::Vector3D'], 'Vector')

    typehandlers.add_type_alias('ns3::Vector3DValue', 'ns3::VectorValue')

    typehandlers.add_type_alias('ns3::Vector3DValue*', 'ns3::VectorValue*')

    typehandlers.add_type_alias('ns3::Vector3DValue&', 'ns3::VectorValue&')

    module.add_typedef(root_module['ns3::Vector3DValue'], 'VectorValue')

    typehandlers.add_type_alias('ns3::Vector3DChecker', 'ns3::VectorChecker')

    typehandlers.add_type_alias('ns3::Vector3DChecker*', 'ns3::VectorChecker*')

    typehandlers.add_type_alias('ns3::Vector3DChecker&', 'ns3::VectorChecker&')

    module.add_typedef(root_module['ns3::Vector3DChecker'], 'VectorChecker')

    ## Register a nested module for the namespace FatalImpl

    nested_module = module.add_cpp_namespace('FatalImpl')

    register_types_ns3_FatalImpl(nested_module)

    ## Register a nested module for the namespace Hash

    nested_module = module.add_cpp_namespace('Hash')

    register_types_ns3_Hash(nested_module)

def register_types_ns3_FatalImpl(module):

    root_module = module.get_root()

def register_types_ns3_Hash(module):

    root_module = module.get_root()

    ## hash-function.h (module 'core'): ns3::Hash::Implementation [class]

    module.add_class('Implementation', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::Hash::Implementation, ns3::empty, ns3::DefaultDeleter<ns3::Hash::Implementation> >'])

    typehandlers.add_type_alias('uint32_t ( * ) ( char const *, size_t ) *', 'ns3::Hash::Hash32Function_ptr')

    typehandlers.add_type_alias('uint32_t ( * ) ( char const *, size_t ) **', 'ns3::Hash::Hash32Function_ptr*')

    typehandlers.add_type_alias('uint32_t ( * ) ( char const *, size_t ) *&', 'ns3::Hash::Hash32Function_ptr&')

    typehandlers.add_type_alias('uint64_t ( * ) ( char const *, size_t ) *', 'ns3::Hash::Hash64Function_ptr')

    typehandlers.add_type_alias('uint64_t ( * ) ( char const *, size_t ) **', 'ns3::Hash::Hash64Function_ptr*')

    typehandlers.add_type_alias('uint64_t ( * ) ( char const *, size_t ) *&', 'ns3::Hash::Hash64Function_ptr&')

    ## Register a nested module for the namespace Function

    nested_module = module.add_cpp_namespace('Function')

    register_types_ns3_Hash_Function(nested_module)

def register_types_ns3_Hash_Function(module):

    root_module = module.get_root()

    ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a [class]

    module.add_class('Fnv1a', import_from_module='ns.core', parent=root_module['ns3::Hash::Implementation'])

    ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32 [class]

    module.add_class('Hash32', import_from_module='ns.core', parent=root_module['ns3::Hash::Implementation'])

    ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64 [class]

    module.add_class('Hash64', import_from_module='ns.core', parent=root_module['ns3::Hash::Implementation'])

    ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3 [class]

    module.add_class('Murmur3', import_from_module='ns.core', parent=root_module['ns3::Hash::Implementation'])

def register_methods(root_module):

    register_Ns3AttributeConstructionList_methods(root_module, root_module['ns3::AttributeConstructionList'])

    register_Ns3AttributeConstructionListItem_methods(root_module, root_module['ns3::AttributeConstructionList::Item'])

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

    register_Ns3Hasher_methods(root_module, root_module['ns3::Hasher'])

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

    register_Ns3ObjectDeleter_methods(root_module, root_module['ns3::ObjectDeleter'])

    register_Ns3PropagationCache__Ns3JakesProcess_methods(root_module, root_module['ns3::PropagationCache< ns3::JakesProcess >'])

    register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods(root_module, root_module['ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter >'])

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

    register_Ns3TypeIdAttributeInformation_methods(root_module, root_module['ns3::TypeId::AttributeInformation'])

    register_Ns3TypeIdTraceSourceInformation_methods(root_module, root_module['ns3::TypeId::TraceSourceInformation'])

    register_Ns3Vector2D_methods(root_module, root_module['ns3::Vector2D'])

    register_Ns3Vector3D_methods(root_module, root_module['ns3::Vector3D'])

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

    register_Ns3Int64x64_t_methods(root_module, root_module['ns3::int64x64_t'])

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

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

    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_Ns3RandomVariableStream_methods(root_module, root_module['ns3::RandomVariableStream'])

    register_Ns3RangePropagationLossModel_methods(root_module, root_module['ns3::RangePropagationLossModel'])

    register_Ns3SequentialRandomVariable_methods(root_module, root_module['ns3::SequentialRandomVariable'])

    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_Ns3SimpleRefCount__Ns3HashImplementation_Ns3Empty_Ns3DefaultDeleter__lt__ns3HashImplementation__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::Hash::Implementation, ns3::empty, ns3::DefaultDeleter<ns3::Hash::Implementation> >'])

    register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3TraceSourceAccessor__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> >'])

    register_Ns3ThreeLogDistancePropagationLossModel_methods(root_module, root_module['ns3::ThreeLogDistancePropagationLossModel'])

    register_Ns3Time_methods(root_module, root_module['ns3::Time'])

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

    register_Ns3TriangularRandomVariable_methods(root_module, root_module['ns3::TriangularRandomVariable'])

    register_Ns3TwoRayGroundPropagationLossModel_methods(root_module, root_module['ns3::TwoRayGroundPropagationLossModel'])

    register_Ns3UniformRandomVariable_methods(root_module, root_module['ns3::UniformRandomVariable'])

    register_Ns3WeibullRandomVariable_methods(root_module, root_module['ns3::WeibullRandomVariable'])

    register_Ns3ZetaRandomVariable_methods(root_module, root_module['ns3::ZetaRandomVariable'])

    register_Ns3ZipfRandomVariable_methods(root_module, root_module['ns3::ZipfRandomVariable'])

    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_Ns3ConstantRandomVariable_methods(root_module, root_module['ns3::ConstantRandomVariable'])

    register_Ns3ConstantSpeedPropagationDelayModel_methods(root_module, root_module['ns3::ConstantSpeedPropagationDelayModel'])

    register_Ns3Cost231PropagationLossModel_methods(root_module, root_module['ns3::Cost231PropagationLossModel'])

    register_Ns3DeterministicRandomVariable_methods(root_module, root_module['ns3::DeterministicRandomVariable'])

    register_Ns3EmpiricalRandomVariable_methods(root_module, root_module['ns3::EmpiricalRandomVariable'])

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

    register_Ns3ErlangRandomVariable_methods(root_module, root_module['ns3::ErlangRandomVariable'])

    register_Ns3ExponentialRandomVariable_methods(root_module, root_module['ns3::ExponentialRandomVariable'])

    register_Ns3FixedRssLossModel_methods(root_module, root_module['ns3::FixedRssLossModel'])

    register_Ns3FriisPropagationLossModel_methods(root_module, root_module['ns3::FriisPropagationLossModel'])

    register_Ns3GammaRandomVariable_methods(root_module, root_module['ns3::GammaRandomVariable'])

    register_Ns3ItuR1411LosPropagationLossModel_methods(root_module, root_module['ns3::ItuR1411LosPropagationLossModel'])

    register_Ns3ItuR1411NlosOverRooftopPropagationLossModel_methods(root_module, root_module['ns3::ItuR1411NlosOverRooftopPropagationLossModel'])

    register_Ns3JakesProcess_methods(root_module, root_module['ns3::JakesProcess'])

    register_Ns3JakesPropagationLossModel_methods(root_module, root_module['ns3::JakesPropagationLossModel'])

    register_Ns3Kun2600MhzPropagationLossModel_methods(root_module, root_module['ns3::Kun2600MhzPropagationLossModel'])

    register_Ns3LogDistancePropagationLossModel_methods(root_module, root_module['ns3::LogDistancePropagationLossModel'])

    register_Ns3LogNormalRandomVariable_methods(root_module, root_module['ns3::LogNormalRandomVariable'])

    register_Ns3MatrixPropagationLossModel_methods(root_module, root_module['ns3::MatrixPropagationLossModel'])

    register_Ns3MobilityModel_methods(root_module, root_module['ns3::MobilityModel'])

    register_Ns3NakagamiPropagationLossModel_methods(root_module, root_module['ns3::NakagamiPropagationLossModel'])

    register_Ns3NormalRandomVariable_methods(root_module, root_module['ns3::NormalRandomVariable'])

    register_Ns3OkumuraHataPropagationLossModel_methods(root_module, root_module['ns3::OkumuraHataPropagationLossModel'])

    register_Ns3ParetoRandomVariable_methods(root_module, root_module['ns3::ParetoRandomVariable'])

    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'])

    register_Ns3Vector2DChecker_methods(root_module, root_module['ns3::Vector2DChecker'])

    register_Ns3Vector2DValue_methods(root_module, root_module['ns3::Vector2DValue'])

    register_Ns3Vector3DChecker_methods(root_module, root_module['ns3::Vector3DChecker'])

    register_Ns3Vector3DValue_methods(root_module, root_module['ns3::Vector3DValue'])

    register_Ns3HashImplementation_methods(root_module, root_module['ns3::Hash::Implementation'])

    register_Ns3HashFunctionFnv1a_methods(root_module, root_module['ns3::Hash::Function::Fnv1a'])

    register_Ns3HashFunctionHash32_methods(root_module, root_module['ns3::Hash::Function::Hash32'])

    register_Ns3HashFunctionHash64_methods(root_module, root_module['ns3::Hash::Function::Hash64'])

    register_Ns3HashFunctionMurmur3_methods(root_module, root_module['ns3::Hash::Function::Murmur3'])

    return

def register_Ns3AttributeConstructionList_methods(root_module, cls):

    ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList(ns3::AttributeConstructionList const & arg0) [copy constructor]

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

    ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList() [constructor]

    cls.add_constructor([])

    ## attribute-construction-list.h (module 'core'): void ns3::AttributeConstructionList::Add(std::string name, ns3::Ptr<ns3::AttributeChecker const> checker, ns3::Ptr<ns3::AttributeValue> value) [member function]

    cls.add_method('Add', 

                   'void', 

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

    ## attribute-construction-list.h (module 'core'): std::_List_const_iterator<ns3::AttributeConstructionList::Item> ns3::AttributeConstructionList::Begin() const [member function]

    cls.add_method('Begin', 

                   'std::_List_const_iterator< ns3::AttributeConstructionList::Item >', 

                   [], 

                   is_const=True)

    ## attribute-construction-list.h (module 'core'): std::_List_const_iterator<ns3::AttributeConstructionList::Item> ns3::AttributeConstructionList::End() const [member function]

    cls.add_method('End', 

                   'std::_List_const_iterator< ns3::AttributeConstructionList::Item >', 

                   [], 

                   is_const=True)

    ## attribute-construction-list.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::AttributeConstructionList::Find(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

    cls.add_method('Find', 

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

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

                   is_const=True)

    return

def register_Ns3AttributeConstructionListItem_methods(root_module, cls):

    ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item() [constructor]

    cls.add_constructor([])

    ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item(ns3::AttributeConstructionList::Item const & arg0) [copy constructor]

    cls.add_constructor([param('ns3::AttributeConstructionList::Item const &', 'arg0')])

    ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::checker [variable]

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

    ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::name [variable]

    cls.add_instance_attribute('name', 'std::string', is_const=False)

    ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::value [variable]

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

    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_Ns3Hasher_methods(root_module, cls):

    ## hash.h (module 'core'): ns3::Hasher::Hasher(ns3::Hasher const & arg0) [copy constructor]

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

    ## hash.h (module 'core'): ns3::Hasher::Hasher() [constructor]

    cls.add_constructor([])

    ## hash.h (module 'core'): ns3::Hasher::Hasher(ns3::Ptr<ns3::Hash::Implementation> hp) [constructor]

    cls.add_constructor([param('ns3::Ptr< ns3::Hash::Implementation >', 'hp')])

    ## hash.h (module 'core'): uint32_t ns3::Hasher::GetHash32(char const * buffer, size_t const size) [member function]

    cls.add_method('GetHash32', 

                   'uint32_t', 

                   [param('char const *', 'buffer'), param('size_t const', 'size')])

    ## hash.h (module 'core'): uint32_t ns3::Hasher::GetHash32(std::string const s) [member function]

    cls.add_method('GetHash32', 

                   'uint32_t', 

                   [param('std::string const', 's')])

    ## hash.h (module 'core'): uint64_t ns3::Hasher::GetHash64(char const * buffer, size_t const size) [member function]

    cls.add_method('GetHash64', 

                   'uint64_t', 

                   [param('char const *', 'buffer'), param('size_t const', 'size')])

    ## hash.h (module 'core'): uint64_t ns3::Hasher::GetHash64(std::string const s) [member function]

    cls.add_method('GetHash64', 

                   'uint64_t', 

                   [param('std::string const', 's')])

    ## hash.h (module 'core'): ns3::Hasher & ns3::Hasher::clear() [member function]

    cls.add_method('clear', 

                   'ns3::Hasher &', 

                   [])

    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::AttributeConstructionList const & attributes) [member function]

    cls.add_method('ConstructSelf', 

                   'void', 

                   [param('ns3::AttributeConstructionList 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_Ns3PropagationCache__Ns3JakesProcess_methods(root_module, cls):

    ## propagation-cache.h (module 'propagation'): ns3::PropagationCache<ns3::JakesProcess>::PropagationCache(ns3::PropagationCache<ns3::JakesProcess> const & arg0) [copy constructor]

    cls.add_constructor([param('ns3::PropagationCache< ns3::JakesProcess > const &', 'arg0')])

    ## propagation-cache.h (module 'propagation'): ns3::PropagationCache<ns3::JakesProcess>::PropagationCache() [constructor]

    cls.add_constructor([])

    ## propagation-cache.h (module 'propagation'): void ns3::PropagationCache<ns3::JakesProcess>::AddPathData(ns3::Ptr<ns3::JakesProcess> data, ns3::Ptr<ns3::MobilityModel const> a, ns3::Ptr<ns3::MobilityModel const> b, uint32_t modelUid) [member function]

    cls.add_method('AddPathData', 

                   'void', 

                   [param('ns3::Ptr< ns3::JakesProcess >', 'data'), param('ns3::Ptr< ns3::MobilityModel const >', 'a'), param('ns3::Ptr< ns3::MobilityModel const >', 'b'), param('uint32_t', 'modelUid')])

    ## propagation-cache.h (module 'propagation'): ns3::Ptr<ns3::JakesProcess> ns3::PropagationCache<ns3::JakesProcess>::GetPathData(ns3::Ptr<ns3::MobilityModel const> a, ns3::Ptr<ns3::MobilityModel const> b, uint32_t modelUid) [member function]

    cls.add_method('GetPathData',