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.config_store', cpp_namespace='::ns3')

    return root_module

def register_types(module):

    root_module = module.get_root()

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

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

    ## file-config.h (module 'config-store'): ns3::FileConfig [class]

    module.add_class('FileConfig', allow_subclassing=True)

    ## gtk-config-store.h (module 'config-store'): ns3::GtkConfigStore [class]

    module.add_class('GtkConfigStore')

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

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

    ## file-config.h (module 'config-store'): ns3::NoneFileConfig [class]

    module.add_class('NoneFileConfig', parent=root_module['ns3::FileConfig'])

    ## object-base.h (module 'core'): ns3::ObjectBase [class]

    module.add_class('ObjectBase', allow_subclassing=True, import_from_module='ns.core')

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

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

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

    ## config-store.h (module 'config-store'): ns3::ConfigStore [class]

    module.add_class('ConfigStore', parent=root_module['ns3::ObjectBase'])

    ## config-store.h (module 'config-store'): ns3::ConfigStore::Mode [enumeration]

    module.add_enum('Mode', ['LOAD', 'SAVE', 'NONE'], outer_class=root_module['ns3::ConfigStore'])

    ## config-store.h (module 'config-store'): ns3::ConfigStore::FileFormat [enumeration]

    module.add_enum('FileFormat', ['XML', 'RAW_TEXT'], outer_class=root_module['ns3::ConfigStore'])

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

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

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

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

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

    ## 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(u'uint32_t ( * ) ( char const *, size_t ) *', u'ns3::Hash::Hash32Function_ptr')

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

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

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

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

    typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) *&', u'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_Ns3CallbackBase_methods(root_module, root_module['ns3::CallbackBase'])

    register_Ns3FileConfig_methods(root_module, root_module['ns3::FileConfig'])

    register_Ns3GtkConfigStore_methods(root_module, root_module['ns3::GtkConfigStore'])

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

    register_Ns3NoneFileConfig_methods(root_module, root_module['ns3::NoneFileConfig'])

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

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

    register_Ns3ConfigStore_methods(root_module, root_module['ns3::ConfigStore'])

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

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

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

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

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

    return

def register_Ns3FileConfig_methods(root_module, cls):

    ## file-config.h (module 'config-store'): ns3::FileConfig::FileConfig() [constructor]

    cls.add_constructor([])

    ## file-config.h (module 'config-store'): ns3::FileConfig::FileConfig(ns3::FileConfig const & arg0) [copy constructor]

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

    ## file-config.h (module 'config-store'): void ns3::FileConfig::Attributes() [member function]

    cls.add_method('Attributes', 

                   'void', 

                   [], 

                   is_pure_virtual=True, is_virtual=True)

    ## file-config.h (module 'config-store'): void ns3::FileConfig::Default() [member function]

    cls.add_method('Default', 

                   'void', 

                   [], 

                   is_pure_virtual=True, is_virtual=True)

    ## file-config.h (module 'config-store'): void ns3::FileConfig::Global() [member function]

    cls.add_method('Global', 

                   'void', 

                   [], 

                   is_pure_virtual=True, is_virtual=True)

    ## file-config.h (module 'config-store'): void ns3::FileConfig::SetFilename(std::string filename) [member function]

    cls.add_method('SetFilename', 

                   'void', 

                   [param('std::string', 'filename')], 

                   is_pure_virtual=True, is_virtual=True)

    return

def register_Ns3GtkConfigStore_methods(root_module, cls):

    ## gtk-config-store.h (module 'config-store'): ns3::GtkConfigStore::GtkConfigStore(ns3::GtkConfigStore const & arg0) [copy constructor]

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

    ## gtk-config-store.h (module 'config-store'): ns3::GtkConfigStore::GtkConfigStore() [constructor]

    cls.add_constructor([])

    ## gtk-config-store.h (module 'config-store'): void ns3::GtkConfigStore::ConfigureAttributes() [member function]

    cls.add_method('ConfigureAttributes', 

                   'void', 

                   [])

    ## gtk-config-store.h (module 'config-store'): void ns3::GtkConfigStore::ConfigureDefaults() [member function]

    cls.add_method('ConfigureDefaults', 

                   'void', 

                   [])

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

    ## file-config.h (module 'config-store'): ns3::NoneFileConfig::NoneFileConfig(ns3::NoneFileConfig const & arg0) [copy constructor]

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

    ## file-config.h (module 'config-store'): ns3::NoneFileConfig::NoneFileConfig() [constructor]

    cls.add_constructor([])

    ## file-config.h (module 'config-store'): void ns3::NoneFileConfig::Attributes() [member function]

    cls.add_method('Attributes', 

                   'void', 

                   [], 

                   is_virtual=True)

    ## file-config.h (module 'config-store'): void ns3::NoneFileConfig::Default() [member function]

    cls.add_method('Default', 

                   'void', 

                   [], 

                   is_virtual=True)

    ## file-config.h (module 'config-store'): void ns3::NoneFileConfig::Global() [member function]

    cls.add_method('Global', 

                   'void', 

                   [], 

                   is_virtual=True)

    ## file-config.h (module 'config-store'): void ns3::NoneFileConfig::SetFilename(std::string filename) [member function]

    cls.add_method('SetFilename', 

                   'void', 

                   [param('std::string', 'filename')], 

                   is_virtual=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 & value) const [member function]

    cls.add_method('GetAttributeFailSafe', 

                   'bool', 

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

                   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_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<ns3::TraceSourceAccessor const> accessor) [member function]

    cls.add_method('AddTraceSource', 

                   'ns3::TypeId', 

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

                   deprecated=True)

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

    cls.add_method('AddTraceSource', 

                   'ns3::TypeId', 

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

    ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation ns3::TypeId::GetAttribute(uint32_t i) const [member function]

    cls.add_method('GetAttribute', 

                   'ns3::TypeId::AttributeInformation', 

                   [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'): uint32_t ns3::TypeId::GetAttributeN() const [member function]

    cls.add_method('GetAttributeN', 

                   'uint32_t', 

                   [], 

                   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'): uint32_t ns3::TypeId::GetHash() const [member function]

    cls.add_method('GetHash', 

                   'uint32_t', 

                   [], 

                   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'): std::size_t ns3::TypeId::GetSize() const [member function]

    cls.add_method('GetSize', 

                   'std::size_t', 

                   [], 

                   is_const=True)

    ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation ns3::TypeId::GetTraceSource(uint32_t i) const [member function]

    cls.add_method('GetTraceSource', 

                   'ns3::TypeId::TraceSourceInformation', 

                   [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'): 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'): bool ns3::TypeId::LookupAttributeByName(std::string name, ns3::TypeId::AttributeInformation * info) const [member function]

    cls.add_method('LookupAttributeByName', 

                   'bool', 

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

                   is_const=True)

    ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::LookupByHash(uint32_t hash) [member function]

    cls.add_method('LookupByHash', 

                   'ns3::TypeId', 

                   [param('uint32_t', 'hash')], 

                   is_static=True)

    ## type-id.h (module 'core'): static bool ns3::TypeId::LookupByHashFailSafe(uint32_t hash, ns3::TypeId * tid) [member function]

    cls.add_method('LookupByHashFailSafe', 

                   'bool', 

                   [param('uint32_t', 'hash'), param('ns3::TypeId *', 'tid')], 

                   is_static=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<ns3::TraceSourceAccessor const> 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'): bool ns3::TypeId::SetAttributeInitialValue(uint32_t i, ns3::Ptr<ns3::AttributeValue const> initialValue) [member function]

    cls.add_method('SetAttributeInitialValue', 

                   'bool', 

                   [param('uint32_t', 'i'), param('ns3::Ptr< ns3::AttributeValue const >', 'initialValue')])

    ## 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'): ns3::TypeId ns3::TypeId::SetSize(std::size_t size) [member function]

    cls.add_method('SetSize', 

                   'ns3::TypeId', 

                   [param('std::size_t', 'size')])

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

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

    cls.add_constructor([])

    ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation(ns3::TypeId::AttributeInformation const & arg0) [copy constructor]

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

    ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::accessor [variable]

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