bindings/python/ns3_module_core.py
changeset 3731 317f9dbccc2b
parent 3574 b6804efbe16b
child 3745 73e7bb607014
child 3753 a84a48233eb3
equal deleted inserted replaced
3730:ee3519505ec2 3731:317f9dbccc2b
     3 def register_types(module):
     3 def register_types(module):
     4     root_module = module.get_root()
     4     root_module = module.get_root()
     5     
     5     
     6     ## log.h: ns3::LogLevel [enumeration]
     6     ## log.h: ns3::LogLevel [enumeration]
     7     module.add_enum('LogLevel', ['LOG_NONE', 'LOG_ERROR', 'LOG_LEVEL_ERROR', 'LOG_WARN', 'LOG_LEVEL_WARN', 'LOG_DEBUG', 'LOG_LEVEL_DEBUG', 'LOG_INFO', 'LOG_LEVEL_INFO', 'LOG_FUNCTION', 'LOG_LEVEL_FUNCTION', 'LOG_LOGIC', 'LOG_LEVEL_LOGIC', 'LOG_ALL', 'LOG_LEVEL_ALL', 'LOG_PREFIX_FUNC', 'LOG_PREFIX_TIME'])
     7     module.add_enum('LogLevel', ['LOG_NONE', 'LOG_ERROR', 'LOG_LEVEL_ERROR', 'LOG_WARN', 'LOG_LEVEL_WARN', 'LOG_DEBUG', 'LOG_LEVEL_DEBUG', 'LOG_INFO', 'LOG_LEVEL_INFO', 'LOG_FUNCTION', 'LOG_LEVEL_FUNCTION', 'LOG_LOGIC', 'LOG_LEVEL_LOGIC', 'LOG_ALL', 'LOG_LEVEL_ALL', 'LOG_PREFIX_FUNC', 'LOG_PREFIX_TIME'])
       
     8     ## attribute-list.h: ns3::AttributeList [class]
       
     9     module.add_class('AttributeList')
       
    10     ## callback.h: ns3::CallbackBase [class]
       
    11     module.add_class('CallbackBase')
       
    12     ## callback.h: ns3::CallbackImplBase [class]
       
    13     module.add_class('CallbackImplBase', allow_subclassing=True, memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
       
    14     ## command-line.h: ns3::CommandLine [class]
       
    15     module.add_class('CommandLine')
       
    16     ## system-mutex.h: ns3::CriticalSection [class]
       
    17     module.add_class('CriticalSection')
       
    18     ## global-value.h: ns3::GlobalValue [class]
       
    19     module.add_class('GlobalValue')
       
    20     ## int-to-type.h: ns3::IntToType<0> [struct]
       
    21     module.add_class('IntToType', template_parameters=['0'])
       
    22     ## int-to-type.h: ns3::IntToType<0>::v_e [enumeration]
       
    23     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 0 >'])
       
    24     ## int-to-type.h: ns3::IntToType<1> [struct]
       
    25     module.add_class('IntToType', template_parameters=['1'])
       
    26     ## int-to-type.h: ns3::IntToType<1>::v_e [enumeration]
       
    27     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 1 >'])
       
    28     ## int-to-type.h: ns3::IntToType<2> [struct]
       
    29     module.add_class('IntToType', template_parameters=['2'])
       
    30     ## int-to-type.h: ns3::IntToType<2>::v_e [enumeration]
       
    31     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 2 >'])
       
    32     ## int-to-type.h: ns3::IntToType<3> [struct]
       
    33     module.add_class('IntToType', template_parameters=['3'])
       
    34     ## int-to-type.h: ns3::IntToType<3>::v_e [enumeration]
       
    35     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 3 >'])
       
    36     ## int-to-type.h: ns3::IntToType<4> [struct]
       
    37     module.add_class('IntToType', template_parameters=['4'])
       
    38     ## int-to-type.h: ns3::IntToType<4>::v_e [enumeration]
       
    39     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 4 >'])
       
    40     ## int-to-type.h: ns3::IntToType<5> [struct]
       
    41     module.add_class('IntToType', template_parameters=['5'])
       
    42     ## int-to-type.h: ns3::IntToType<5>::v_e [enumeration]
       
    43     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 5 >'])
       
    44     ## int-to-type.h: ns3::IntToType<6> [struct]
       
    45     module.add_class('IntToType', template_parameters=['6'])
       
    46     ## int-to-type.h: ns3::IntToType<6>::v_e [enumeration]
       
    47     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 6 >'])
       
    48     ## object-base.h: ns3::ObjectBase [class]
       
    49     module.add_class('ObjectBase', allow_subclassing=True)
       
    50     ## object-factory.h: ns3::ObjectFactory [class]
       
    51     module.add_class('ObjectFactory')
     8     ## random-variable.h: ns3::RandomVariable [class]
    52     ## random-variable.h: ns3::RandomVariable [class]
     9     module.add_class('RandomVariable')
    53     module.add_class('RandomVariable')
       
    54     ## ref-count-base.h: ns3::RefCountBase [class]
       
    55     module.add_class('RefCountBase', automatic_type_narrowing=True, memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
       
    56     ## rng-stream.h: ns3::RngStream [class]
       
    57     module.add_class('RngStream')
       
    58     ## random-variable.h: ns3::SequentialVariable [class]
       
    59     module.add_class('SequentialVariable', parent=root_module['ns3::RandomVariable'])
       
    60     ## system-condition.h: ns3::SystemCondition [class]
       
    61     module.add_class('SystemCondition')
       
    62     ## system-mutex.h: ns3::SystemMutex [class]
       
    63     module.add_class('SystemMutex')
       
    64     ## system-thread.h: ns3::SystemThread [class]
       
    65     module.add_class('SystemThread')
       
    66     ## system-wall-clock-ms.h: ns3::SystemWallClockMs [class]
       
    67     module.add_class('SystemWallClockMs')
       
    68     ## trace-source-accessor.h: ns3::TraceSourceAccessor [class]
       
    69     module.add_class('TraceSourceAccessor', allow_subclassing=True)
    10     ## random-variable.h: ns3::TriangularVariable [class]
    70     ## random-variable.h: ns3::TriangularVariable [class]
    11     module.add_class('TriangularVariable', parent=root_module['ns3::RandomVariable'])
    71     module.add_class('TriangularVariable', parent=root_module['ns3::RandomVariable'])
    12     ## global-value.h: ns3::GlobalValue [class]
       
    13     module.add_class('GlobalValue')
       
    14     ## ref-count-base.h: ns3::RefCountBase [class]
       
    15     module.add_class('RefCountBase', automatic_type_narrowing=True, memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
       
    16     ## type-id.h: ns3::TypeId [class]
    72     ## type-id.h: ns3::TypeId [class]
    17     module.add_class('TypeId')
    73     module.add_class('TypeId')
    18     ## type-id.h: ns3::TypeId::AttributeFlag [enumeration]
    74     ## type-id.h: ns3::TypeId::AttributeFlag [enumeration]
    19     module.add_enum('AttributeFlag', ['ATTR_GET', 'ATTR_SET', 'ATTR_CONSTRUCT', 'ATTR_SGC'], outer_class=root_module['ns3::TypeId'])
    75     module.add_enum('AttributeFlag', ['ATTR_GET', 'ATTR_SET', 'ATTR_CONSTRUCT', 'ATTR_SGC'], outer_class=root_module['ns3::TypeId'])
    20     ## type-id.h: ns3::TypeId::AttributeInfo [struct]
    76     ## type-id.h: ns3::TypeId::AttributeInfo [struct]
    21     module.add_class('AttributeInfo', outer_class=root_module['ns3::TypeId'])
    77     module.add_class('AttributeInfo', outer_class=root_module['ns3::TypeId'])
    22     ## system-wall-clock-ms.h: ns3::SystemWallClockMs [class]
    78     ## random-variable.h: ns3::UniformVariable [class]
    23     module.add_class('SystemWallClockMs')
    79     module.add_class('UniformVariable', parent=root_module['ns3::RandomVariable'])
    24     ## callback.h: ns3::CallbackImplBase [class]
    80     ## random-variable.h: ns3::WeibullVariable [class]
    25     module.add_class('CallbackImplBase', allow_subclassing=True, memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
    81     module.add_class('WeibullVariable', parent=root_module['ns3::RandomVariable'])
    26     ## system-mutex.h: ns3::CriticalSection [class]
    82     ## empty.h: ns3::empty [class]
    27     module.add_class('CriticalSection')
    83     module.add_class('empty')
    28     ## trace-source-accessor.h: ns3::TraceSourceAccessor [class]
    84     ## attribute.h: ns3::AttributeAccessor [class]
    29     module.add_class('TraceSourceAccessor', allow_subclassing=True)
    85     module.add_class('AttributeAccessor', parent=root_module['ns3::RefCountBase'])
    30     ## attribute.h: ns3::AttributeChecker [class]
    86     ## attribute.h: ns3::AttributeChecker [class]
    31     module.add_class('AttributeChecker', allow_subclassing=False, automatic_type_narrowing=True, parent=root_module['ns3::RefCountBase'])
    87     module.add_class('AttributeChecker', allow_subclassing=False, automatic_type_narrowing=True, parent=root_module['ns3::RefCountBase'])
    32     ## random-variable.h: ns3::RandomVariableChecker [class]
    88     ## attribute.h: ns3::AttributeValue [class]
    33     module.add_class('RandomVariableChecker', parent=root_module['ns3::AttributeChecker'])
    89     module.add_class('AttributeValue', allow_subclassing=False, automatic_type_narrowing=True, parent=root_module['ns3::RefCountBase'])
    34     ## system-mutex.h: ns3::SystemMutex [class]
    90     ## boolean.h: ns3::BooleanChecker [class]
    35     module.add_class('SystemMutex')
    91     module.add_class('BooleanChecker', parent=root_module['ns3::AttributeChecker'])
       
    92     ## boolean.h: ns3::BooleanValue [class]
       
    93     module.add_class('BooleanValue', parent=root_module['ns3::AttributeValue'])
       
    94     ## random-variable.h: ns3::ConstantVariable [class]
       
    95     module.add_class('ConstantVariable', parent=root_module['ns3::RandomVariable'])
       
    96     ## random-variable.h: ns3::DeterministicVariable [class]
       
    97     module.add_class('DeterministicVariable', parent=root_module['ns3::RandomVariable'])
       
    98     ## double.h: ns3::DoubleValue [class]
       
    99     module.add_class('DoubleValue', parent=root_module['ns3::AttributeValue'])
       
   100     ## random-variable.h: ns3::EmpiricalVariable [class]
       
   101     module.add_class('EmpiricalVariable', parent=root_module['ns3::RandomVariable'])
       
   102     ## attribute.h: ns3::EmptyAttributeValue [class]
       
   103     module.add_class('EmptyAttributeValue', parent=root_module['ns3::AttributeValue'])
       
   104     ## enum.h: ns3::EnumChecker [class]
       
   105     module.add_class('EnumChecker', parent=root_module['ns3::AttributeChecker'])
       
   106     ## enum.h: ns3::EnumValue [class]
       
   107     module.add_class('EnumValue', parent=root_module['ns3::AttributeValue'])
       
   108     ## random-variable.h: ns3::ExponentialVariable [class]
       
   109     module.add_class('ExponentialVariable', parent=root_module['ns3::RandomVariable'])
       
   110     ## random-variable.h: ns3::IntEmpiricalVariable [class]
       
   111     module.add_class('IntEmpiricalVariable', parent=root_module['ns3::EmpiricalVariable'])
       
   112     ## integer.h: ns3::IntegerValue [class]
       
   113     module.add_class('IntegerValue', parent=root_module['ns3::AttributeValue'])
       
   114     ## random-variable.h: ns3::LogNormalVariable [class]
       
   115     module.add_class('LogNormalVariable', parent=root_module['ns3::RandomVariable'])
    36     ## random-variable.h: ns3::NormalVariable [class]
   116     ## random-variable.h: ns3::NormalVariable [class]
    37     module.add_class('NormalVariable', parent=root_module['ns3::RandomVariable'])
   117     module.add_class('NormalVariable', parent=root_module['ns3::RandomVariable'])
    38     ## object-factory.h: ns3::ObjectFactory [class]
       
    39     module.add_class('ObjectFactory')
       
    40     ## attribute.h: ns3::AttributeAccessor [class]
       
    41     module.add_class('AttributeAccessor', parent=root_module['ns3::RefCountBase'])
       
    42     ## random-variable.h: ns3::ParetoVariable [class]
       
    43     module.add_class('ParetoVariable', parent=root_module['ns3::RandomVariable'])
       
    44     ## random-variable.h: ns3::ConstantVariable [class]
       
    45     module.add_class('ConstantVariable', parent=root_module['ns3::RandomVariable'])
       
    46     ## random-variable.h: ns3::EmpiricalVariable [class]
       
    47     module.add_class('EmpiricalVariable', parent=root_module['ns3::RandomVariable'])
       
    48     ## enum.h: ns3::EnumChecker [class]
       
    49     module.add_class('EnumChecker', parent=root_module['ns3::AttributeChecker'])
       
    50     ## empty.h: ns3::empty [class]
       
    51     module.add_class('empty')
       
    52     ## object-base.h: ns3::ObjectBase [class]
       
    53     module.add_class('ObjectBase', allow_subclassing=True)
       
    54     ## command-line.h: ns3::CommandLine [class]
       
    55     module.add_class('CommandLine')
       
    56     ## int-to-type.h: ns3::IntToType<6> [struct]
       
    57     module.add_class('IntToType', template_parameters=['6'])
       
    58     ## int-to-type.h: ns3::IntToType<6>::v_e [enumeration]
       
    59     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 6 >'])
       
    60     ## int-to-type.h: ns3::IntToType<5> [struct]
       
    61     module.add_class('IntToType', template_parameters=['5'])
       
    62     ## int-to-type.h: ns3::IntToType<5>::v_e [enumeration]
       
    63     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 5 >'])
       
    64     ## int-to-type.h: ns3::IntToType<4> [struct]
       
    65     module.add_class('IntToType', template_parameters=['4'])
       
    66     ## int-to-type.h: ns3::IntToType<4>::v_e [enumeration]
       
    67     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 4 >'])
       
    68     ## int-to-type.h: ns3::IntToType<3> [struct]
       
    69     module.add_class('IntToType', template_parameters=['3'])
       
    70     ## int-to-type.h: ns3::IntToType<3>::v_e [enumeration]
       
    71     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 3 >'])
       
    72     ## int-to-type.h: ns3::IntToType<2> [struct]
       
    73     module.add_class('IntToType', template_parameters=['2'])
       
    74     ## int-to-type.h: ns3::IntToType<2>::v_e [enumeration]
       
    75     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 2 >'])
       
    76     ## int-to-type.h: ns3::IntToType<1> [struct]
       
    77     module.add_class('IntToType', template_parameters=['1'])
       
    78     ## int-to-type.h: ns3::IntToType<1>::v_e [enumeration]
       
    79     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 1 >'])
       
    80     ## int-to-type.h: ns3::IntToType<0> [struct]
       
    81     module.add_class('IntToType', template_parameters=['0'])
       
    82     ## int-to-type.h: ns3::IntToType<0>::v_e [enumeration]
       
    83     module.add_enum('v_e', ['value'], outer_class=root_module['ns3::IntToType< 0 >'])
       
    84     ## rng-stream.h: ns3::RngStream [class]
       
    85     module.add_class('RngStream')
       
    86     ## random-variable.h: ns3::LogNormalVariable [class]
       
    87     module.add_class('LogNormalVariable', parent=root_module['ns3::RandomVariable'])
       
    88     ## random-variable.h: ns3::IntEmpiricalVariable [class]
       
    89     module.add_class('IntEmpiricalVariable', parent=root_module['ns3::EmpiricalVariable'])
       
    90     ## pointer.h: ns3::PointerChecker [class]
       
    91     module.add_class('PointerChecker', parent=root_module['ns3::AttributeChecker'])
       
    92     ## random-variable.h: ns3::WeibullVariable [class]
       
    93     module.add_class('WeibullVariable', parent=root_module['ns3::RandomVariable'])
       
    94     ## callback.h: ns3::CallbackBase [class]
       
    95     module.add_class('CallbackBase')
       
    96     ## random-variable.h: ns3::ExponentialVariable [class]
       
    97     module.add_class('ExponentialVariable', parent=root_module['ns3::RandomVariable'])
       
    98     ## random-variable.h: ns3::DeterministicVariable [class]
       
    99     module.add_class('DeterministicVariable', parent=root_module['ns3::RandomVariable'])
       
   100     ## system-thread.h: ns3::SystemThread [class]
       
   101     module.add_class('SystemThread')
       
   102     ## attribute-list.h: ns3::AttributeList [class]
       
   103     module.add_class('AttributeList')
       
   104     ## attribute.h: ns3::AttributeValue [class]
       
   105     module.add_class('AttributeValue', allow_subclassing=False, automatic_type_narrowing=True, parent=root_module['ns3::RefCountBase'])
       
   106     ## random-variable.h: ns3::UniformVariable [class]
       
   107     module.add_class('UniformVariable', parent=root_module['ns3::RandomVariable'])
       
   108     ## object.h: ns3::Object [class]
   118     ## object.h: ns3::Object [class]
   109     module.add_class('Object', automatic_type_narrowing=True, parent=root_module['ns3::ObjectBase'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
   119     module.add_class('Object', automatic_type_narrowing=True, parent=root_module['ns3::ObjectBase'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
   110     ## object.h: ns3::Object::AggregateIterator [class]
   120     ## object.h: ns3::Object::AggregateIterator [class]
   111     module.add_class('AggregateIterator', outer_class=root_module['ns3::Object'])
   121     module.add_class('AggregateIterator', outer_class=root_module['ns3::Object'])
   112     ## system-condition.h: ns3::SystemCondition [class]
   122     ## object-factory.h: ns3::ObjectFactoryChecker [class]
   113     module.add_class('SystemCondition')
   123     module.add_class('ObjectFactoryChecker', parent=root_module['ns3::AttributeChecker'])
   114     ## random-variable.h: ns3::SequentialVariable [class]
   124     ## object-factory.h: ns3::ObjectFactoryValue [class]
   115     module.add_class('SequentialVariable', parent=root_module['ns3::RandomVariable'])
   125     module.add_class('ObjectFactoryValue', parent=root_module['ns3::AttributeValue'])
       
   126     ## object-vector.h: ns3::ObjectVectorAccessor [class]
       
   127     module.add_class('ObjectVectorAccessor', parent=root_module['ns3::AttributeAccessor'])
   116     ## object-vector.h: ns3::ObjectVectorChecker [class]
   128     ## object-vector.h: ns3::ObjectVectorChecker [class]
   117     module.add_class('ObjectVectorChecker', parent=root_module['ns3::AttributeChecker'])
   129     module.add_class('ObjectVectorChecker', parent=root_module['ns3::AttributeChecker'])
       
   130     ## object-vector.h: ns3::ObjectVectorValue [class]
       
   131     module.add_class('ObjectVectorValue', parent=root_module['ns3::AttributeValue'])
       
   132     ## random-variable.h: ns3::ParetoVariable [class]
       
   133     module.add_class('ParetoVariable', parent=root_module['ns3::RandomVariable'])
       
   134     ## pointer.h: ns3::PointerChecker [class]
       
   135     module.add_class('PointerChecker', parent=root_module['ns3::AttributeChecker'])
       
   136     ## pointer.h: ns3::PointerValue [class]
       
   137     module.add_class('PointerValue', parent=root_module['ns3::AttributeValue'])
       
   138     ## random-variable.h: ns3::RandomVariableChecker [class]
       
   139     module.add_class('RandomVariableChecker', parent=root_module['ns3::AttributeChecker'])
       
   140     ## random-variable.h: ns3::RandomVariableValue [class]
       
   141     module.add_class('RandomVariableValue', parent=root_module['ns3::AttributeValue'])
   118     ## string.h: ns3::StringChecker [class]
   142     ## string.h: ns3::StringChecker [class]
   119     module.add_class('StringChecker', parent=root_module['ns3::AttributeChecker'])
   143     module.add_class('StringChecker', parent=root_module['ns3::AttributeChecker'])
   120     ## object-vector.h: ns3::ObjectVectorValue [class]
   144     ## string.h: ns3::StringValue [class]
   121     module.add_class('ObjectVectorValue', parent=root_module['ns3::AttributeValue'])
   145     module.add_class('StringValue', parent=root_module['ns3::AttributeValue'])
   122     ## boolean.h: ns3::BooleanChecker [class]
   146     ## type-id.h: ns3::TypeIdChecker [class]
   123     module.add_class('BooleanChecker', parent=root_module['ns3::AttributeChecker'])
   147     module.add_class('TypeIdChecker', parent=root_module['ns3::AttributeChecker'])
       
   148     ## type-id.h: ns3::TypeIdValue [class]
       
   149     module.add_class('TypeIdValue', parent=root_module['ns3::AttributeValue'])
   124     ## uinteger.h: ns3::UintegerValue [class]
   150     ## uinteger.h: ns3::UintegerValue [class]
   125     module.add_class('UintegerValue', parent=root_module['ns3::AttributeValue'])
   151     module.add_class('UintegerValue', parent=root_module['ns3::AttributeValue'])
   126     ## object-vector.h: ns3::ObjectVectorAccessor [class]
       
   127     module.add_class('ObjectVectorAccessor', parent=root_module['ns3::AttributeAccessor'])
       
   128     ## pointer.h: ns3::PointerValue [class]
       
   129     module.add_class('PointerValue', parent=root_module['ns3::AttributeValue'])
       
   130     ## object-factory.h: ns3::ObjectFactoryChecker [class]
       
   131     module.add_class('ObjectFactoryChecker', parent=root_module['ns3::AttributeChecker'])
       
   132     ## type-id.h: ns3::TypeIdChecker [class]
       
   133     module.add_class('TypeIdChecker', parent=root_module['ns3::AttributeChecker'])
       
   134     ## double.h: ns3::DoubleValue [class]
       
   135     module.add_class('DoubleValue', parent=root_module['ns3::AttributeValue'])
       
   136     ## type-id.h: ns3::TypeIdValue [class]
       
   137     module.add_class('TypeIdValue', parent=root_module['ns3::AttributeValue'])
       
   138     ## enum.h: ns3::EnumValue [class]
       
   139     module.add_class('EnumValue', parent=root_module['ns3::AttributeValue'])
       
   140     ## random-variable.h: ns3::RandomVariableValue [class]
       
   141     module.add_class('RandomVariableValue', parent=root_module['ns3::AttributeValue'])
       
   142     ## object-factory.h: ns3::ObjectFactoryValue [class]
       
   143     module.add_class('ObjectFactoryValue', parent=root_module['ns3::AttributeValue'])
       
   144     ## integer.h: ns3::IntegerValue [class]
       
   145     module.add_class('IntegerValue', parent=root_module['ns3::AttributeValue'])
       
   146     ## boolean.h: ns3::BooleanValue [class]
       
   147     module.add_class('BooleanValue', parent=root_module['ns3::AttributeValue'])
       
   148     ## string.h: ns3::StringValue [class]
       
   149     module.add_class('StringValue', parent=root_module['ns3::AttributeValue'])
       
   150     ## attribute.h: ns3::EmptyAttributeValue [class]
       
   151     module.add_class('EmptyAttributeValue', parent=root_module['ns3::AttributeValue'])
       
   152     ## traced-value.h: ns3::TracedValue<unsigned int> [class]
   152     ## traced-value.h: ns3::TracedValue<unsigned int> [class]
   153     module.add_class('TracedValue', template_parameters=['unsigned int'])
   153     module.add_class('TracedValue', template_parameters=['unsigned int'])
   154     ## traced-value.h: ns3::TracedValue<unsigned int> [class]
   154     ## traced-value.h: ns3::TracedValue<unsigned int> [class]
   155     root_module['ns3::TracedValue< unsigned int >'].implicitly_converts_to(root_module['ns3::IntegerValue'])
   155     root_module['ns3::TracedValue< unsigned int >'].implicitly_converts_to(root_module['ns3::IntegerValue'])
   156     ## traced-value.h: ns3::TracedValue<unsigned int> [class]
   156     ## traced-value.h: ns3::TracedValue<unsigned int> [class]
   199 def register_types_ns3_olsr(module):
   199 def register_types_ns3_olsr(module):
   200     root_module = module.get_root()
   200     root_module = module.get_root()
   201     
   201     
   202 
   202 
   203 def register_methods(root_module):
   203 def register_methods(root_module):
       
   204     register_Ns3AttributeList_methods(root_module, root_module['ns3::AttributeList'])
       
   205     register_Ns3CallbackBase_methods(root_module, root_module['ns3::CallbackBase'])
       
   206     register_Ns3CallbackImplBase_methods(root_module, root_module['ns3::CallbackImplBase'])
       
   207     register_Ns3CommandLine_methods(root_module, root_module['ns3::CommandLine'])
       
   208     register_Ns3CriticalSection_methods(root_module, root_module['ns3::CriticalSection'])
       
   209     register_Ns3GlobalValue_methods(root_module, root_module['ns3::GlobalValue'])
       
   210     register_Ns3IntToType__0_methods(root_module, root_module['ns3::IntToType< 0 >'])
       
   211     register_Ns3IntToType__1_methods(root_module, root_module['ns3::IntToType< 1 >'])
       
   212     register_Ns3IntToType__2_methods(root_module, root_module['ns3::IntToType< 2 >'])
       
   213     register_Ns3IntToType__3_methods(root_module, root_module['ns3::IntToType< 3 >'])
       
   214     register_Ns3IntToType__4_methods(root_module, root_module['ns3::IntToType< 4 >'])
       
   215     register_Ns3IntToType__5_methods(root_module, root_module['ns3::IntToType< 5 >'])
       
   216     register_Ns3IntToType__6_methods(root_module, root_module['ns3::IntToType< 6 >'])
       
   217     register_Ns3ObjectBase_methods(root_module, root_module['ns3::ObjectBase'])
       
   218     register_Ns3ObjectFactory_methods(root_module, root_module['ns3::ObjectFactory'])
   204     register_Ns3RandomVariable_methods(root_module, root_module['ns3::RandomVariable'])
   219     register_Ns3RandomVariable_methods(root_module, root_module['ns3::RandomVariable'])
       
   220     register_Ns3RefCountBase_methods(root_module, root_module['ns3::RefCountBase'])
       
   221     register_Ns3RngStream_methods(root_module, root_module['ns3::RngStream'])
       
   222     register_Ns3SequentialVariable_methods(root_module, root_module['ns3::SequentialVariable'])
       
   223     register_Ns3SystemCondition_methods(root_module, root_module['ns3::SystemCondition'])
       
   224     register_Ns3SystemMutex_methods(root_module, root_module['ns3::SystemMutex'])
       
   225     register_Ns3SystemThread_methods(root_module, root_module['ns3::SystemThread'])
       
   226     register_Ns3SystemWallClockMs_methods(root_module, root_module['ns3::SystemWallClockMs'])
       
   227     register_Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::TraceSourceAccessor'])
   205     register_Ns3TriangularVariable_methods(root_module, root_module['ns3::TriangularVariable'])
   228     register_Ns3TriangularVariable_methods(root_module, root_module['ns3::TriangularVariable'])
   206     register_Ns3GlobalValue_methods(root_module, root_module['ns3::GlobalValue'])
       
   207     register_Ns3RefCountBase_methods(root_module, root_module['ns3::RefCountBase'])
       
   208     register_Ns3TypeId_methods(root_module, root_module['ns3::TypeId'])
   229     register_Ns3TypeId_methods(root_module, root_module['ns3::TypeId'])
   209     register_Ns3TypeIdAttributeInfo_methods(root_module, root_module['ns3::TypeId::AttributeInfo'])
   230     register_Ns3TypeIdAttributeInfo_methods(root_module, root_module['ns3::TypeId::AttributeInfo'])
   210     register_Ns3SystemWallClockMs_methods(root_module, root_module['ns3::SystemWallClockMs'])
   231     register_Ns3UniformVariable_methods(root_module, root_module['ns3::UniformVariable'])
   211     register_Ns3CallbackImplBase_methods(root_module, root_module['ns3::CallbackImplBase'])
   232     register_Ns3WeibullVariable_methods(root_module, root_module['ns3::WeibullVariable'])
   212     register_Ns3CriticalSection_methods(root_module, root_module['ns3::CriticalSection'])
   233     register_Ns3Empty_methods(root_module, root_module['ns3::empty'])
   213     register_Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::TraceSourceAccessor'])
   234     register_Ns3AttributeAccessor_methods(root_module, root_module['ns3::AttributeAccessor'])
   214     register_Ns3AttributeChecker_methods(root_module, root_module['ns3::AttributeChecker'])
   235     register_Ns3AttributeChecker_methods(root_module, root_module['ns3::AttributeChecker'])
   215     register_Ns3RandomVariableChecker_methods(root_module, root_module['ns3::RandomVariableChecker'])
   236     register_Ns3AttributeValue_methods(root_module, root_module['ns3::AttributeValue'])
   216     register_Ns3SystemMutex_methods(root_module, root_module['ns3::SystemMutex'])
   237     register_Ns3BooleanChecker_methods(root_module, root_module['ns3::BooleanChecker'])
       
   238     register_Ns3BooleanValue_methods(root_module, root_module['ns3::BooleanValue'])
       
   239     register_Ns3ConstantVariable_methods(root_module, root_module['ns3::ConstantVariable'])
       
   240     register_Ns3DeterministicVariable_methods(root_module, root_module['ns3::DeterministicVariable'])
       
   241     register_Ns3DoubleValue_methods(root_module, root_module['ns3::DoubleValue'])
       
   242     register_Ns3EmpiricalVariable_methods(root_module, root_module['ns3::EmpiricalVariable'])
       
   243     register_Ns3EmptyAttributeValue_methods(root_module, root_module['ns3::EmptyAttributeValue'])
       
   244     register_Ns3EnumChecker_methods(root_module, root_module['ns3::EnumChecker'])
       
   245     register_Ns3EnumValue_methods(root_module, root_module['ns3::EnumValue'])
       
   246     register_Ns3ExponentialVariable_methods(root_module, root_module['ns3::ExponentialVariable'])
       
   247     register_Ns3IntEmpiricalVariable_methods(root_module, root_module['ns3::IntEmpiricalVariable'])
       
   248     register_Ns3IntegerValue_methods(root_module, root_module['ns3::IntegerValue'])
       
   249     register_Ns3LogNormalVariable_methods(root_module, root_module['ns3::LogNormalVariable'])
   217     register_Ns3NormalVariable_methods(root_module, root_module['ns3::NormalVariable'])
   250     register_Ns3NormalVariable_methods(root_module, root_module['ns3::NormalVariable'])
   218     register_Ns3ObjectFactory_methods(root_module, root_module['ns3::ObjectFactory'])
       
   219     register_Ns3AttributeAccessor_methods(root_module, root_module['ns3::AttributeAccessor'])
       
   220     register_Ns3ParetoVariable_methods(root_module, root_module['ns3::ParetoVariable'])
       
   221     register_Ns3ConstantVariable_methods(root_module, root_module['ns3::ConstantVariable'])
       
   222     register_Ns3EmpiricalVariable_methods(root_module, root_module['ns3::EmpiricalVariable'])
       
   223     register_Ns3EnumChecker_methods(root_module, root_module['ns3::EnumChecker'])
       
   224     register_Ns3Empty_methods(root_module, root_module['ns3::empty'])
       
   225     register_Ns3ObjectBase_methods(root_module, root_module['ns3::ObjectBase'])
       
   226     register_Ns3CommandLine_methods(root_module, root_module['ns3::CommandLine'])
       
   227     register_Ns3IntToType__6_methods(root_module, root_module['ns3::IntToType< 6 >'])
       
   228     register_Ns3IntToType__5_methods(root_module, root_module['ns3::IntToType< 5 >'])
       
   229     register_Ns3IntToType__4_methods(root_module, root_module['ns3::IntToType< 4 >'])
       
   230     register_Ns3IntToType__3_methods(root_module, root_module['ns3::IntToType< 3 >'])
       
   231     register_Ns3IntToType__2_methods(root_module, root_module['ns3::IntToType< 2 >'])
       
   232     register_Ns3IntToType__1_methods(root_module, root_module['ns3::IntToType< 1 >'])
       
   233     register_Ns3IntToType__0_methods(root_module, root_module['ns3::IntToType< 0 >'])
       
   234     register_Ns3RngStream_methods(root_module, root_module['ns3::RngStream'])
       
   235     register_Ns3LogNormalVariable_methods(root_module, root_module['ns3::LogNormalVariable'])
       
   236     register_Ns3IntEmpiricalVariable_methods(root_module, root_module['ns3::IntEmpiricalVariable'])
       
   237     register_Ns3PointerChecker_methods(root_module, root_module['ns3::PointerChecker'])
       
   238     register_Ns3WeibullVariable_methods(root_module, root_module['ns3::WeibullVariable'])
       
   239     register_Ns3CallbackBase_methods(root_module, root_module['ns3::CallbackBase'])
       
   240     register_Ns3ExponentialVariable_methods(root_module, root_module['ns3::ExponentialVariable'])
       
   241     register_Ns3DeterministicVariable_methods(root_module, root_module['ns3::DeterministicVariable'])
       
   242     register_Ns3SystemThread_methods(root_module, root_module['ns3::SystemThread'])
       
   243     register_Ns3AttributeList_methods(root_module, root_module['ns3::AttributeList'])
       
   244     register_Ns3AttributeValue_methods(root_module, root_module['ns3::AttributeValue'])
       
   245     register_Ns3UniformVariable_methods(root_module, root_module['ns3::UniformVariable'])
       
   246     register_Ns3Object_methods(root_module, root_module['ns3::Object'])
   251     register_Ns3Object_methods(root_module, root_module['ns3::Object'])
   247     register_Ns3ObjectAggregateIterator_methods(root_module, root_module['ns3::Object::AggregateIterator'])
   252     register_Ns3ObjectAggregateIterator_methods(root_module, root_module['ns3::Object::AggregateIterator'])
   248     register_Ns3SystemCondition_methods(root_module, root_module['ns3::SystemCondition'])
   253     register_Ns3ObjectFactoryChecker_methods(root_module, root_module['ns3::ObjectFactoryChecker'])
   249     register_Ns3SequentialVariable_methods(root_module, root_module['ns3::SequentialVariable'])
   254     register_Ns3ObjectFactoryValue_methods(root_module, root_module['ns3::ObjectFactoryValue'])
       
   255     register_Ns3ObjectVectorAccessor_methods(root_module, root_module['ns3::ObjectVectorAccessor'])
   250     register_Ns3ObjectVectorChecker_methods(root_module, root_module['ns3::ObjectVectorChecker'])
   256     register_Ns3ObjectVectorChecker_methods(root_module, root_module['ns3::ObjectVectorChecker'])
       
   257     register_Ns3ObjectVectorValue_methods(root_module, root_module['ns3::ObjectVectorValue'])
       
   258     register_Ns3ParetoVariable_methods(root_module, root_module['ns3::ParetoVariable'])
       
   259     register_Ns3PointerChecker_methods(root_module, root_module['ns3::PointerChecker'])
       
   260     register_Ns3PointerValue_methods(root_module, root_module['ns3::PointerValue'])
       
   261     register_Ns3RandomVariableChecker_methods(root_module, root_module['ns3::RandomVariableChecker'])
       
   262     register_Ns3RandomVariableValue_methods(root_module, root_module['ns3::RandomVariableValue'])
   251     register_Ns3StringChecker_methods(root_module, root_module['ns3::StringChecker'])
   263     register_Ns3StringChecker_methods(root_module, root_module['ns3::StringChecker'])
   252     register_Ns3ObjectVectorValue_methods(root_module, root_module['ns3::ObjectVectorValue'])
   264     register_Ns3StringValue_methods(root_module, root_module['ns3::StringValue'])
   253     register_Ns3BooleanChecker_methods(root_module, root_module['ns3::BooleanChecker'])
   265     register_Ns3TypeIdChecker_methods(root_module, root_module['ns3::TypeIdChecker'])
       
   266     register_Ns3TypeIdValue_methods(root_module, root_module['ns3::TypeIdValue'])
   254     register_Ns3UintegerValue_methods(root_module, root_module['ns3::UintegerValue'])
   267     register_Ns3UintegerValue_methods(root_module, root_module['ns3::UintegerValue'])
   255     register_Ns3ObjectVectorAccessor_methods(root_module, root_module['ns3::ObjectVectorAccessor'])
       
   256     register_Ns3PointerValue_methods(root_module, root_module['ns3::PointerValue'])
       
   257     register_Ns3ObjectFactoryChecker_methods(root_module, root_module['ns3::ObjectFactoryChecker'])
       
   258     register_Ns3TypeIdChecker_methods(root_module, root_module['ns3::TypeIdChecker'])
       
   259     register_Ns3DoubleValue_methods(root_module, root_module['ns3::DoubleValue'])
       
   260     register_Ns3TypeIdValue_methods(root_module, root_module['ns3::TypeIdValue'])
       
   261     register_Ns3EnumValue_methods(root_module, root_module['ns3::EnumValue'])
       
   262     register_Ns3RandomVariableValue_methods(root_module, root_module['ns3::RandomVariableValue'])
       
   263     register_Ns3ObjectFactoryValue_methods(root_module, root_module['ns3::ObjectFactoryValue'])
       
   264     register_Ns3IntegerValue_methods(root_module, root_module['ns3::IntegerValue'])
       
   265     register_Ns3BooleanValue_methods(root_module, root_module['ns3::BooleanValue'])
       
   266     register_Ns3StringValue_methods(root_module, root_module['ns3::StringValue'])
       
   267     register_Ns3EmptyAttributeValue_methods(root_module, root_module['ns3::EmptyAttributeValue'])
       
   268     register_Ns3TracedValue__Unsigned_int_methods(root_module, root_module['ns3::TracedValue< unsigned int >'])
   268     register_Ns3TracedValue__Unsigned_int_methods(root_module, root_module['ns3::TracedValue< unsigned int >'])
   269     return
   269     return
   270 
   270 
   271 def register_Ns3RandomVariable_methods(root_module, cls):
   271 def register_Ns3AttributeList_methods(root_module, cls):
   272     ## random-variable.h: ns3::RandomVariable::RandomVariable() [constructor]
   272     ## attribute-list.h: ns3::AttributeList::AttributeList() [constructor]
   273     cls.add_constructor([])
   273     cls.add_constructor([])
   274     ## random-variable.h: ns3::RandomVariable::RandomVariable(ns3::RandomVariable const & o) [copy constructor]
   274     ## attribute-list.h: ns3::AttributeList::AttributeList(ns3::AttributeList const & o) [copy constructor]
   275     cls.add_constructor([param('ns3::RandomVariable const &', 'o')])
   275     cls.add_constructor([param('ns3::AttributeList const &', 'o')])
   276     ## random-variable.h: uint32_t ns3::RandomVariable::GetInteger() const [member function]
   276     ## attribute-list.h: void ns3::AttributeList::Set(std::string name, ns3::AttributeValue const & value) [member function]
   277     cls.add_method('GetInteger', 
   277     cls.add_method('Set', 
   278                    'uint32_t', 
   278                    'void', 
   279                    [], 
   279                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
   280                    is_const=True)
   280     ## attribute-list.h: bool ns3::AttributeList::SetFailSafe(std::string name, ns3::AttributeValue const & value) [member function]
   281     ## random-variable.h: void ns3::RandomVariable::GetSeed(uint32_t * seed) const [member function]
   281     cls.add_method('SetFailSafe', 
   282     cls.add_method('GetSeed', 
   282                    'bool', 
   283                    'void', 
   283                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
   284                    [param('uint32_t *', 'seed', direction=2, array_length=6)], 
   284     ## attribute-list.h: void ns3::AttributeList::SetWithTid(ns3::TypeId tid, std::string name, ns3::AttributeValue const & value) [member function]
   285                    is_const=True)
   285     cls.add_method('SetWithTid', 
   286     ## random-variable.h: double ns3::RandomVariable::GetValue() const [member function]
   286                    'void', 
   287     cls.add_method('GetValue', 
   287                    [param('ns3::TypeId', 'tid'), param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
   288                    'double', 
   288     ## attribute-list.h: void ns3::AttributeList::Reset() [member function]
   289                    [], 
   289     cls.add_method('Reset', 
   290                    is_const=True)
   290                    'void', 
   291     ## random-variable.h: static void ns3::RandomVariable::SetRunNumber(uint32_t n) [member function]
   291                    [])
   292     cls.add_method('SetRunNumber', 
   292     ## attribute-list.h: static ns3::AttributeList * ns3::AttributeList::GetGlobal() [member function]
   293                    'void', 
   293     cls.add_method('GetGlobal', 
   294                    [param('uint32_t', 'n')], 
   294                    'ns3::AttributeList *', 
   295                    is_static=True)
   295                    [], 
   296     ## random-variable.h: static void ns3::RandomVariable::UseDevRandom(bool udr=true) [member function]
   296                    is_static=True)
   297     cls.add_method('UseDevRandom', 
   297     ## attribute-list.h: std::string ns3::AttributeList::SerializeToString() const [member function]
   298                    'void', 
   298     cls.add_method('SerializeToString', 
   299                    [param('bool', 'udr', default_value='true')], 
   299                    'std::string', 
   300                    is_static=True)
   300                    [], 
   301     ## random-variable.h: static void ns3::RandomVariable::UseGlobalSeed(uint32_t s0, uint32_t s1, uint32_t s2, uint32_t s3, uint32_t s4, uint32_t s5) [member function]
   301                    is_const=True)
   302     cls.add_method('UseGlobalSeed', 
   302     ## attribute-list.h: bool ns3::AttributeList::DeserializeFromString(std::string value) [member function]
   303                    'void', 
   303     cls.add_method('DeserializeFromString', 
   304                    [param('uint32_t', 's0'), param('uint32_t', 's1'), param('uint32_t', 's2'), param('uint32_t', 's3'), param('uint32_t', 's4'), param('uint32_t', 's5')], 
   304                    'bool', 
   305                    is_static=True)
   305                    [param('std::string', 'value')])
   306     cls.add_output_stream_operator()
   306     return
   307     return
   307 
   308 
   308 def register_Ns3CallbackBase_methods(root_module, cls):
   309 def register_Ns3TriangularVariable_methods(root_module, cls):
   309     ## callback.h: ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [copy constructor]
   310     ## random-variable.h: ns3::TriangularVariable::TriangularVariable(ns3::TriangularVariable const & arg0) [copy constructor]
   310     cls.add_constructor([param('ns3::CallbackBase const &', 'arg0')])
   311     cls.add_constructor([param('ns3::TriangularVariable const &', 'arg0')])
   311     ## callback.h: ns3::CallbackBase::CallbackBase() [constructor]
   312     ## random-variable.h: ns3::TriangularVariable::TriangularVariable() [constructor]
   312     cls.add_constructor([])
   313     cls.add_constructor([])
   313     ## callback.h: ns3::Ptr<ns3::CallbackImplBase> ns3::CallbackBase::GetImpl() const [member function]
   314     ## random-variable.h: ns3::TriangularVariable::TriangularVariable(double s, double l, double mean) [constructor]
   314     cls.add_method('GetImpl', 
   315     cls.add_constructor([param('double', 's'), param('double', 'l'), param('double', 'mean')])
   315                    'ns3::Ptr< ns3::CallbackImplBase >', 
   316     ## random-variable.h: static double ns3::TriangularVariable::GetSingleValue(double s, double l, double mean) [member function]
   316                    [], 
   317     cls.add_method('GetSingleValue', 
   317                    is_const=True)
   318                    'double', 
   318     ## callback.h: ns3::CallbackBase::CallbackBase(ns3::Ptr<ns3::CallbackImplBase> impl) [constructor]
   319                    [param('double', 's'), param('double', 'l'), param('double', 'mean')], 
   319     cls.add_constructor([param('ns3::Ptr< ns3::CallbackImplBase >', 'impl')], 
   320                    is_static=True)
   320                         visibility='protected')
       
   321     return
       
   322 
       
   323 def register_Ns3CallbackImplBase_methods(root_module, cls):
       
   324     ## callback.h: ns3::CallbackImplBase::CallbackImplBase(ns3::CallbackImplBase const & arg0) [copy constructor]
       
   325     cls.add_constructor([param('ns3::CallbackImplBase const &', 'arg0')])
       
   326     ## callback.h: ns3::CallbackImplBase::CallbackImplBase() [constructor]
       
   327     cls.add_constructor([])
       
   328     ## callback.h: bool ns3::CallbackImplBase::IsEqual(ns3::Ptr<ns3::CallbackImplBase const> other) const [member function]
       
   329     cls.add_method('IsEqual', 
       
   330                    'bool', 
       
   331                    [param('ns3::Ptr< ns3::CallbackImplBase const >', 'other')], 
       
   332                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
   333     return
       
   334 
       
   335 def register_Ns3CommandLine_methods(root_module, cls):
       
   336     ## command-line.h: ns3::CommandLine::CommandLine(ns3::CommandLine const & arg0) [copy constructor]
       
   337     cls.add_constructor([param('ns3::CommandLine const &', 'arg0')])
       
   338     ## command-line.h: ns3::CommandLine::CommandLine() [constructor]
       
   339     cls.add_constructor([])
       
   340     return
       
   341 
       
   342 def register_Ns3CriticalSection_methods(root_module, cls):
       
   343     ## system-mutex.h: ns3::CriticalSection::CriticalSection(ns3::CriticalSection const & arg0) [copy constructor]
       
   344     cls.add_constructor([param('ns3::CriticalSection const &', 'arg0')])
       
   345     ## system-mutex.h: ns3::CriticalSection::CriticalSection(ns3::SystemMutex & mutex) [constructor]
       
   346     cls.add_constructor([param('ns3::SystemMutex &', 'mutex')])
   321     return
   347     return
   322 
   348 
   323 def register_Ns3GlobalValue_methods(root_module, cls):
   349 def register_Ns3GlobalValue_methods(root_module, cls):
   324     ## global-value.h: ns3::GlobalValue::GlobalValue(ns3::GlobalValue const & arg0) [copy constructor]
   350     ## global-value.h: ns3::GlobalValue::GlobalValue(ns3::GlobalValue const & arg0) [copy constructor]
   325     cls.add_constructor([param('ns3::GlobalValue const &', 'arg0')])
   351     cls.add_constructor([param('ns3::GlobalValue const &', 'arg0')])
   359                    'bool', 
   385                    'bool', 
   360                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')], 
   386                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')], 
   361                    is_static=True)
   387                    is_static=True)
   362     ## global-value.h: static __gnu_cxx::__normal_iterator<ns3::GlobalValue* const*,std::vector<ns3::GlobalValue*, std::allocator<ns3::GlobalValue*> > > ns3::GlobalValue::Begin() [member function]
   388     ## global-value.h: static __gnu_cxx::__normal_iterator<ns3::GlobalValue* const*,std::vector<ns3::GlobalValue*, std::allocator<ns3::GlobalValue*> > > ns3::GlobalValue::Begin() [member function]
   363     cls.add_method('Begin', 
   389     cls.add_method('Begin', 
   364                    '__gnu_cxx::__normal_iterator< ns3::GlobalValue* const*, std::vector< ns3::GlobalValue* > >', 
   390                    '__gnu_cxx::__normal_iterator< ns3::GlobalValue * const *, std::vector< ns3::GlobalValue * > >', 
   365                    [], 
   391                    [], 
   366                    is_static=True)
   392                    is_static=True)
   367     ## global-value.h: static __gnu_cxx::__normal_iterator<ns3::GlobalValue* const*,std::vector<ns3::GlobalValue*, std::allocator<ns3::GlobalValue*> > > ns3::GlobalValue::End() [member function]
   393     ## global-value.h: static __gnu_cxx::__normal_iterator<ns3::GlobalValue* const*,std::vector<ns3::GlobalValue*, std::allocator<ns3::GlobalValue*> > > ns3::GlobalValue::End() [member function]
   368     cls.add_method('End', 
   394     cls.add_method('End', 
   369                    '__gnu_cxx::__normal_iterator< ns3::GlobalValue* const*, std::vector< ns3::GlobalValue* > >', 
   395                    '__gnu_cxx::__normal_iterator< ns3::GlobalValue * const *, std::vector< ns3::GlobalValue * > >', 
   370                    [], 
   396                    [], 
       
   397                    is_static=True)
       
   398     return
       
   399 
       
   400 def register_Ns3IntToType__0_methods(root_module, cls):
       
   401     ## int-to-type.h: ns3::IntToType<0>::IntToType(ns3::IntToType<0> const & arg0) [copy constructor]
       
   402     cls.add_constructor([param('ns3::IntToType< 0 > const &', 'arg0')])
       
   403     ## int-to-type.h: ns3::IntToType<0>::IntToType() [constructor]
       
   404     cls.add_constructor([])
       
   405     return
       
   406 
       
   407 def register_Ns3IntToType__1_methods(root_module, cls):
       
   408     ## int-to-type.h: ns3::IntToType<1>::IntToType(ns3::IntToType<1> const & arg0) [copy constructor]
       
   409     cls.add_constructor([param('ns3::IntToType< 1 > const &', 'arg0')])
       
   410     ## int-to-type.h: ns3::IntToType<1>::IntToType() [constructor]
       
   411     cls.add_constructor([])
       
   412     return
       
   413 
       
   414 def register_Ns3IntToType__2_methods(root_module, cls):
       
   415     ## int-to-type.h: ns3::IntToType<2>::IntToType(ns3::IntToType<2> const & arg0) [copy constructor]
       
   416     cls.add_constructor([param('ns3::IntToType< 2 > const &', 'arg0')])
       
   417     ## int-to-type.h: ns3::IntToType<2>::IntToType() [constructor]
       
   418     cls.add_constructor([])
       
   419     return
       
   420 
       
   421 def register_Ns3IntToType__3_methods(root_module, cls):
       
   422     ## int-to-type.h: ns3::IntToType<3>::IntToType(ns3::IntToType<3> const & arg0) [copy constructor]
       
   423     cls.add_constructor([param('ns3::IntToType< 3 > const &', 'arg0')])
       
   424     ## int-to-type.h: ns3::IntToType<3>::IntToType() [constructor]
       
   425     cls.add_constructor([])
       
   426     return
       
   427 
       
   428 def register_Ns3IntToType__4_methods(root_module, cls):
       
   429     ## int-to-type.h: ns3::IntToType<4>::IntToType(ns3::IntToType<4> const & arg0) [copy constructor]
       
   430     cls.add_constructor([param('ns3::IntToType< 4 > const &', 'arg0')])
       
   431     ## int-to-type.h: ns3::IntToType<4>::IntToType() [constructor]
       
   432     cls.add_constructor([])
       
   433     return
       
   434 
       
   435 def register_Ns3IntToType__5_methods(root_module, cls):
       
   436     ## int-to-type.h: ns3::IntToType<5>::IntToType(ns3::IntToType<5> const & arg0) [copy constructor]
       
   437     cls.add_constructor([param('ns3::IntToType< 5 > const &', 'arg0')])
       
   438     ## int-to-type.h: ns3::IntToType<5>::IntToType() [constructor]
       
   439     cls.add_constructor([])
       
   440     return
       
   441 
       
   442 def register_Ns3IntToType__6_methods(root_module, cls):
       
   443     ## int-to-type.h: ns3::IntToType<6>::IntToType(ns3::IntToType<6> const & arg0) [copy constructor]
       
   444     cls.add_constructor([param('ns3::IntToType< 6 > const &', 'arg0')])
       
   445     ## int-to-type.h: ns3::IntToType<6>::IntToType() [constructor]
       
   446     cls.add_constructor([])
       
   447     return
       
   448 
       
   449 def register_Ns3ObjectBase_methods(root_module, cls):
       
   450     ## object-base.h: ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [copy constructor]
       
   451     cls.add_constructor([param('ns3::ObjectBase const &', 'arg0')])
       
   452     ## object-base.h: ns3::ObjectBase::ObjectBase() [constructor]
       
   453     cls.add_constructor([])
       
   454     ## object-base.h: static ns3::TypeId ns3::ObjectBase::GetTypeId() [member function]
       
   455     cls.add_method('GetTypeId', 
       
   456                    'ns3::TypeId', 
       
   457                    [], 
       
   458                    is_static=True)
       
   459     ## object-base.h: ns3::TypeId ns3::ObjectBase::GetInstanceTypeId() const [member function]
       
   460     cls.add_method('GetInstanceTypeId', 
       
   461                    'ns3::TypeId', 
       
   462                    [], 
       
   463                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
   464     ## object-base.h: void ns3::ObjectBase::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function]
       
   465     cls.add_method('SetAttribute', 
       
   466                    'void', 
       
   467                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
       
   468     ## object-base.h: bool ns3::ObjectBase::SetAttributeFailSafe(std::string name, ns3::AttributeValue const & value) [member function]
       
   469     cls.add_method('SetAttributeFailSafe', 
       
   470                    'bool', 
       
   471                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
       
   472     ## object-base.h: void ns3::ObjectBase::GetAttribute(std::string name, ns3::AttributeValue & value) const [member function]
       
   473     cls.add_method('GetAttribute', 
       
   474                    'void', 
       
   475                    [param('std::string', 'name'), param('ns3::AttributeValue &', 'value')], 
       
   476                    is_const=True)
       
   477     ## object-base.h: bool ns3::ObjectBase::GetAttributeFailSafe(std::string name, ns3::AttributeValue & attribute) const [member function]
       
   478     cls.add_method('GetAttributeFailSafe', 
       
   479                    'bool', 
       
   480                    [param('std::string', 'name'), param('ns3::AttributeValue &', 'attribute')], 
       
   481                    is_const=True)
       
   482     ## object-base.h: bool ns3::ObjectBase::TraceConnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function]
       
   483     cls.add_method('TraceConnect', 
       
   484                    'bool', 
       
   485                    [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')])
       
   486     ## object-base.h: bool ns3::ObjectBase::TraceConnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]
       
   487     cls.add_method('TraceConnectWithoutContext', 
       
   488                    'bool', 
       
   489                    [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])
       
   490     ## object-base.h: bool ns3::ObjectBase::TraceDisconnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function]
       
   491     cls.add_method('TraceDisconnect', 
       
   492                    'bool', 
       
   493                    [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')])
       
   494     ## object-base.h: bool ns3::ObjectBase::TraceDisconnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]
       
   495     cls.add_method('TraceDisconnectWithoutContext', 
       
   496                    'bool', 
       
   497                    [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])
       
   498     ## object-base.h: void ns3::ObjectBase::NotifyConstructionCompleted() [member function]
       
   499     cls.add_method('NotifyConstructionCompleted', 
       
   500                    'void', 
       
   501                    [], 
       
   502                    visibility='protected', is_virtual=True)
       
   503     ## object-base.h: void ns3::ObjectBase::ConstructSelf(ns3::AttributeList const & attributes) [member function]
       
   504     cls.add_method('ConstructSelf', 
       
   505                    'void', 
       
   506                    [param('ns3::AttributeList const &', 'attributes')], 
       
   507                    visibility='protected')
       
   508     return
       
   509 
       
   510 def register_Ns3ObjectFactory_methods(root_module, cls):
       
   511     cls.add_output_stream_operator()
       
   512     ## object-factory.h: ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [copy constructor]
       
   513     cls.add_constructor([param('ns3::ObjectFactory const &', 'arg0')])
       
   514     ## object-factory.h: ns3::ObjectFactory::ObjectFactory() [constructor]
       
   515     cls.add_constructor([])
       
   516     ## object-factory.h: ns3::Ptr<ns3::Object> ns3::ObjectFactory::Create() const [member function]
       
   517     cls.add_method('Create', 
       
   518                    'ns3::Ptr< ns3::Object >', 
       
   519                    [], 
       
   520                    is_const=True)
       
   521     ## object-factory.h: ns3::TypeId ns3::ObjectFactory::GetTypeId() const [member function]
       
   522     cls.add_method('GetTypeId', 
       
   523                    'ns3::TypeId', 
       
   524                    [], 
       
   525                    is_const=True)
       
   526     ## object-factory.h: void ns3::ObjectFactory::Set(std::string name, ns3::AttributeValue const & value) [member function]
       
   527     cls.add_method('Set', 
       
   528                    'void', 
       
   529                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
       
   530     ## object-factory.h: void ns3::ObjectFactory::SetTypeId(ns3::TypeId tid) [member function]
       
   531     cls.add_method('SetTypeId', 
       
   532                    'void', 
       
   533                    [param('ns3::TypeId', 'tid')])
       
   534     ## object-factory.h: void ns3::ObjectFactory::SetTypeId(char const * tid) [member function]
       
   535     cls.add_method('SetTypeId', 
       
   536                    'void', 
       
   537                    [param('char const *', 'tid')])
       
   538     ## object-factory.h: void ns3::ObjectFactory::SetTypeId(std::string tid) [member function]
       
   539     cls.add_method('SetTypeId', 
       
   540                    'void', 
       
   541                    [param('std::string', 'tid')])
       
   542     return
       
   543 
       
   544 def register_Ns3RandomVariable_methods(root_module, cls):
       
   545     cls.add_output_stream_operator()
       
   546     ## random-variable.h: ns3::RandomVariable::RandomVariable() [constructor]
       
   547     cls.add_constructor([])
       
   548     ## random-variable.h: ns3::RandomVariable::RandomVariable(ns3::RandomVariable const & o) [copy constructor]
       
   549     cls.add_constructor([param('ns3::RandomVariable const &', 'o')])
       
   550     ## random-variable.h: uint32_t ns3::RandomVariable::GetInteger() const [member function]
       
   551     cls.add_method('GetInteger', 
       
   552                    'uint32_t', 
       
   553                    [], 
       
   554                    is_const=True)
       
   555     ## random-variable.h: void ns3::RandomVariable::GetSeed(uint32_t * seed) const [member function]
       
   556     cls.add_method('GetSeed', 
       
   557                    'void', 
       
   558                    [param('uint32_t *', 'seed', direction=2, array_length=6)], 
       
   559                    is_const=True)
       
   560     ## random-variable.h: double ns3::RandomVariable::GetValue() const [member function]
       
   561     cls.add_method('GetValue', 
       
   562                    'double', 
       
   563                    [], 
       
   564                    is_const=True)
       
   565     ## random-variable.h: static void ns3::RandomVariable::SetRunNumber(uint32_t n) [member function]
       
   566     cls.add_method('SetRunNumber', 
       
   567                    'void', 
       
   568                    [param('uint32_t', 'n')], 
       
   569                    is_static=True)
       
   570     ## random-variable.h: static void ns3::RandomVariable::UseDevRandom(bool udr=true) [member function]
       
   571     cls.add_method('UseDevRandom', 
       
   572                    'void', 
       
   573                    [param('bool', 'udr', default_value='true')], 
       
   574                    is_static=True)
       
   575     ## random-variable.h: static void ns3::RandomVariable::UseGlobalSeed(uint32_t s0, uint32_t s1, uint32_t s2, uint32_t s3, uint32_t s4, uint32_t s5) [member function]
       
   576     cls.add_method('UseGlobalSeed', 
       
   577                    'void', 
       
   578                    [param('uint32_t', 's0'), param('uint32_t', 's1'), param('uint32_t', 's2'), param('uint32_t', 's3'), param('uint32_t', 's4'), param('uint32_t', 's5')], 
   371                    is_static=True)
   579                    is_static=True)
   372     return
   580     return
   373 
   581 
   374 def register_Ns3RefCountBase_methods(root_module, cls):
   582 def register_Ns3RefCountBase_methods(root_module, cls):
   375     ## ref-count-base.h: ns3::RefCountBase::RefCountBase() [constructor]
   583     ## ref-count-base.h: ns3::RefCountBase::RefCountBase() [constructor]
   376     cls.add_constructor([])
   584     cls.add_constructor([])
   377     ## ref-count-base.h: ns3::RefCountBase::RefCountBase(ns3::RefCountBase const & o) [copy constructor]
   585     ## ref-count-base.h: ns3::RefCountBase::RefCountBase(ns3::RefCountBase const & o) [copy constructor]
   378     cls.add_constructor([param('ns3::RefCountBase const &', 'o')])
   586     cls.add_constructor([param('ns3::RefCountBase const &', 'o')])
   379     return
   587     return
   380 
   588 
       
   589 def register_Ns3RngStream_methods(root_module, cls):
       
   590     ## rng-stream.h: ns3::RngStream::RngStream() [constructor]
       
   591     cls.add_constructor([])
       
   592     ## rng-stream.h: ns3::RngStream::RngStream(ns3::RngStream const & arg0) [copy constructor]
       
   593     cls.add_constructor([param('ns3::RngStream const &', 'arg0')])
       
   594     ## rng-stream.h: void ns3::RngStream::InitializeStream() [member function]
       
   595     cls.add_method('InitializeStream', 
       
   596                    'void', 
       
   597                    [])
       
   598     ## rng-stream.h: void ns3::RngStream::ResetStartStream() [member function]
       
   599     cls.add_method('ResetStartStream', 
       
   600                    'void', 
       
   601                    [])
       
   602     ## rng-stream.h: void ns3::RngStream::ResetStartSubstream() [member function]
       
   603     cls.add_method('ResetStartSubstream', 
       
   604                    'void', 
       
   605                    [])
       
   606     ## rng-stream.h: void ns3::RngStream::ResetNextSubstream() [member function]
       
   607     cls.add_method('ResetNextSubstream', 
       
   608                    'void', 
       
   609                    [])
       
   610     ## rng-stream.h: void ns3::RngStream::ResetNthSubstream(uint32_t N) [member function]
       
   611     cls.add_method('ResetNthSubstream', 
       
   612                    'void', 
       
   613                    [param('uint32_t', 'N')])
       
   614     ## rng-stream.h: void ns3::RngStream::SetAntithetic(bool a) [member function]
       
   615     cls.add_method('SetAntithetic', 
       
   616                    'void', 
       
   617                    [param('bool', 'a')])
       
   618     ## rng-stream.h: void ns3::RngStream::IncreasedPrecis(bool incp) [member function]
       
   619     cls.add_method('IncreasedPrecis', 
       
   620                    'void', 
       
   621                    [param('bool', 'incp')])
       
   622     ## rng-stream.h: bool ns3::RngStream::SetSeeds(uint32_t const * seed) [member function]
       
   623     cls.add_method('SetSeeds', 
       
   624                    'bool', 
       
   625                    [param('uint32_t const *', 'seed')])
       
   626     ## rng-stream.h: void ns3::RngStream::AdvanceState(int32_t e, int32_t c) [member function]
       
   627     cls.add_method('AdvanceState', 
       
   628                    'void', 
       
   629                    [param('int32_t', 'e'), param('int32_t', 'c')])
       
   630     ## rng-stream.h: void ns3::RngStream::GetState(uint32_t * seed) const [member function]
       
   631     cls.add_method('GetState', 
       
   632                    'void', 
       
   633                    [param('uint32_t *', 'seed')], 
       
   634                    is_const=True)
       
   635     ## rng-stream.h: double ns3::RngStream::RandU01() [member function]
       
   636     cls.add_method('RandU01', 
       
   637                    'double', 
       
   638                    [])
       
   639     ## rng-stream.h: int32_t ns3::RngStream::RandInt(int32_t i, int32_t j) [member function]
       
   640     cls.add_method('RandInt', 
       
   641                    'int32_t', 
       
   642                    [param('int32_t', 'i'), param('int32_t', 'j')])
       
   643     ## rng-stream.h: static bool ns3::RngStream::SetPackageSeed(uint32_t const * seed) [member function]
       
   644     cls.add_method('SetPackageSeed', 
       
   645                    'bool', 
       
   646                    [param('uint32_t const *', 'seed')], 
       
   647                    is_static=True)
       
   648     ## rng-stream.h: static bool ns3::RngStream::CheckSeed(uint32_t const * seed) [member function]
       
   649     cls.add_method('CheckSeed', 
       
   650                    'bool', 
       
   651                    [param('uint32_t const *', 'seed')], 
       
   652                    is_static=True)
       
   653     return
       
   654 
       
   655 def register_Ns3SequentialVariable_methods(root_module, cls):
       
   656     ## random-variable.h: ns3::SequentialVariable::SequentialVariable(ns3::SequentialVariable const & arg0) [copy constructor]
       
   657     cls.add_constructor([param('ns3::SequentialVariable const &', 'arg0')])
       
   658     ## random-variable.h: ns3::SequentialVariable::SequentialVariable(double f, double l, double i=1, uint32_t c=1) [constructor]
       
   659     cls.add_constructor([param('double', 'f'), param('double', 'l'), param('double', 'i', default_value='1'), param('uint32_t', 'c', default_value='1')])
       
   660     ## random-variable.h: ns3::SequentialVariable::SequentialVariable(double f, double l, ns3::RandomVariable const & i, uint32_t c=1) [constructor]
       
   661     cls.add_constructor([param('double', 'f'), param('double', 'l'), param('ns3::RandomVariable const &', 'i'), param('uint32_t', 'c', default_value='1')])
       
   662     return
       
   663 
       
   664 def register_Ns3SystemCondition_methods(root_module, cls):
       
   665     ## system-condition.h: ns3::SystemCondition::SystemCondition(ns3::SystemCondition const & arg0) [copy constructor]
       
   666     cls.add_constructor([param('ns3::SystemCondition const &', 'arg0')])
       
   667     ## system-condition.h: ns3::SystemCondition::SystemCondition() [constructor]
       
   668     cls.add_constructor([])
       
   669     ## system-condition.h: void ns3::SystemCondition::SetCondition(bool condition) [member function]
       
   670     cls.add_method('SetCondition', 
       
   671                    'void', 
       
   672                    [param('bool', 'condition')])
       
   673     ## system-condition.h: bool ns3::SystemCondition::GetCondition() [member function]
       
   674     cls.add_method('GetCondition', 
       
   675                    'bool', 
       
   676                    [])
       
   677     ## system-condition.h: void ns3::SystemCondition::Signal() [member function]
       
   678     cls.add_method('Signal', 
       
   679                    'void', 
       
   680                    [])
       
   681     ## system-condition.h: void ns3::SystemCondition::Broadcast() [member function]
       
   682     cls.add_method('Broadcast', 
       
   683                    'void', 
       
   684                    [])
       
   685     ## system-condition.h: void ns3::SystemCondition::Wait() [member function]
       
   686     cls.add_method('Wait', 
       
   687                    'void', 
       
   688                    [])
       
   689     ## system-condition.h: bool ns3::SystemCondition::TimedWait(uint64_t ns) [member function]
       
   690     cls.add_method('TimedWait', 
       
   691                    'bool', 
       
   692                    [param('uint64_t', 'ns')])
       
   693     return
       
   694 
       
   695 def register_Ns3SystemMutex_methods(root_module, cls):
       
   696     ## system-mutex.h: ns3::SystemMutex::SystemMutex(ns3::SystemMutex const & arg0) [copy constructor]
       
   697     cls.add_constructor([param('ns3::SystemMutex const &', 'arg0')])
       
   698     ## system-mutex.h: ns3::SystemMutex::SystemMutex() [constructor]
       
   699     cls.add_constructor([])
       
   700     ## system-mutex.h: void ns3::SystemMutex::Lock() [member function]
       
   701     cls.add_method('Lock', 
       
   702                    'void', 
       
   703                    [])
       
   704     ## system-mutex.h: void ns3::SystemMutex::Unlock() [member function]
       
   705     cls.add_method('Unlock', 
       
   706                    'void', 
       
   707                    [])
       
   708     return
       
   709 
       
   710 def register_Ns3SystemThread_methods(root_module, cls):
       
   711     ## system-thread.h: ns3::SystemThread::SystemThread(ns3::SystemThread const & arg0) [copy constructor]
       
   712     cls.add_constructor([param('ns3::SystemThread const &', 'arg0')])
       
   713     ## system-thread.h: ns3::SystemThread::SystemThread(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [constructor]
       
   714     cls.add_constructor([param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')])
       
   715     ## system-thread.h: void ns3::SystemThread::Ref() const [member function]
       
   716     cls.add_method('Ref', 
       
   717                    'void', 
       
   718                    [], 
       
   719                    is_const=True)
       
   720     ## system-thread.h: void ns3::SystemThread::Unref() const [member function]
       
   721     cls.add_method('Unref', 
       
   722                    'void', 
       
   723                    [], 
       
   724                    is_const=True)
       
   725     ## system-thread.h: void ns3::SystemThread::Start() [member function]
       
   726     cls.add_method('Start', 
       
   727                    'void', 
       
   728                    [])
       
   729     ## system-thread.h: void ns3::SystemThread::Join() [member function]
       
   730     cls.add_method('Join', 
       
   731                    'void', 
       
   732                    [])
       
   733     return
       
   734 
       
   735 def register_Ns3SystemWallClockMs_methods(root_module, cls):
       
   736     ## system-wall-clock-ms.h: ns3::SystemWallClockMs::SystemWallClockMs(ns3::SystemWallClockMs const & arg0) [copy constructor]
       
   737     cls.add_constructor([param('ns3::SystemWallClockMs const &', 'arg0')])
       
   738     ## system-wall-clock-ms.h: ns3::SystemWallClockMs::SystemWallClockMs() [constructor]
       
   739     cls.add_constructor([])
       
   740     ## system-wall-clock-ms.h: void ns3::SystemWallClockMs::Start() [member function]
       
   741     cls.add_method('Start', 
       
   742                    'void', 
       
   743                    [])
       
   744     ## system-wall-clock-ms.h: long long unsigned int ns3::SystemWallClockMs::End() [member function]
       
   745     cls.add_method('End', 
       
   746                    'long long unsigned int', 
       
   747                    [])
       
   748     return
       
   749 
       
   750 def register_Ns3TraceSourceAccessor_methods(root_module, cls):
       
   751     ## trace-source-accessor.h: ns3::TraceSourceAccessor::TraceSourceAccessor(ns3::TraceSourceAccessor const & arg0) [copy constructor]
       
   752     cls.add_constructor([param('ns3::TraceSourceAccessor const &', 'arg0')])
       
   753     ## trace-source-accessor.h: ns3::TraceSourceAccessor::TraceSourceAccessor() [constructor]
       
   754     cls.add_constructor([])
       
   755     ## trace-source-accessor.h: void ns3::TraceSourceAccessor::Ref() const [member function]
       
   756     cls.add_method('Ref', 
       
   757                    'void', 
       
   758                    [], 
       
   759                    is_const=True)
       
   760     ## trace-source-accessor.h: void ns3::TraceSourceAccessor::Unref() const [member function]
       
   761     cls.add_method('Unref', 
       
   762                    'void', 
       
   763                    [], 
       
   764                    is_const=True)
       
   765     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::ConnectWithoutContext(ns3::ObjectBase * obj, ns3::CallbackBase const & cb) const [member function]
       
   766     cls.add_method('ConnectWithoutContext', 
       
   767                    'bool', 
       
   768                    [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase const &', 'cb')], 
       
   769                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
   770     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::Connect(ns3::ObjectBase * obj, std::string context, ns3::CallbackBase const & cb) const [member function]
       
   771     cls.add_method('Connect', 
       
   772                    'bool', 
       
   773                    [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')], 
       
   774                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
   775     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::DisconnectWithoutContext(ns3::ObjectBase * obj, ns3::CallbackBase const & cb) const [member function]
       
   776     cls.add_method('DisconnectWithoutContext', 
       
   777                    'bool', 
       
   778                    [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase const &', 'cb')], 
       
   779                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
   780     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::Disconnect(ns3::ObjectBase * obj, std::string context, ns3::CallbackBase const & cb) const [member function]
       
   781     cls.add_method('Disconnect', 
       
   782                    'bool', 
       
   783                    [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')], 
       
   784                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
   785     return
       
   786 
       
   787 def register_Ns3TriangularVariable_methods(root_module, cls):
       
   788     ## random-variable.h: ns3::TriangularVariable::TriangularVariable(ns3::TriangularVariable const & arg0) [copy constructor]
       
   789     cls.add_constructor([param('ns3::TriangularVariable const &', 'arg0')])
       
   790     ## random-variable.h: ns3::TriangularVariable::TriangularVariable() [constructor]
       
   791     cls.add_constructor([])
       
   792     ## random-variable.h: ns3::TriangularVariable::TriangularVariable(double s, double l, double mean) [constructor]
       
   793     cls.add_constructor([param('double', 's'), param('double', 'l'), param('double', 'mean')])
       
   794     ## random-variable.h: static double ns3::TriangularVariable::GetSingleValue(double s, double l, double mean) [member function]
       
   795     cls.add_method('GetSingleValue', 
       
   796                    'double', 
       
   797                    [param('double', 's'), param('double', 'l'), param('double', 'mean')], 
       
   798                    is_static=True)
       
   799     return
       
   800 
   381 def register_Ns3TypeId_methods(root_module, cls):
   801 def register_Ns3TypeId_methods(root_module, cls):
       
   802     cls.add_binary_comparison_operator('!=')
       
   803     cls.add_binary_comparison_operator('<')
       
   804     cls.add_output_stream_operator()
       
   805     cls.add_binary_comparison_operator('==')
   382     ## type-id.h: ns3::TypeId::TypeId(ns3::TypeId const & arg0) [copy constructor]
   806     ## type-id.h: ns3::TypeId::TypeId(ns3::TypeId const & arg0) [copy constructor]
   383     cls.add_constructor([param('ns3::TypeId const &', 'arg0')])
   807     cls.add_constructor([param('ns3::TypeId const &', 'arg0')])
   384     ## type-id.h: ns3::TypeId::TypeId(char const * name) [constructor]
   808     ## type-id.h: ns3::TypeId::TypeId(char const * name) [constructor]
   385     cls.add_constructor([param('char const *', 'name')])
   809     cls.add_constructor([param('char const *', 'name')])
   386     ## type-id.h: ns3::TypeId::TypeId() [constructor]
   810     ## type-id.h: ns3::TypeId::TypeId() [constructor]
   437                    'std::string', 
   861                    'std::string', 
   438                    [param('uint32_t', 'i')], 
   862                    [param('uint32_t', 'i')], 
   439                    is_const=True)
   863                    is_const=True)
   440     ## type-id.h: ns3::Callback<ns3::ObjectBase*,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ns3::TypeId::GetConstructor() const [member function]
   864     ## type-id.h: ns3::Callback<ns3::ObjectBase*,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> ns3::TypeId::GetConstructor() const [member function]
   441     cls.add_method('GetConstructor', 
   865     cls.add_method('GetConstructor', 
   442                    'ns3::Callback< ns3::ObjectBase*, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 
   866                    'ns3::Callback< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 
   443                    [], 
   867                    [], 
   444                    is_const=True)
   868                    is_const=True)
   445     ## type-id.h: std::string ns3::TypeId::GetGroupName() const [member function]
   869     ## type-id.h: std::string ns3::TypeId::GetGroupName() const [member function]
   446     cls.add_method('GetGroupName', 
   870     cls.add_method('GetGroupName', 
   447                    'std::string', 
   871                    'std::string', 
   546                    [param('ns3::TypeId', 'tid')])
   970                    [param('ns3::TypeId', 'tid')])
   547     ## type-id.h: void ns3::TypeId::SetUid(uint16_t tid) [member function]
   971     ## type-id.h: void ns3::TypeId::SetUid(uint16_t tid) [member function]
   548     cls.add_method('SetUid', 
   972     cls.add_method('SetUid', 
   549                    'void', 
   973                    'void', 
   550                    [param('uint16_t', 'tid')])
   974                    [param('uint16_t', 'tid')])
   551     cls.add_output_stream_operator()
       
   552     return
   975     return
   553 
   976 
   554 def register_Ns3TypeIdAttributeInfo_methods(root_module, cls):
   977 def register_Ns3TypeIdAttributeInfo_methods(root_module, cls):
   555     ## type-id.h: ns3::TypeId::AttributeInfo::accessor [variable]
   978     ## type-id.h: ns3::TypeId::AttributeInfo::accessor [variable]
   556     cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::AttributeAccessor const >', is_const=False)
   979     cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::AttributeAccessor const >', is_const=False)
   564     cls.add_constructor([param('ns3::TypeId::AttributeInfo const &', 'arg0')])
   987     cls.add_constructor([param('ns3::TypeId::AttributeInfo const &', 'arg0')])
   565     ## type-id.h: ns3::TypeId::AttributeInfo::AttributeInfo() [constructor]
   988     ## type-id.h: ns3::TypeId::AttributeInfo::AttributeInfo() [constructor]
   566     cls.add_constructor([])
   989     cls.add_constructor([])
   567     return
   990     return
   568 
   991 
   569 def register_Ns3SystemWallClockMs_methods(root_module, cls):
   992 def register_Ns3UniformVariable_methods(root_module, cls):
   570     ## system-wall-clock-ms.h: ns3::SystemWallClockMs::SystemWallClockMs(ns3::SystemWallClockMs const & arg0) [copy constructor]
   993     ## random-variable.h: ns3::UniformVariable::UniformVariable(ns3::UniformVariable const & arg0) [copy constructor]
   571     cls.add_constructor([param('ns3::SystemWallClockMs const &', 'arg0')])
   994     cls.add_constructor([param('ns3::UniformVariable const &', 'arg0')])
   572     ## system-wall-clock-ms.h: ns3::SystemWallClockMs::SystemWallClockMs() [constructor]
   995     ## random-variable.h: ns3::UniformVariable::UniformVariable() [constructor]
   573     cls.add_constructor([])
   996     cls.add_constructor([])
   574     ## system-wall-clock-ms.h: void ns3::SystemWallClockMs::Start() [member function]
   997     ## random-variable.h: ns3::UniformVariable::UniformVariable(double s, double l) [constructor]
   575     cls.add_method('Start', 
   998     cls.add_constructor([param('double', 's'), param('double', 'l')])
   576                    'void', 
   999     ## random-variable.h: static double ns3::UniformVariable::GetSingleValue(double s, double l) [member function]
   577                    [])
  1000     cls.add_method('GetSingleValue', 
   578     ## system-wall-clock-ms.h: long long unsigned int ns3::SystemWallClockMs::End() [member function]
  1001                    'double', 
   579     cls.add_method('End', 
  1002                    [param('double', 's'), param('double', 'l')], 
   580                    'long long unsigned int', 
  1003                    is_static=True)
   581                    [])
  1004     return
   582     return
  1005 
   583 
  1006 def register_Ns3WeibullVariable_methods(root_module, cls):
   584 def register_Ns3CallbackImplBase_methods(root_module, cls):
  1007     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(ns3::WeibullVariable const & arg0) [copy constructor]
   585     ## callback.h: ns3::CallbackImplBase::CallbackImplBase(ns3::CallbackImplBase const & arg0) [copy constructor]
  1008     cls.add_constructor([param('ns3::WeibullVariable const &', 'arg0')])
   586     cls.add_constructor([param('ns3::CallbackImplBase const &', 'arg0')])
  1009     ## random-variable.h: ns3::WeibullVariable::WeibullVariable() [constructor]
   587     ## callback.h: ns3::CallbackImplBase::CallbackImplBase() [constructor]
  1010     cls.add_constructor([])
   588     cls.add_constructor([])
  1011     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(double m) [constructor]
   589     ## callback.h: bool ns3::CallbackImplBase::IsEqual(ns3::Ptr<ns3::CallbackImplBase const> other) const [member function]
  1012     cls.add_constructor([param('double', 'm')])
   590     cls.add_method('IsEqual', 
  1013     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(double m, double s) [constructor]
   591                    'bool', 
  1014     cls.add_constructor([param('double', 'm'), param('double', 's')])
   592                    [param('ns3::Ptr< ns3::CallbackImplBase const >', 'other')], 
  1015     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(double m, double s, double b) [constructor]
       
  1016     cls.add_constructor([param('double', 'm'), param('double', 's'), param('double', 'b')])
       
  1017     ## random-variable.h: static double ns3::WeibullVariable::GetSingleValue(double m, double s, double b=0) [member function]
       
  1018     cls.add_method('GetSingleValue', 
       
  1019                    'double', 
       
  1020                    [param('double', 'm'), param('double', 's'), param('double', 'b', default_value='0')], 
       
  1021                    is_static=True)
       
  1022     return
       
  1023 
       
  1024 def register_Ns3Empty_methods(root_module, cls):
       
  1025     ## empty.h: ns3::empty::empty(ns3::empty const & arg0) [copy constructor]
       
  1026     cls.add_constructor([param('ns3::empty const &', 'arg0')])
       
  1027     ## empty.h: ns3::empty::empty() [constructor]
       
  1028     cls.add_constructor([])
       
  1029     return
       
  1030 
       
  1031 def register_Ns3AttributeAccessor_methods(root_module, cls):
       
  1032     ## attribute.h: ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [copy constructor]
       
  1033     cls.add_constructor([param('ns3::AttributeAccessor const &', 'arg0')])
       
  1034     ## attribute.h: ns3::AttributeAccessor::AttributeAccessor() [constructor]
       
  1035     cls.add_constructor([])
       
  1036     ## attribute.h: bool ns3::AttributeAccessor::Set(ns3::ObjectBase * object, ns3::AttributeValue const & value) const [member function]
       
  1037     cls.add_method('Set', 
       
  1038                    'bool', 
       
  1039                    [param('ns3::ObjectBase *', 'object', transfer_ownership=False), param('ns3::AttributeValue const &', 'value')], 
   593                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1040                    is_pure_virtual=True, is_const=True, is_virtual=True)
   594     return
  1041     ## attribute.h: bool ns3::AttributeAccessor::Get(ns3::ObjectBase const * object, ns3::AttributeValue & attribute) const [member function]
   595 
  1042     cls.add_method('Get', 
   596 def register_Ns3CriticalSection_methods(root_module, cls):
  1043                    'bool', 
   597     ## system-mutex.h: ns3::CriticalSection::CriticalSection(ns3::CriticalSection const & arg0) [copy constructor]
  1044                    [param('ns3::ObjectBase const *', 'object'), param('ns3::AttributeValue &', 'attribute')], 
   598     cls.add_constructor([param('ns3::CriticalSection const &', 'arg0')])
       
   599     ## system-mutex.h: ns3::CriticalSection::CriticalSection(ns3::SystemMutex & mutex) [constructor]
       
   600     cls.add_constructor([param('ns3::SystemMutex &', 'mutex')])
       
   601     return
       
   602 
       
   603 def register_Ns3TraceSourceAccessor_methods(root_module, cls):
       
   604     ## trace-source-accessor.h: ns3::TraceSourceAccessor::TraceSourceAccessor(ns3::TraceSourceAccessor const & arg0) [copy constructor]
       
   605     cls.add_constructor([param('ns3::TraceSourceAccessor const &', 'arg0')])
       
   606     ## trace-source-accessor.h: ns3::TraceSourceAccessor::TraceSourceAccessor() [constructor]
       
   607     cls.add_constructor([])
       
   608     ## trace-source-accessor.h: void ns3::TraceSourceAccessor::Ref() const [member function]
       
   609     cls.add_method('Ref', 
       
   610                    'void', 
       
   611                    [], 
       
   612                    is_const=True)
       
   613     ## trace-source-accessor.h: void ns3::TraceSourceAccessor::Unref() const [member function]
       
   614     cls.add_method('Unref', 
       
   615                    'void', 
       
   616                    [], 
       
   617                    is_const=True)
       
   618     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::ConnectWithoutContext(ns3::ObjectBase * obj, ns3::CallbackBase const & cb) const [member function]
       
   619     cls.add_method('ConnectWithoutContext', 
       
   620                    'bool', 
       
   621                    [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase const &', 'cb')], 
       
   622                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1045                    is_pure_virtual=True, is_const=True, is_virtual=True)
   623     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::Connect(ns3::ObjectBase * obj, std::string context, ns3::CallbackBase const & cb) const [member function]
  1046     ## attribute.h: bool ns3::AttributeAccessor::HasGetter() const [member function]
   624     cls.add_method('Connect', 
  1047     cls.add_method('HasGetter', 
   625                    'bool', 
  1048                    'bool', 
   626                    [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')], 
  1049                    [], 
   627                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1050                    is_pure_virtual=True, is_const=True, is_virtual=True)
   628     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::DisconnectWithoutContext(ns3::ObjectBase * obj, ns3::CallbackBase const & cb) const [member function]
  1051     ## attribute.h: bool ns3::AttributeAccessor::HasSetter() const [member function]
   629     cls.add_method('DisconnectWithoutContext', 
  1052     cls.add_method('HasSetter', 
   630                    'bool', 
  1053                    'bool', 
   631                    [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase const &', 'cb')], 
  1054                    [], 
   632                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
   633     ## trace-source-accessor.h: bool ns3::TraceSourceAccessor::Disconnect(ns3::ObjectBase * obj, std::string context, ns3::CallbackBase const & cb) const [member function]
       
   634     cls.add_method('Disconnect', 
       
   635                    'bool', 
       
   636                    [param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')], 
       
   637                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1055                    is_pure_virtual=True, is_const=True, is_virtual=True)
   638     return
  1056     return
   639 
  1057 
   640 def register_Ns3AttributeChecker_methods(root_module, cls):
  1058 def register_Ns3AttributeChecker_methods(root_module, cls):
   641     ## attribute.h: ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [copy constructor]
  1059     ## attribute.h: ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [copy constructor]
   672                    'bool', 
  1090                    'bool', 
   673                    [param('ns3::AttributeValue const &', 'source'), param('ns3::AttributeValue &', 'destination')], 
  1091                    [param('ns3::AttributeValue const &', 'source'), param('ns3::AttributeValue &', 'destination')], 
   674                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1092                    is_pure_virtual=True, is_const=True, is_virtual=True)
   675     return
  1093     return
   676 
  1094 
   677 def register_Ns3RandomVariableChecker_methods(root_module, cls):
  1095 def register_Ns3AttributeValue_methods(root_module, cls):
   678     ## random-variable.h: ns3::RandomVariableChecker::RandomVariableChecker(ns3::RandomVariableChecker const & arg0) [copy constructor]
  1096     ## attribute.h: ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [copy constructor]
   679     cls.add_constructor([param('ns3::RandomVariableChecker const &', 'arg0')])
  1097     cls.add_constructor([param('ns3::AttributeValue const &', 'arg0')])
   680     ## random-variable.h: ns3::RandomVariableChecker::RandomVariableChecker() [constructor]
  1098     ## attribute.h: ns3::AttributeValue::AttributeValue() [constructor]
   681     cls.add_constructor([])
  1099     cls.add_constructor([])
   682     return
  1100     ## attribute.h: ns3::Ptr<ns3::AttributeValue> ns3::AttributeValue::Copy() const [member function]
   683 
  1101     cls.add_method('Copy', 
   684 def register_Ns3SystemMutex_methods(root_module, cls):
  1102                    'ns3::Ptr< ns3::AttributeValue >', 
   685     ## system-mutex.h: ns3::SystemMutex::SystemMutex(ns3::SystemMutex const & arg0) [copy constructor]
  1103                    [], 
   686     cls.add_constructor([param('ns3::SystemMutex const &', 'arg0')])
  1104                    is_pure_virtual=True, is_const=True, is_virtual=True)
   687     ## system-mutex.h: ns3::SystemMutex::SystemMutex() [constructor]
  1105     ## attribute.h: std::string ns3::AttributeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
   688     cls.add_constructor([])
  1106     cls.add_method('SerializeToString', 
   689     ## system-mutex.h: void ns3::SystemMutex::Lock() [member function]
  1107                    'std::string', 
   690     cls.add_method('Lock', 
  1108                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
   691                    'void', 
  1109                    is_pure_virtual=True, is_const=True, is_virtual=True)
   692                    [])
  1110     ## attribute.h: bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   693     ## system-mutex.h: void ns3::SystemMutex::Unlock() [member function]
  1111     cls.add_method('DeserializeFromString', 
   694     cls.add_method('Unlock', 
  1112                    'bool', 
   695                    'void', 
  1113                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
   696                    [])
  1114                    is_pure_virtual=True, is_virtual=True)
       
  1115     return
       
  1116 
       
  1117 def register_Ns3BooleanChecker_methods(root_module, cls):
       
  1118     ## boolean.h: ns3::BooleanChecker::BooleanChecker(ns3::BooleanChecker const & arg0) [copy constructor]
       
  1119     cls.add_constructor([param('ns3::BooleanChecker const &', 'arg0')])
       
  1120     ## boolean.h: ns3::BooleanChecker::BooleanChecker() [constructor]
       
  1121     cls.add_constructor([])
       
  1122     return
       
  1123 
       
  1124 def register_Ns3BooleanValue_methods(root_module, cls):
       
  1125     cls.add_output_stream_operator()
       
  1126     ## boolean.h: ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [copy constructor]
       
  1127     cls.add_constructor([param('ns3::BooleanValue const &', 'arg0')])
       
  1128     ## boolean.h: ns3::BooleanValue::BooleanValue() [constructor]
       
  1129     cls.add_constructor([])
       
  1130     ## boolean.h: ns3::BooleanValue::BooleanValue(bool value) [constructor]
       
  1131     cls.add_constructor([param('bool', 'value')])
       
  1132     ## boolean.h: ns3::Ptr<ns3::AttributeValue> ns3::BooleanValue::Copy() const [member function]
       
  1133     cls.add_method('Copy', 
       
  1134                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1135                    [], 
       
  1136                    is_const=True, is_virtual=True)
       
  1137     ## boolean.h: bool ns3::BooleanValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
       
  1138     cls.add_method('DeserializeFromString', 
       
  1139                    'bool', 
       
  1140                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1141                    is_virtual=True)
       
  1142     ## boolean.h: bool ns3::BooleanValue::Get() const [member function]
       
  1143     cls.add_method('Get', 
       
  1144                    'bool', 
       
  1145                    [], 
       
  1146                    is_const=True)
       
  1147     ## boolean.h: std::string ns3::BooleanValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
       
  1148     cls.add_method('SerializeToString', 
       
  1149                    'std::string', 
       
  1150                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1151                    is_const=True, is_virtual=True)
       
  1152     ## boolean.h: void ns3::BooleanValue::Set(bool value) [member function]
       
  1153     cls.add_method('Set', 
       
  1154                    'void', 
       
  1155                    [param('bool', 'value')])
       
  1156     return
       
  1157 
       
  1158 def register_Ns3ConstantVariable_methods(root_module, cls):
       
  1159     ## random-variable.h: ns3::ConstantVariable::ConstantVariable(ns3::ConstantVariable const & arg0) [copy constructor]
       
  1160     cls.add_constructor([param('ns3::ConstantVariable const &', 'arg0')])
       
  1161     ## random-variable.h: ns3::ConstantVariable::ConstantVariable() [constructor]
       
  1162     cls.add_constructor([])
       
  1163     ## random-variable.h: ns3::ConstantVariable::ConstantVariable(double c) [constructor]
       
  1164     cls.add_constructor([param('double', 'c')])
       
  1165     ## random-variable.h: void ns3::ConstantVariable::SetConstant(double c) [member function]
       
  1166     cls.add_method('SetConstant', 
       
  1167                    'void', 
       
  1168                    [param('double', 'c')])
       
  1169     return
       
  1170 
       
  1171 def register_Ns3DeterministicVariable_methods(root_module, cls):
       
  1172     ## random-variable.h: ns3::DeterministicVariable::DeterministicVariable(ns3::DeterministicVariable const & arg0) [copy constructor]
       
  1173     cls.add_constructor([param('ns3::DeterministicVariable const &', 'arg0')])
       
  1174     ## random-variable.h: ns3::DeterministicVariable::DeterministicVariable(double * d, uint32_t c) [constructor]
       
  1175     cls.add_constructor([param('double *', 'd'), param('uint32_t', 'c')])
       
  1176     return
       
  1177 
       
  1178 def register_Ns3DoubleValue_methods(root_module, cls):
       
  1179     ## double.h: ns3::DoubleValue::DoubleValue(ns3::DoubleValue const & arg0) [copy constructor]
       
  1180     cls.add_constructor([param('ns3::DoubleValue const &', 'arg0')])
       
  1181     ## double.h: ns3::DoubleValue::DoubleValue() [constructor]
       
  1182     cls.add_constructor([])
       
  1183     ## double.h: ns3::DoubleValue::DoubleValue(double const & value) [constructor]
       
  1184     cls.add_constructor([param('double const &', 'value')])
       
  1185     ## double.h: void ns3::DoubleValue::Set(double const & value) [member function]
       
  1186     cls.add_method('Set', 
       
  1187                    'void', 
       
  1188                    [param('double const &', 'value')])
       
  1189     ## double.h: double ns3::DoubleValue::Get() const [member function]
       
  1190     cls.add_method('Get', 
       
  1191                    'double', 
       
  1192                    [], 
       
  1193                    is_const=True)
       
  1194     ## double.h: ns3::Ptr<ns3::AttributeValue> ns3::DoubleValue::Copy() const [member function]
       
  1195     cls.add_method('Copy', 
       
  1196                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1197                    [], 
       
  1198                    is_const=True, is_virtual=True)
       
  1199     ## double.h: std::string ns3::DoubleValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
       
  1200     cls.add_method('SerializeToString', 
       
  1201                    'std::string', 
       
  1202                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1203                    is_const=True, is_virtual=True)
       
  1204     ## double.h: bool ns3::DoubleValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
       
  1205     cls.add_method('DeserializeFromString', 
       
  1206                    'bool', 
       
  1207                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1208                    is_virtual=True)
       
  1209     return
       
  1210 
       
  1211 def register_Ns3EmpiricalVariable_methods(root_module, cls):
       
  1212     ## random-variable.h: ns3::EmpiricalVariable::EmpiricalVariable(ns3::EmpiricalVariable const & arg0) [copy constructor]
       
  1213     cls.add_constructor([param('ns3::EmpiricalVariable const &', 'arg0')])
       
  1214     ## random-variable.h: ns3::EmpiricalVariable::EmpiricalVariable() [constructor]
       
  1215     cls.add_constructor([])
       
  1216     ## random-variable.h: void ns3::EmpiricalVariable::CDF(double v, double c) [member function]
       
  1217     cls.add_method('CDF', 
       
  1218                    'void', 
       
  1219                    [param('double', 'v'), param('double', 'c')])
       
  1220     return
       
  1221 
       
  1222 def register_Ns3EmptyAttributeValue_methods(root_module, cls):
       
  1223     ## attribute.h: ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [copy constructor]
       
  1224     cls.add_constructor([param('ns3::EmptyAttributeValue const &', 'arg0')])
       
  1225     ## attribute.h: ns3::EmptyAttributeValue::EmptyAttributeValue() [constructor]
       
  1226     cls.add_constructor([])
       
  1227     ## attribute.h: ns3::Ptr<ns3::AttributeValue> ns3::EmptyAttributeValue::Copy() const [member function]
       
  1228     cls.add_method('Copy', 
       
  1229                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1230                    [], 
       
  1231                    is_const=True, visibility='private', is_virtual=True)
       
  1232     ## attribute.h: std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
       
  1233     cls.add_method('SerializeToString', 
       
  1234                    'std::string', 
       
  1235                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1236                    is_const=True, visibility='private', is_virtual=True)
       
  1237     ## attribute.h: bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
       
  1238     cls.add_method('DeserializeFromString', 
       
  1239                    'bool', 
       
  1240                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1241                    visibility='private', is_virtual=True)
       
  1242     return
       
  1243 
       
  1244 def register_Ns3EnumChecker_methods(root_module, cls):
       
  1245     ## enum.h: ns3::EnumChecker::EnumChecker(ns3::EnumChecker const & arg0) [copy constructor]
       
  1246     cls.add_constructor([param('ns3::EnumChecker const &', 'arg0')])
       
  1247     ## enum.h: ns3::EnumChecker::EnumChecker() [constructor]
       
  1248     cls.add_constructor([])
       
  1249     ## enum.h: void ns3::EnumChecker::AddDefault(int v, std::string name) [member function]
       
  1250     cls.add_method('AddDefault', 
       
  1251                    'void', 
       
  1252                    [param('int', 'v'), param('std::string', 'name')])
       
  1253     ## enum.h: void ns3::EnumChecker::Add(int v, std::string name) [member function]
       
  1254     cls.add_method('Add', 
       
  1255                    'void', 
       
  1256                    [param('int', 'v'), param('std::string', 'name')])
       
  1257     ## enum.h: bool ns3::EnumChecker::Check(ns3::AttributeValue const & value) const [member function]
       
  1258     cls.add_method('Check', 
       
  1259                    'bool', 
       
  1260                    [param('ns3::AttributeValue const &', 'value')], 
       
  1261                    is_const=True, is_virtual=True)
       
  1262     ## enum.h: std::string ns3::EnumChecker::GetValueTypeName() const [member function]
       
  1263     cls.add_method('GetValueTypeName', 
       
  1264                    'std::string', 
       
  1265                    [], 
       
  1266                    is_const=True, is_virtual=True)
       
  1267     ## enum.h: bool ns3::EnumChecker::HasUnderlyingTypeInformation() const [member function]
       
  1268     cls.add_method('HasUnderlyingTypeInformation', 
       
  1269                    'bool', 
       
  1270                    [], 
       
  1271                    is_const=True, is_virtual=True)
       
  1272     ## enum.h: std::string ns3::EnumChecker::GetUnderlyingTypeInformation() const [member function]
       
  1273     cls.add_method('GetUnderlyingTypeInformation', 
       
  1274                    'std::string', 
       
  1275                    [], 
       
  1276                    is_const=True, is_virtual=True)
       
  1277     ## enum.h: ns3::Ptr<ns3::AttributeValue> ns3::EnumChecker::Create() const [member function]
       
  1278     cls.add_method('Create', 
       
  1279                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1280                    [], 
       
  1281                    is_const=True, is_virtual=True)
       
  1282     ## enum.h: bool ns3::EnumChecker::Copy(ns3::AttributeValue const & src, ns3::AttributeValue & dst) const [member function]
       
  1283     cls.add_method('Copy', 
       
  1284                    'bool', 
       
  1285                    [param('ns3::AttributeValue const &', 'src'), param('ns3::AttributeValue &', 'dst')], 
       
  1286                    is_const=True, is_virtual=True)
       
  1287     return
       
  1288 
       
  1289 def register_Ns3EnumValue_methods(root_module, cls):
       
  1290     ## enum.h: ns3::EnumValue::EnumValue(ns3::EnumValue const & arg0) [copy constructor]
       
  1291     cls.add_constructor([param('ns3::EnumValue const &', 'arg0')])
       
  1292     ## enum.h: ns3::EnumValue::EnumValue() [constructor]
       
  1293     cls.add_constructor([])
       
  1294     ## enum.h: ns3::EnumValue::EnumValue(int v) [constructor]
       
  1295     cls.add_constructor([param('int', 'v')])
       
  1296     ## enum.h: void ns3::EnumValue::Set(int v) [member function]
       
  1297     cls.add_method('Set', 
       
  1298                    'void', 
       
  1299                    [param('int', 'v')])
       
  1300     ## enum.h: int ns3::EnumValue::Get() const [member function]
       
  1301     cls.add_method('Get', 
       
  1302                    'int', 
       
  1303                    [], 
       
  1304                    is_const=True)
       
  1305     ## enum.h: ns3::Ptr<ns3::AttributeValue> ns3::EnumValue::Copy() const [member function]
       
  1306     cls.add_method('Copy', 
       
  1307                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1308                    [], 
       
  1309                    is_const=True, is_virtual=True)
       
  1310     ## enum.h: std::string ns3::EnumValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
       
  1311     cls.add_method('SerializeToString', 
       
  1312                    'std::string', 
       
  1313                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1314                    is_const=True, is_virtual=True)
       
  1315     ## enum.h: bool ns3::EnumValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
       
  1316     cls.add_method('DeserializeFromString', 
       
  1317                    'bool', 
       
  1318                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1319                    is_virtual=True)
       
  1320     return
       
  1321 
       
  1322 def register_Ns3ExponentialVariable_methods(root_module, cls):
       
  1323     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable(ns3::ExponentialVariable const & arg0) [copy constructor]
       
  1324     cls.add_constructor([param('ns3::ExponentialVariable const &', 'arg0')])
       
  1325     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable() [constructor]
       
  1326     cls.add_constructor([])
       
  1327     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable(double m) [constructor]
       
  1328     cls.add_constructor([param('double', 'm')])
       
  1329     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable(double m, double b) [constructor]
       
  1330     cls.add_constructor([param('double', 'm'), param('double', 'b')])
       
  1331     ## random-variable.h: static double ns3::ExponentialVariable::GetSingleValue(double m, double b=0) [member function]
       
  1332     cls.add_method('GetSingleValue', 
       
  1333                    'double', 
       
  1334                    [param('double', 'm'), param('double', 'b', default_value='0')], 
       
  1335                    is_static=True)
       
  1336     return
       
  1337 
       
  1338 def register_Ns3IntEmpiricalVariable_methods(root_module, cls):
       
  1339     ## random-variable.h: ns3::IntEmpiricalVariable::IntEmpiricalVariable(ns3::IntEmpiricalVariable const & arg0) [copy constructor]
       
  1340     cls.add_constructor([param('ns3::IntEmpiricalVariable const &', 'arg0')])
       
  1341     ## random-variable.h: ns3::IntEmpiricalVariable::IntEmpiricalVariable() [constructor]
       
  1342     cls.add_constructor([])
       
  1343     return
       
  1344 
       
  1345 def register_Ns3IntegerValue_methods(root_module, cls):
       
  1346     ## integer.h: ns3::IntegerValue::IntegerValue(ns3::IntegerValue const & arg0) [copy constructor]
       
  1347     cls.add_constructor([param('ns3::IntegerValue const &', 'arg0')])
       
  1348     ## integer.h: ns3::IntegerValue::IntegerValue() [constructor]
       
  1349     cls.add_constructor([])
       
  1350     ## integer.h: ns3::IntegerValue::IntegerValue(int64_t const & value) [constructor]
       
  1351     cls.add_constructor([param('int64_t const &', 'value')])
       
  1352     ## integer.h: void ns3::IntegerValue::Set(int64_t const & value) [member function]
       
  1353     cls.add_method('Set', 
       
  1354                    'void', 
       
  1355                    [param('int64_t const &', 'value')])
       
  1356     ## integer.h: int64_t ns3::IntegerValue::Get() const [member function]
       
  1357     cls.add_method('Get', 
       
  1358                    'int64_t', 
       
  1359                    [], 
       
  1360                    is_const=True)
       
  1361     ## integer.h: ns3::Ptr<ns3::AttributeValue> ns3::IntegerValue::Copy() const [member function]
       
  1362     cls.add_method('Copy', 
       
  1363                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1364                    [], 
       
  1365                    is_const=True, is_virtual=True)
       
  1366     ## integer.h: std::string ns3::IntegerValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
       
  1367     cls.add_method('SerializeToString', 
       
  1368                    'std::string', 
       
  1369                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1370                    is_const=True, is_virtual=True)
       
  1371     ## integer.h: bool ns3::IntegerValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
       
  1372     cls.add_method('DeserializeFromString', 
       
  1373                    'bool', 
       
  1374                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1375                    is_virtual=True)
       
  1376     return
       
  1377 
       
  1378 def register_Ns3LogNormalVariable_methods(root_module, cls):
       
  1379     ## random-variable.h: ns3::LogNormalVariable::LogNormalVariable(ns3::LogNormalVariable const & arg0) [copy constructor]
       
  1380     cls.add_constructor([param('ns3::LogNormalVariable const &', 'arg0')])
       
  1381     ## random-variable.h: ns3::LogNormalVariable::LogNormalVariable(double mu, double sigma) [constructor]
       
  1382     cls.add_constructor([param('double', 'mu'), param('double', 'sigma')])
       
  1383     ## random-variable.h: static double ns3::LogNormalVariable::GetSingleValue(double mu, double sigma) [member function]
       
  1384     cls.add_method('GetSingleValue', 
       
  1385                    'double', 
       
  1386                    [param('double', 'mu'), param('double', 'sigma')], 
       
  1387                    is_static=True)
   697     return
  1388     return
   698 
  1389 
   699 def register_Ns3NormalVariable_methods(root_module, cls):
  1390 def register_Ns3NormalVariable_methods(root_module, cls):
   700     ## random-variable.h: ns3::NormalVariable::NormalVariable(ns3::NormalVariable const & arg0) [copy constructor]
  1391     ## random-variable.h: ns3::NormalVariable::NormalVariable(ns3::NormalVariable const & arg0) [copy constructor]
   701     cls.add_constructor([param('ns3::NormalVariable const &', 'arg0')])
  1392     cls.add_constructor([param('ns3::NormalVariable const &', 'arg0')])
   715                    'double', 
  1406                    'double', 
   716                    [param('double', 'm'), param('double', 'v'), param('double', 'b')], 
  1407                    [param('double', 'm'), param('double', 'v'), param('double', 'b')], 
   717                    is_static=True)
  1408                    is_static=True)
   718     return
  1409     return
   719 
  1410 
   720 def register_Ns3ObjectFactory_methods(root_module, cls):
  1411 def register_Ns3Object_methods(root_module, cls):
   721     ## object-factory.h: ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [copy constructor]
  1412     ## object.h: static ns3::TypeId ns3::Object::GetTypeId() [member function]
   722     cls.add_constructor([param('ns3::ObjectFactory const &', 'arg0')])
       
   723     ## object-factory.h: ns3::ObjectFactory::ObjectFactory() [constructor]
       
   724     cls.add_constructor([])
       
   725     ## object-factory.h: ns3::Ptr<ns3::Object> ns3::ObjectFactory::Create() const [member function]
       
   726     cls.add_method('Create', 
       
   727                    'ns3::Ptr< ns3::Object >', 
       
   728                    [], 
       
   729                    is_const=True)
       
   730     ## object-factory.h: ns3::TypeId ns3::ObjectFactory::GetTypeId() const [member function]
       
   731     cls.add_method('GetTypeId', 
  1413     cls.add_method('GetTypeId', 
   732                    'ns3::TypeId', 
  1414                    'ns3::TypeId', 
   733                    [], 
  1415                    [], 
   734                    is_const=True)
  1416                    is_static=True)
   735     ## object-factory.h: void ns3::ObjectFactory::Set(std::string name, ns3::AttributeValue const & value) [member function]
  1417     ## object.h: ns3::Object::Object() [constructor]
       
  1418     cls.add_constructor([])
       
  1419     ## object.h: ns3::TypeId ns3::Object::GetInstanceTypeId() const [member function]
       
  1420     cls.add_method('GetInstanceTypeId', 
       
  1421                    'ns3::TypeId', 
       
  1422                    [], 
       
  1423                    is_const=True, is_virtual=True)
       
  1424     ## object.h: ns3::Ptr<ns3::Object> ns3::Object::GetObject(ns3::TypeId tid) const [member function]
       
  1425     cls.add_method('GetObject', 
       
  1426                    'ns3::Ptr< ns3::Object >', 
       
  1427                    [param('ns3::TypeId', 'tid')], 
       
  1428                    is_const=True, template_parameters=['ns3::Object'], custom_template_method_name='GetObject')
       
  1429     ## object.h: void ns3::Object::Dispose() [member function]
       
  1430     cls.add_method('Dispose', 
       
  1431                    'void', 
       
  1432                    [])
       
  1433     ## object.h: void ns3::Object::AggregateObject(ns3::Ptr<ns3::Object> other) [member function]
       
  1434     cls.add_method('AggregateObject', 
       
  1435                    'void', 
       
  1436                    [param('ns3::Ptr< ns3::Object >', 'other')])
       
  1437     ## object.h: ns3::Object::AggregateIterator ns3::Object::GetAggregateIterator() const [member function]
       
  1438     cls.add_method('GetAggregateIterator', 
       
  1439                    'ns3::Object::AggregateIterator', 
       
  1440                    [], 
       
  1441                    is_const=True)
       
  1442     ## object.h: void ns3::Object::DoDispose() [member function]
       
  1443     cls.add_method('DoDispose', 
       
  1444                    'void', 
       
  1445                    [], 
       
  1446                    visibility='protected', is_virtual=True)
       
  1447     ## object.h: ns3::Object::Object(ns3::Object const & o) [copy constructor]
       
  1448     cls.add_constructor([param('ns3::Object const &', 'o')], 
       
  1449                         visibility='protected')
       
  1450     return
       
  1451 
       
  1452 def register_Ns3ObjectAggregateIterator_methods(root_module, cls):
       
  1453     ## object.h: ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [copy constructor]
       
  1454     cls.add_constructor([param('ns3::Object::AggregateIterator const &', 'arg0')])
       
  1455     ## object.h: ns3::Object::AggregateIterator::AggregateIterator() [constructor]
       
  1456     cls.add_constructor([])
       
  1457     ## object.h: bool ns3::Object::AggregateIterator::HasNext() const [member function]
       
  1458     cls.add_method('HasNext', 
       
  1459                    'bool', 
       
  1460                    [], 
       
  1461                    is_const=True)
       
  1462     ## object.h: ns3::Ptr<ns3::Object const> ns3::Object::AggregateIterator::Next() [member function]
       
  1463     cls.add_method('Next', 
       
  1464                    'ns3::Ptr< ns3::Object const >', 
       
  1465                    [])
       
  1466     return
       
  1467 
       
  1468 def register_Ns3ObjectFactoryChecker_methods(root_module, cls):
       
  1469     ## object-factory.h: ns3::ObjectFactoryChecker::ObjectFactoryChecker(ns3::ObjectFactoryChecker const & arg0) [copy constructor]
       
  1470     cls.add_constructor([param('ns3::ObjectFactoryChecker const &', 'arg0')])
       
  1471     ## object-factory.h: ns3::ObjectFactoryChecker::ObjectFactoryChecker() [constructor]
       
  1472     cls.add_constructor([])
       
  1473     return
       
  1474 
       
  1475 def register_Ns3ObjectFactoryValue_methods(root_module, cls):
       
  1476     ## object-factory.h: ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactoryValue const & arg0) [copy constructor]
       
  1477     cls.add_constructor([param('ns3::ObjectFactoryValue const &', 'arg0')])
       
  1478     ## object-factory.h: ns3::ObjectFactoryValue::ObjectFactoryValue() [constructor]
       
  1479     cls.add_constructor([])
       
  1480     ## object-factory.h: ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactory const & value) [constructor]
       
  1481     cls.add_constructor([param('ns3::ObjectFactory const &', 'value')])
       
  1482     ## object-factory.h: void ns3::ObjectFactoryValue::Set(ns3::ObjectFactory const & value) [member function]
   736     cls.add_method('Set', 
  1483     cls.add_method('Set', 
   737                    'void', 
  1484                    'void', 
   738                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
  1485                    [param('ns3::ObjectFactory const &', 'value')])
   739     ## object-factory.h: void ns3::ObjectFactory::SetTypeId(ns3::TypeId tid) [member function]
  1486     ## object-factory.h: ns3::ObjectFactory ns3::ObjectFactoryValue::Get() const [member function]
   740     cls.add_method('SetTypeId', 
  1487     cls.add_method('Get', 
   741                    'void', 
  1488                    'ns3::ObjectFactory', 
   742                    [param('ns3::TypeId', 'tid')])
  1489                    [], 
   743     ## object-factory.h: void ns3::ObjectFactory::SetTypeId(char const * tid) [member function]
  1490                    is_const=True)
   744     cls.add_method('SetTypeId', 
  1491     ## object-factory.h: ns3::Ptr<ns3::AttributeValue> ns3::ObjectFactoryValue::Copy() const [member function]
   745                    'void', 
  1492     cls.add_method('Copy', 
   746                    [param('char const *', 'tid')])
  1493                    'ns3::Ptr< ns3::AttributeValue >', 
   747     ## object-factory.h: void ns3::ObjectFactory::SetTypeId(std::string tid) [member function]
  1494                    [], 
   748     cls.add_method('SetTypeId', 
  1495                    is_const=True, is_virtual=True)
   749                    'void', 
  1496     ## object-factory.h: std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
   750                    [param('std::string', 'tid')])
  1497     cls.add_method('SerializeToString', 
   751     cls.add_output_stream_operator()
  1498                    'std::string', 
   752     return
  1499                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
   753 
  1500                    is_const=True, is_virtual=True)
   754 def register_Ns3AttributeAccessor_methods(root_module, cls):
  1501     ## object-factory.h: bool ns3::ObjectFactoryValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   755     ## attribute.h: ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [copy constructor]
  1502     cls.add_method('DeserializeFromString', 
   756     cls.add_constructor([param('ns3::AttributeAccessor const &', 'arg0')])
  1503                    'bool', 
   757     ## attribute.h: ns3::AttributeAccessor::AttributeAccessor() [constructor]
  1504                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
   758     cls.add_constructor([])
  1505                    is_virtual=True)
   759     ## attribute.h: bool ns3::AttributeAccessor::Set(ns3::ObjectBase * object, ns3::AttributeValue const & value) const [member function]
  1506     return
       
  1507 
       
  1508 def register_Ns3ObjectVectorAccessor_methods(root_module, cls):
       
  1509     ## object-vector.h: ns3::ObjectVectorAccessor::ObjectVectorAccessor(ns3::ObjectVectorAccessor const & arg0) [copy constructor]
       
  1510     cls.add_constructor([param('ns3::ObjectVectorAccessor const &', 'arg0')])
       
  1511     ## object-vector.h: ns3::ObjectVectorAccessor::ObjectVectorAccessor() [constructor]
       
  1512     cls.add_constructor([])
       
  1513     ## object-vector.h: bool ns3::ObjectVectorAccessor::Set(ns3::ObjectBase * object, ns3::AttributeValue const & value) const [member function]
   760     cls.add_method('Set', 
  1514     cls.add_method('Set', 
   761                    'bool', 
  1515                    'bool', 
   762                    [param('ns3::ObjectBase *', 'object', transfer_ownership=False), param('ns3::AttributeValue const &', 'value')], 
  1516                    [param('ns3::ObjectBase *', 'object'), param('ns3::AttributeValue const &', 'value')], 
       
  1517                    is_const=True, is_virtual=True)
       
  1518     ## object-vector.h: bool ns3::ObjectVectorAccessor::Get(ns3::ObjectBase const * object, ns3::AttributeValue & value) const [member function]
       
  1519     cls.add_method('Get', 
       
  1520                    'bool', 
       
  1521                    [param('ns3::ObjectBase const *', 'object'), param('ns3::AttributeValue &', 'value')], 
       
  1522                    is_const=True, is_virtual=True)
       
  1523     ## object-vector.h: bool ns3::ObjectVectorAccessor::HasGetter() const [member function]
       
  1524     cls.add_method('HasGetter', 
       
  1525                    'bool', 
       
  1526                    [], 
       
  1527                    is_const=True, is_virtual=True)
       
  1528     ## object-vector.h: bool ns3::ObjectVectorAccessor::HasSetter() const [member function]
       
  1529     cls.add_method('HasSetter', 
       
  1530                    'bool', 
       
  1531                    [], 
       
  1532                    is_const=True, is_virtual=True)
       
  1533     ## object-vector.h: bool ns3::ObjectVectorAccessor::DoGetN(ns3::ObjectBase const * object, uint32_t * n) const [member function]
       
  1534     cls.add_method('DoGetN', 
       
  1535                    'bool', 
       
  1536                    [param('ns3::ObjectBase const *', 'object'), param('uint32_t *', 'n')], 
       
  1537                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1538     ## object-vector.h: ns3::Ptr<ns3::Object> ns3::ObjectVectorAccessor::DoGet(ns3::ObjectBase const * object, uint32_t i) const [member function]
       
  1539     cls.add_method('DoGet', 
       
  1540                    'ns3::Ptr< ns3::Object >', 
       
  1541                    [param('ns3::ObjectBase const *', 'object'), param('uint32_t', 'i')], 
       
  1542                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1543     return
       
  1544 
       
  1545 def register_Ns3ObjectVectorChecker_methods(root_module, cls):
       
  1546     ## object-vector.h: ns3::ObjectVectorChecker::ObjectVectorChecker(ns3::ObjectVectorChecker const & arg0) [copy constructor]
       
  1547     cls.add_constructor([param('ns3::ObjectVectorChecker const &', 'arg0')])
       
  1548     ## object-vector.h: ns3::ObjectVectorChecker::ObjectVectorChecker() [constructor]
       
  1549     cls.add_constructor([])
       
  1550     ## object-vector.h: ns3::TypeId ns3::ObjectVectorChecker::GetItemTypeId() const [member function]
       
  1551     cls.add_method('GetItemTypeId', 
       
  1552                    'ns3::TypeId', 
       
  1553                    [], 
   763                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1554                    is_pure_virtual=True, is_const=True, is_virtual=True)
   764     ## attribute.h: bool ns3::AttributeAccessor::Get(ns3::ObjectBase const * object, ns3::AttributeValue & attribute) const [member function]
  1555     return
       
  1556 
       
  1557 def register_Ns3ObjectVectorValue_methods(root_module, cls):
       
  1558     ## object-vector.h: ns3::ObjectVectorValue::ObjectVectorValue(ns3::ObjectVectorValue const & arg0) [copy constructor]
       
  1559     cls.add_constructor([param('ns3::ObjectVectorValue const &', 'arg0')])
       
  1560     ## object-vector.h: ns3::ObjectVectorValue::ObjectVectorValue() [constructor]
       
  1561     cls.add_constructor([])
       
  1562     ## object-vector.h: __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Object>*,std::vector<ns3::Ptr<ns3::Object>, std::allocator<ns3::Ptr<ns3::Object> > > > ns3::ObjectVectorValue::Begin() const [member function]
       
  1563     cls.add_method('Begin', 
       
  1564                    '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Object > const, std::vector< ns3::Ptr< ns3::Object > > >', 
       
  1565                    [], 
       
  1566                    is_const=True)
       
  1567     ## object-vector.h: __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Object>*,std::vector<ns3::Ptr<ns3::Object>, std::allocator<ns3::Ptr<ns3::Object> > > > ns3::ObjectVectorValue::End() const [member function]
       
  1568     cls.add_method('End', 
       
  1569                    '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Object > const, std::vector< ns3::Ptr< ns3::Object > > >', 
       
  1570                    [], 
       
  1571                    is_const=True)
       
  1572     ## object-vector.h: uint32_t ns3::ObjectVectorValue::GetN() const [member function]
       
  1573     cls.add_method('GetN', 
       
  1574                    'uint32_t', 
       
  1575                    [], 
       
  1576                    is_const=True)
       
  1577     ## object-vector.h: ns3::Ptr<ns3::Object> ns3::ObjectVectorValue::Get(uint32_t i) const [member function]
   765     cls.add_method('Get', 
  1578     cls.add_method('Get', 
   766                    'bool', 
  1579                    'ns3::Ptr< ns3::Object >', 
   767                    [param('ns3::ObjectBase const *', 'object'), param('ns3::AttributeValue &', 'attribute')], 
  1580                    [param('uint32_t', 'i')], 
   768                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1581                    is_const=True)
   769     ## attribute.h: bool ns3::AttributeAccessor::HasGetter() const [member function]
  1582     ## object-vector.h: ns3::Ptr<ns3::AttributeValue> ns3::ObjectVectorValue::Copy() const [member function]
   770     cls.add_method('HasGetter', 
  1583     cls.add_method('Copy', 
   771                    'bool', 
  1584                    'ns3::Ptr< ns3::AttributeValue >', 
   772                    [], 
  1585                    [], 
   773                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1586                    is_const=True, is_virtual=True)
   774     ## attribute.h: bool ns3::AttributeAccessor::HasSetter() const [member function]
  1587     ## object-vector.h: std::string ns3::ObjectVectorValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
   775     cls.add_method('HasSetter', 
  1588     cls.add_method('SerializeToString', 
   776                    'bool', 
  1589                    'std::string', 
   777                    [], 
  1590                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
   778                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1591                    is_const=True, is_virtual=True)
       
  1592     ## object-vector.h: bool ns3::ObjectVectorValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
       
  1593     cls.add_method('DeserializeFromString', 
       
  1594                    'bool', 
       
  1595                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1596                    is_virtual=True)
   779     return
  1597     return
   780 
  1598 
   781 def register_Ns3ParetoVariable_methods(root_module, cls):
  1599 def register_Ns3ParetoVariable_methods(root_module, cls):
   782     ## random-variable.h: ns3::ParetoVariable::ParetoVariable(ns3::ParetoVariable const & arg0) [copy constructor]
  1600     ## random-variable.h: ns3::ParetoVariable::ParetoVariable(ns3::ParetoVariable const & arg0) [copy constructor]
   783     cls.add_constructor([param('ns3::ParetoVariable const &', 'arg0')])
  1601     cls.add_constructor([param('ns3::ParetoVariable const &', 'arg0')])
   794                    'double', 
  1612                    'double', 
   795                    [param('double', 'm'), param('double', 's'), param('double', 'b', default_value='0')], 
  1613                    [param('double', 'm'), param('double', 's'), param('double', 'b', default_value='0')], 
   796                    is_static=True)
  1614                    is_static=True)
   797     return
  1615     return
   798 
  1616 
   799 def register_Ns3ConstantVariable_methods(root_module, cls):
       
   800     ## random-variable.h: ns3::ConstantVariable::ConstantVariable(ns3::ConstantVariable const & arg0) [copy constructor]
       
   801     cls.add_constructor([param('ns3::ConstantVariable const &', 'arg0')])
       
   802     ## random-variable.h: ns3::ConstantVariable::ConstantVariable() [constructor]
       
   803     cls.add_constructor([])
       
   804     ## random-variable.h: ns3::ConstantVariable::ConstantVariable(double c) [constructor]
       
   805     cls.add_constructor([param('double', 'c')])
       
   806     ## random-variable.h: void ns3::ConstantVariable::SetConstant(double c) [member function]
       
   807     cls.add_method('SetConstant', 
       
   808                    'void', 
       
   809                    [param('double', 'c')])
       
   810     return
       
   811 
       
   812 def register_Ns3EmpiricalVariable_methods(root_module, cls):
       
   813     ## random-variable.h: ns3::EmpiricalVariable::EmpiricalVariable(ns3::EmpiricalVariable const & arg0) [copy constructor]
       
   814     cls.add_constructor([param('ns3::EmpiricalVariable const &', 'arg0')])
       
   815     ## random-variable.h: ns3::EmpiricalVariable::EmpiricalVariable() [constructor]
       
   816     cls.add_constructor([])
       
   817     ## random-variable.h: void ns3::EmpiricalVariable::CDF(double v, double c) [member function]
       
   818     cls.add_method('CDF', 
       
   819                    'void', 
       
   820                    [param('double', 'v'), param('double', 'c')])
       
   821     return
       
   822 
       
   823 def register_Ns3EnumChecker_methods(root_module, cls):
       
   824     ## enum.h: ns3::EnumChecker::EnumChecker(ns3::EnumChecker const & arg0) [copy constructor]
       
   825     cls.add_constructor([param('ns3::EnumChecker const &', 'arg0')])
       
   826     ## enum.h: ns3::EnumChecker::EnumChecker() [constructor]
       
   827     cls.add_constructor([])
       
   828     ## enum.h: void ns3::EnumChecker::AddDefault(int v, std::string name) [member function]
       
   829     cls.add_method('AddDefault', 
       
   830                    'void', 
       
   831                    [param('int', 'v'), param('std::string', 'name')])
       
   832     ## enum.h: void ns3::EnumChecker::Add(int v, std::string name) [member function]
       
   833     cls.add_method('Add', 
       
   834                    'void', 
       
   835                    [param('int', 'v'), param('std::string', 'name')])
       
   836     ## enum.h: bool ns3::EnumChecker::Check(ns3::AttributeValue const & value) const [member function]
       
   837     cls.add_method('Check', 
       
   838                    'bool', 
       
   839                    [param('ns3::AttributeValue const &', 'value')], 
       
   840                    is_const=True, is_virtual=True)
       
   841     ## enum.h: std::string ns3::EnumChecker::GetValueTypeName() const [member function]
       
   842     cls.add_method('GetValueTypeName', 
       
   843                    'std::string', 
       
   844                    [], 
       
   845                    is_const=True, is_virtual=True)
       
   846     ## enum.h: bool ns3::EnumChecker::HasUnderlyingTypeInformation() const [member function]
       
   847     cls.add_method('HasUnderlyingTypeInformation', 
       
   848                    'bool', 
       
   849                    [], 
       
   850                    is_const=True, is_virtual=True)
       
   851     ## enum.h: std::string ns3::EnumChecker::GetUnderlyingTypeInformation() const [member function]
       
   852     cls.add_method('GetUnderlyingTypeInformation', 
       
   853                    'std::string', 
       
   854                    [], 
       
   855                    is_const=True, is_virtual=True)
       
   856     ## enum.h: ns3::Ptr<ns3::AttributeValue> ns3::EnumChecker::Create() const [member function]
       
   857     cls.add_method('Create', 
       
   858                    'ns3::Ptr< ns3::AttributeValue >', 
       
   859                    [], 
       
   860                    is_const=True, is_virtual=True)
       
   861     ## enum.h: bool ns3::EnumChecker::Copy(ns3::AttributeValue const & src, ns3::AttributeValue & dst) const [member function]
       
   862     cls.add_method('Copy', 
       
   863                    'bool', 
       
   864                    [param('ns3::AttributeValue const &', 'src'), param('ns3::AttributeValue &', 'dst')], 
       
   865                    is_const=True, is_virtual=True)
       
   866     return
       
   867 
       
   868 def register_Ns3Empty_methods(root_module, cls):
       
   869     ## empty.h: ns3::empty::empty(ns3::empty const & arg0) [copy constructor]
       
   870     cls.add_constructor([param('ns3::empty const &', 'arg0')])
       
   871     ## empty.h: ns3::empty::empty() [constructor]
       
   872     cls.add_constructor([])
       
   873     return
       
   874 
       
   875 def register_Ns3ObjectBase_methods(root_module, cls):
       
   876     ## object-base.h: ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [copy constructor]
       
   877     cls.add_constructor([param('ns3::ObjectBase const &', 'arg0')])
       
   878     ## object-base.h: ns3::ObjectBase::ObjectBase() [constructor]
       
   879     cls.add_constructor([])
       
   880     ## object-base.h: static ns3::TypeId ns3::ObjectBase::GetTypeId() [member function]
       
   881     cls.add_method('GetTypeId', 
       
   882                    'ns3::TypeId', 
       
   883                    [], 
       
   884                    is_static=True)
       
   885     ## object-base.h: ns3::TypeId ns3::ObjectBase::GetInstanceTypeId() const [member function]
       
   886     cls.add_method('GetInstanceTypeId', 
       
   887                    'ns3::TypeId', 
       
   888                    [], 
       
   889                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
   890     ## object-base.h: void ns3::ObjectBase::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function]
       
   891     cls.add_method('SetAttribute', 
       
   892                    'void', 
       
   893                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
       
   894     ## object-base.h: bool ns3::ObjectBase::SetAttributeFailSafe(std::string name, ns3::AttributeValue const & value) [member function]
       
   895     cls.add_method('SetAttributeFailSafe', 
       
   896                    'bool', 
       
   897                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
       
   898     ## object-base.h: void ns3::ObjectBase::GetAttribute(std::string name, ns3::AttributeValue & value) const [member function]
       
   899     cls.add_method('GetAttribute', 
       
   900                    'void', 
       
   901                    [param('std::string', 'name'), param('ns3::AttributeValue &', 'value')], 
       
   902                    is_const=True)
       
   903     ## object-base.h: bool ns3::ObjectBase::GetAttributeFailSafe(std::string name, ns3::AttributeValue & attribute) const [member function]
       
   904     cls.add_method('GetAttributeFailSafe', 
       
   905                    'bool', 
       
   906                    [param('std::string', 'name'), param('ns3::AttributeValue &', 'attribute')], 
       
   907                    is_const=True)
       
   908     ## object-base.h: bool ns3::ObjectBase::TraceConnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function]
       
   909     cls.add_method('TraceConnect', 
       
   910                    'bool', 
       
   911                    [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')])
       
   912     ## object-base.h: bool ns3::ObjectBase::TraceConnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]
       
   913     cls.add_method('TraceConnectWithoutContext', 
       
   914                    'bool', 
       
   915                    [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])
       
   916     ## object-base.h: bool ns3::ObjectBase::TraceDisconnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function]
       
   917     cls.add_method('TraceDisconnect', 
       
   918                    'bool', 
       
   919                    [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')])
       
   920     ## object-base.h: bool ns3::ObjectBase::TraceDisconnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]
       
   921     cls.add_method('TraceDisconnectWithoutContext', 
       
   922                    'bool', 
       
   923                    [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])
       
   924     ## object-base.h: void ns3::ObjectBase::NotifyConstructionCompleted() [member function]
       
   925     cls.add_method('NotifyConstructionCompleted', 
       
   926                    'void', 
       
   927                    [], 
       
   928                    visibility='protected', is_virtual=True)
       
   929     ## object-base.h: void ns3::ObjectBase::ConstructSelf(ns3::AttributeList const & attributes) [member function]
       
   930     cls.add_method('ConstructSelf', 
       
   931                    'void', 
       
   932                    [param('ns3::AttributeList const &', 'attributes')], 
       
   933                    visibility='protected')
       
   934     return
       
   935 
       
   936 def register_Ns3CommandLine_methods(root_module, cls):
       
   937     ## command-line.h: ns3::CommandLine::CommandLine(ns3::CommandLine const & arg0) [copy constructor]
       
   938     cls.add_constructor([param('ns3::CommandLine const &', 'arg0')])
       
   939     ## command-line.h: ns3::CommandLine::CommandLine() [constructor]
       
   940     cls.add_constructor([])
       
   941     return
       
   942 
       
   943 def register_Ns3IntToType__6_methods(root_module, cls):
       
   944     ## int-to-type.h: ns3::IntToType<6>::IntToType(ns3::IntToType<6> const & arg0) [copy constructor]
       
   945     cls.add_constructor([param('ns3::IntToType< 6 >', 'arg0')])
       
   946     ## int-to-type.h: ns3::IntToType<6>::IntToType() [constructor]
       
   947     cls.add_constructor([])
       
   948     cls.add_copy_constructor()
       
   949     return
       
   950 
       
   951 def register_Ns3IntToType__5_methods(root_module, cls):
       
   952     ## int-to-type.h: ns3::IntToType<5>::IntToType(ns3::IntToType<5> const & arg0) [copy constructor]
       
   953     cls.add_constructor([param('ns3::IntToType< 5 >', 'arg0')])
       
   954     ## int-to-type.h: ns3::IntToType<5>::IntToType() [constructor]
       
   955     cls.add_constructor([])
       
   956     cls.add_copy_constructor()
       
   957     return
       
   958 
       
   959 def register_Ns3IntToType__4_methods(root_module, cls):
       
   960     ## int-to-type.h: ns3::IntToType<4>::IntToType(ns3::IntToType<4> const & arg0) [copy constructor]
       
   961     cls.add_constructor([param('ns3::IntToType< 4 >', 'arg0')])
       
   962     ## int-to-type.h: ns3::IntToType<4>::IntToType() [constructor]
       
   963     cls.add_constructor([])
       
   964     cls.add_copy_constructor()
       
   965     return
       
   966 
       
   967 def register_Ns3IntToType__3_methods(root_module, cls):
       
   968     ## int-to-type.h: ns3::IntToType<3>::IntToType(ns3::IntToType<3> const & arg0) [copy constructor]
       
   969     cls.add_constructor([param('ns3::IntToType< 3 >', 'arg0')])
       
   970     ## int-to-type.h: ns3::IntToType<3>::IntToType() [constructor]
       
   971     cls.add_constructor([])
       
   972     cls.add_copy_constructor()
       
   973     return
       
   974 
       
   975 def register_Ns3IntToType__2_methods(root_module, cls):
       
   976     ## int-to-type.h: ns3::IntToType<2>::IntToType(ns3::IntToType<2> const & arg0) [copy constructor]
       
   977     cls.add_constructor([param('ns3::IntToType< 2 >', 'arg0')])
       
   978     ## int-to-type.h: ns3::IntToType<2>::IntToType() [constructor]
       
   979     cls.add_constructor([])
       
   980     cls.add_copy_constructor()
       
   981     return
       
   982 
       
   983 def register_Ns3IntToType__1_methods(root_module, cls):
       
   984     ## int-to-type.h: ns3::IntToType<1>::IntToType(ns3::IntToType<1> const & arg0) [copy constructor]
       
   985     cls.add_constructor([param('ns3::IntToType< 1 >', 'arg0')])
       
   986     ## int-to-type.h: ns3::IntToType<1>::IntToType() [constructor]
       
   987     cls.add_constructor([])
       
   988     cls.add_copy_constructor()
       
   989     return
       
   990 
       
   991 def register_Ns3IntToType__0_methods(root_module, cls):
       
   992     ## int-to-type.h: ns3::IntToType<0>::IntToType(ns3::IntToType<0> const & arg0) [copy constructor]
       
   993     cls.add_constructor([param('ns3::IntToType< 0 >', 'arg0')])
       
   994     ## int-to-type.h: ns3::IntToType<0>::IntToType() [constructor]
       
   995     cls.add_constructor([])
       
   996     cls.add_copy_constructor()
       
   997     return
       
   998 
       
   999 def register_Ns3RngStream_methods(root_module, cls):
       
  1000     ## rng-stream.h: ns3::RngStream::RngStream() [constructor]
       
  1001     cls.add_constructor([])
       
  1002     ## rng-stream.h: ns3::RngStream::RngStream(ns3::RngStream const & arg0) [copy constructor]
       
  1003     cls.add_constructor([param('ns3::RngStream const &', 'arg0')])
       
  1004     ## rng-stream.h: void ns3::RngStream::InitializeStream() [member function]
       
  1005     cls.add_method('InitializeStream', 
       
  1006                    'void', 
       
  1007                    [])
       
  1008     ## rng-stream.h: void ns3::RngStream::ResetStartStream() [member function]
       
  1009     cls.add_method('ResetStartStream', 
       
  1010                    'void', 
       
  1011                    [])
       
  1012     ## rng-stream.h: void ns3::RngStream::ResetStartSubstream() [member function]
       
  1013     cls.add_method('ResetStartSubstream', 
       
  1014                    'void', 
       
  1015                    [])
       
  1016     ## rng-stream.h: void ns3::RngStream::ResetNextSubstream() [member function]
       
  1017     cls.add_method('ResetNextSubstream', 
       
  1018                    'void', 
       
  1019                    [])
       
  1020     ## rng-stream.h: void ns3::RngStream::ResetNthSubstream(uint32_t N) [member function]
       
  1021     cls.add_method('ResetNthSubstream', 
       
  1022                    'void', 
       
  1023                    [param('uint32_t', 'N')])
       
  1024     ## rng-stream.h: void ns3::RngStream::SetAntithetic(bool a) [member function]
       
  1025     cls.add_method('SetAntithetic', 
       
  1026                    'void', 
       
  1027                    [param('bool', 'a')])
       
  1028     ## rng-stream.h: void ns3::RngStream::IncreasedPrecis(bool incp) [member function]
       
  1029     cls.add_method('IncreasedPrecis', 
       
  1030                    'void', 
       
  1031                    [param('bool', 'incp')])
       
  1032     ## rng-stream.h: bool ns3::RngStream::SetSeeds(uint32_t const * seed) [member function]
       
  1033     cls.add_method('SetSeeds', 
       
  1034                    'bool', 
       
  1035                    [param('uint32_t const *', 'seed')])
       
  1036     ## rng-stream.h: void ns3::RngStream::AdvanceState(int32_t e, int32_t c) [member function]
       
  1037     cls.add_method('AdvanceState', 
       
  1038                    'void', 
       
  1039                    [param('int32_t', 'e'), param('int32_t', 'c')])
       
  1040     ## rng-stream.h: void ns3::RngStream::GetState(uint32_t * seed) const [member function]
       
  1041     cls.add_method('GetState', 
       
  1042                    'void', 
       
  1043                    [param('uint32_t *', 'seed')], 
       
  1044                    is_const=True)
       
  1045     ## rng-stream.h: double ns3::RngStream::RandU01() [member function]
       
  1046     cls.add_method('RandU01', 
       
  1047                    'double', 
       
  1048                    [])
       
  1049     ## rng-stream.h: int32_t ns3::RngStream::RandInt(int32_t i, int32_t j) [member function]
       
  1050     cls.add_method('RandInt', 
       
  1051                    'int32_t', 
       
  1052                    [param('int32_t', 'i'), param('int32_t', 'j')])
       
  1053     ## rng-stream.h: static bool ns3::RngStream::SetPackageSeed(uint32_t const * seed) [member function]
       
  1054     cls.add_method('SetPackageSeed', 
       
  1055                    'bool', 
       
  1056                    [param('uint32_t const *', 'seed')], 
       
  1057                    is_static=True)
       
  1058     ## rng-stream.h: static bool ns3::RngStream::CheckSeed(uint32_t const * seed) [member function]
       
  1059     cls.add_method('CheckSeed', 
       
  1060                    'bool', 
       
  1061                    [param('uint32_t const *', 'seed')], 
       
  1062                    is_static=True)
       
  1063     return
       
  1064 
       
  1065 def register_Ns3LogNormalVariable_methods(root_module, cls):
       
  1066     ## random-variable.h: ns3::LogNormalVariable::LogNormalVariable(ns3::LogNormalVariable const & arg0) [copy constructor]
       
  1067     cls.add_constructor([param('ns3::LogNormalVariable const &', 'arg0')])
       
  1068     ## random-variable.h: ns3::LogNormalVariable::LogNormalVariable(double mu, double sigma) [constructor]
       
  1069     cls.add_constructor([param('double', 'mu'), param('double', 'sigma')])
       
  1070     ## random-variable.h: static double ns3::LogNormalVariable::GetSingleValue(double mu, double sigma) [member function]
       
  1071     cls.add_method('GetSingleValue', 
       
  1072                    'double', 
       
  1073                    [param('double', 'mu'), param('double', 'sigma')], 
       
  1074                    is_static=True)
       
  1075     return
       
  1076 
       
  1077 def register_Ns3IntEmpiricalVariable_methods(root_module, cls):
       
  1078     ## random-variable.h: ns3::IntEmpiricalVariable::IntEmpiricalVariable(ns3::IntEmpiricalVariable const & arg0) [copy constructor]
       
  1079     cls.add_constructor([param('ns3::IntEmpiricalVariable const &', 'arg0')])
       
  1080     ## random-variable.h: ns3::IntEmpiricalVariable::IntEmpiricalVariable() [constructor]
       
  1081     cls.add_constructor([])
       
  1082     return
       
  1083 
       
  1084 def register_Ns3PointerChecker_methods(root_module, cls):
  1617 def register_Ns3PointerChecker_methods(root_module, cls):
  1085     ## pointer.h: ns3::PointerChecker::PointerChecker(ns3::PointerChecker const & arg0) [copy constructor]
  1618     ## pointer.h: ns3::PointerChecker::PointerChecker(ns3::PointerChecker const & arg0) [copy constructor]
  1086     cls.add_constructor([param('ns3::PointerChecker const &', 'arg0')])
  1619     cls.add_constructor([param('ns3::PointerChecker const &', 'arg0')])
  1087     ## pointer.h: ns3::PointerChecker::PointerChecker() [constructor]
  1620     ## pointer.h: ns3::PointerChecker::PointerChecker() [constructor]
  1088     cls.add_constructor([])
  1621     cls.add_constructor([])
  1091                    'ns3::TypeId', 
  1624                    'ns3::TypeId', 
  1092                    [], 
  1625                    [], 
  1093                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1626                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1094     return
  1627     return
  1095 
  1628 
  1096 def register_Ns3WeibullVariable_methods(root_module, cls):
  1629 def register_Ns3PointerValue_methods(root_module, cls):
  1097     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(ns3::WeibullVariable const & arg0) [copy constructor]
  1630     ## pointer.h: ns3::PointerValue::PointerValue(ns3::PointerValue const & arg0) [copy constructor]
  1098     cls.add_constructor([param('ns3::WeibullVariable const &', 'arg0')])
  1631     cls.add_constructor([param('ns3::PointerValue const &', 'arg0')])
  1099     ## random-variable.h: ns3::WeibullVariable::WeibullVariable() [constructor]
  1632     ## pointer.h: ns3::PointerValue::PointerValue() [constructor]
  1100     cls.add_constructor([])
  1633     cls.add_constructor([])
  1101     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(double m) [constructor]
  1634     ## pointer.h: ns3::PointerValue::PointerValue(ns3::Ptr<ns3::Object> object) [constructor]
  1102     cls.add_constructor([param('double', 'm')])
  1635     cls.add_constructor([param('ns3::Ptr< ns3::Object >', 'object')])
  1103     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(double m, double s) [constructor]
  1636     ## pointer.h: void ns3::PointerValue::SetObject(ns3::Ptr<ns3::Object> object) [member function]
  1104     cls.add_constructor([param('double', 'm'), param('double', 's')])
  1637     cls.add_method('SetObject', 
  1105     ## random-variable.h: ns3::WeibullVariable::WeibullVariable(double m, double s, double b) [constructor]
  1638                    'void', 
  1106     cls.add_constructor([param('double', 'm'), param('double', 's'), param('double', 'b')])
  1639                    [param('ns3::Ptr< ns3::Object >', 'object')])
  1107     ## random-variable.h: static double ns3::WeibullVariable::GetSingleValue(double m, double s, double b=0) [member function]
  1640     ## pointer.h: ns3::Ptr<ns3::Object> ns3::PointerValue::GetObject() const [member function]
  1108     cls.add_method('GetSingleValue', 
  1641     cls.add_method('GetObject', 
  1109                    'double', 
  1642                    'ns3::Ptr< ns3::Object >', 
  1110                    [param('double', 'm'), param('double', 's'), param('double', 'b', default_value='0')], 
  1643                    [], 
  1111                    is_static=True)
  1644                    is_const=True)
  1112     return
  1645     ## pointer.h: ns3::Ptr<ns3::AttributeValue> ns3::PointerValue::Copy() const [member function]
  1113 
       
  1114 def register_Ns3CallbackBase_methods(root_module, cls):
       
  1115     ## callback.h: ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [copy constructor]
       
  1116     cls.add_constructor([param('ns3::CallbackBase const &', 'arg0')])
       
  1117     ## callback.h: ns3::CallbackBase::CallbackBase() [constructor]
       
  1118     cls.add_constructor([])
       
  1119     ## callback.h: ns3::Ptr<ns3::CallbackImplBase> ns3::CallbackBase::GetImpl() const [member function]
       
  1120     cls.add_method('GetImpl', 
       
  1121                    'ns3::Ptr< ns3::CallbackImplBase >', 
       
  1122                    [], 
       
  1123                    is_const=True)
       
  1124     ## callback.h: ns3::CallbackBase::CallbackBase(ns3::Ptr<ns3::CallbackImplBase> impl) [constructor]
       
  1125     cls.add_constructor([param('ns3::Ptr< ns3::CallbackImplBase >', 'impl')], 
       
  1126                         visibility='protected')
       
  1127     return
       
  1128 
       
  1129 def register_Ns3ExponentialVariable_methods(root_module, cls):
       
  1130     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable(ns3::ExponentialVariable const & arg0) [copy constructor]
       
  1131     cls.add_constructor([param('ns3::ExponentialVariable const &', 'arg0')])
       
  1132     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable() [constructor]
       
  1133     cls.add_constructor([])
       
  1134     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable(double m) [constructor]
       
  1135     cls.add_constructor([param('double', 'm')])
       
  1136     ## random-variable.h: ns3::ExponentialVariable::ExponentialVariable(double m, double b) [constructor]
       
  1137     cls.add_constructor([param('double', 'm'), param('double', 'b')])
       
  1138     ## random-variable.h: static double ns3::ExponentialVariable::GetSingleValue(double m, double b=0) [member function]
       
  1139     cls.add_method('GetSingleValue', 
       
  1140                    'double', 
       
  1141                    [param('double', 'm'), param('double', 'b', default_value='0')], 
       
  1142                    is_static=True)
       
  1143     return
       
  1144 
       
  1145 def register_Ns3DeterministicVariable_methods(root_module, cls):
       
  1146     ## random-variable.h: ns3::DeterministicVariable::DeterministicVariable(ns3::DeterministicVariable const & arg0) [copy constructor]
       
  1147     cls.add_constructor([param('ns3::DeterministicVariable const &', 'arg0')])
       
  1148     ## random-variable.h: ns3::DeterministicVariable::DeterministicVariable(double * d, uint32_t c) [constructor]
       
  1149     cls.add_constructor([param('double *', 'd'), param('uint32_t', 'c')])
       
  1150     return
       
  1151 
       
  1152 def register_Ns3SystemThread_methods(root_module, cls):
       
  1153     ## system-thread.h: ns3::SystemThread::SystemThread(ns3::SystemThread const & arg0) [copy constructor]
       
  1154     cls.add_constructor([param('ns3::SystemThread const &', 'arg0')])
       
  1155     ## system-thread.h: ns3::SystemThread::SystemThread(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [constructor]
       
  1156     cls.add_constructor([param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')])
       
  1157     ## system-thread.h: void ns3::SystemThread::Ref() const [member function]
       
  1158     cls.add_method('Ref', 
       
  1159                    'void', 
       
  1160                    [], 
       
  1161                    is_const=True)
       
  1162     ## system-thread.h: void ns3::SystemThread::Unref() const [member function]
       
  1163     cls.add_method('Unref', 
       
  1164                    'void', 
       
  1165                    [], 
       
  1166                    is_const=True)
       
  1167     ## system-thread.h: void ns3::SystemThread::Start() [member function]
       
  1168     cls.add_method('Start', 
       
  1169                    'void', 
       
  1170                    [])
       
  1171     ## system-thread.h: void ns3::SystemThread::Join() [member function]
       
  1172     cls.add_method('Join', 
       
  1173                    'void', 
       
  1174                    [])
       
  1175     return
       
  1176 
       
  1177 def register_Ns3AttributeList_methods(root_module, cls):
       
  1178     ## attribute-list.h: ns3::AttributeList::AttributeList() [constructor]
       
  1179     cls.add_constructor([])
       
  1180     ## attribute-list.h: ns3::AttributeList::AttributeList(ns3::AttributeList const & o) [copy constructor]
       
  1181     cls.add_constructor([param('ns3::AttributeList const &', 'o')])
       
  1182     ## attribute-list.h: void ns3::AttributeList::Set(std::string name, ns3::AttributeValue const & value) [member function]
       
  1183     cls.add_method('Set', 
       
  1184                    'void', 
       
  1185                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
       
  1186     ## attribute-list.h: bool ns3::AttributeList::SetFailSafe(std::string name, ns3::AttributeValue const & value) [member function]
       
  1187     cls.add_method('SetFailSafe', 
       
  1188                    'bool', 
       
  1189                    [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
       
  1190     ## attribute-list.h: void ns3::AttributeList::SetWithTid(ns3::TypeId tid, std::string name, ns3::AttributeValue const & value) [member function]
       
  1191     cls.add_method('SetWithTid', 
       
  1192                    'void', 
       
  1193                    [param('ns3::TypeId', 'tid'), param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
       
  1194     ## attribute-list.h: void ns3::AttributeList::Reset() [member function]
       
  1195     cls.add_method('Reset', 
       
  1196                    'void', 
       
  1197                    [])
       
  1198     ## attribute-list.h: static ns3::AttributeList * ns3::AttributeList::GetGlobal() [member function]
       
  1199     cls.add_method('GetGlobal', 
       
  1200                    'ns3::AttributeList *', 
       
  1201                    [], 
       
  1202                    is_static=True)
       
  1203     ## attribute-list.h: std::string ns3::AttributeList::SerializeToString() const [member function]
       
  1204     cls.add_method('SerializeToString', 
       
  1205                    'std::string', 
       
  1206                    [], 
       
  1207                    is_const=True)
       
  1208     ## attribute-list.h: bool ns3::AttributeList::DeserializeFromString(std::string value) [member function]
       
  1209     cls.add_method('DeserializeFromString', 
       
  1210                    'bool', 
       
  1211                    [param('std::string', 'value')])
       
  1212     return
       
  1213 
       
  1214 def register_Ns3AttributeValue_methods(root_module, cls):
       
  1215     ## attribute.h: ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [copy constructor]
       
  1216     cls.add_constructor([param('ns3::AttributeValue const &', 'arg0')])
       
  1217     ## attribute.h: ns3::AttributeValue::AttributeValue() [constructor]
       
  1218     cls.add_constructor([])
       
  1219     ## attribute.h: ns3::Ptr<ns3::AttributeValue> ns3::AttributeValue::Copy() const [member function]
       
  1220     cls.add_method('Copy', 
  1646     cls.add_method('Copy', 
  1221                    'ns3::Ptr< ns3::AttributeValue >', 
  1647                    'ns3::Ptr< ns3::AttributeValue >', 
  1222                    [], 
  1648                    [], 
  1223                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1649                    is_const=True, is_virtual=True)
  1224     ## attribute.h: std::string ns3::AttributeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1650     ## pointer.h: std::string ns3::PointerValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1225     cls.add_method('SerializeToString', 
  1651     cls.add_method('SerializeToString', 
  1226                    'std::string', 
  1652                    'std::string', 
  1227                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1653                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1228                    is_pure_virtual=True, is_const=True, is_virtual=True)
  1654                    is_const=True, is_virtual=True)
  1229     ## attribute.h: bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1655     ## pointer.h: bool ns3::PointerValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1230     cls.add_method('DeserializeFromString', 
  1656     cls.add_method('DeserializeFromString', 
  1231                    'bool', 
  1657                    'bool', 
  1232                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1658                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1233                    is_pure_virtual=True, is_virtual=True)
  1659                    is_virtual=True)
  1234     return
  1660     return
  1235 
  1661 
  1236 def register_Ns3UniformVariable_methods(root_module, cls):
  1662 def register_Ns3RandomVariableChecker_methods(root_module, cls):
  1237     ## random-variable.h: ns3::UniformVariable::UniformVariable(ns3::UniformVariable const & arg0) [copy constructor]
  1663     ## random-variable.h: ns3::RandomVariableChecker::RandomVariableChecker(ns3::RandomVariableChecker const & arg0) [copy constructor]
  1238     cls.add_constructor([param('ns3::UniformVariable const &', 'arg0')])
  1664     cls.add_constructor([param('ns3::RandomVariableChecker const &', 'arg0')])
  1239     ## random-variable.h: ns3::UniformVariable::UniformVariable() [constructor]
  1665     ## random-variable.h: ns3::RandomVariableChecker::RandomVariableChecker() [constructor]
  1240     cls.add_constructor([])
  1666     cls.add_constructor([])
  1241     ## random-variable.h: ns3::UniformVariable::UniformVariable(double s, double l) [constructor]
  1667     return
  1242     cls.add_constructor([param('double', 's'), param('double', 'l')])
  1668 
  1243     ## random-variable.h: static double ns3::UniformVariable::GetSingleValue(double s, double l) [member function]
  1669 def register_Ns3RandomVariableValue_methods(root_module, cls):
  1244     cls.add_method('GetSingleValue', 
  1670     ## random-variable.h: ns3::RandomVariableValue::RandomVariableValue(ns3::RandomVariableValue const & arg0) [copy constructor]
  1245                    'double', 
  1671     cls.add_constructor([param('ns3::RandomVariableValue const &', 'arg0')])
  1246                    [param('double', 's'), param('double', 'l')], 
  1672     ## random-variable.h: ns3::RandomVariableValue::RandomVariableValue() [constructor]
  1247                    is_static=True)
  1673     cls.add_constructor([])
  1248     return
  1674     ## random-variable.h: ns3::RandomVariableValue::RandomVariableValue(ns3::RandomVariable const & value) [constructor]
  1249 
  1675     cls.add_constructor([param('ns3::RandomVariable const &', 'value')])
  1250 def register_Ns3Object_methods(root_module, cls):
  1676     ## random-variable.h: void ns3::RandomVariableValue::Set(ns3::RandomVariable const & value) [member function]
  1251     ## object.h: static ns3::TypeId ns3::Object::GetTypeId() [member function]
  1677     cls.add_method('Set', 
  1252     cls.add_method('GetTypeId', 
  1678                    'void', 
  1253                    'ns3::TypeId', 
  1679                    [param('ns3::RandomVariable const &', 'value')])
  1254                    [], 
  1680     ## random-variable.h: ns3::RandomVariable ns3::RandomVariableValue::Get() const [member function]
  1255                    is_static=True)
  1681     cls.add_method('Get', 
  1256     ## object.h: ns3::Object::Object() [constructor]
  1682                    'ns3::RandomVariable', 
  1257     cls.add_constructor([])
  1683                    [], 
  1258     ## object.h: ns3::TypeId ns3::Object::GetInstanceTypeId() const [member function]
  1684                    is_const=True)
  1259     cls.add_method('GetInstanceTypeId', 
  1685     ## random-variable.h: ns3::Ptr<ns3::AttributeValue> ns3::RandomVariableValue::Copy() const [member function]
  1260                    'ns3::TypeId', 
  1686     cls.add_method('Copy', 
  1261                    [], 
  1687                    'ns3::Ptr< ns3::AttributeValue >', 
  1262                    is_const=True, is_virtual=True)
  1688                    [], 
  1263     ## object.h: ns3::Ptr<ns3::Object> ns3::Object::GetObject(ns3::TypeId tid) const [member function]
  1689                    is_const=True, is_virtual=True)
  1264     cls.add_method('GetObject', 
  1690     ## random-variable.h: std::string ns3::RandomVariableValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1265                    'ns3::Ptr< ns3::Object >', 
  1691     cls.add_method('SerializeToString', 
  1266                    [param('ns3::TypeId', 'tid')], 
  1692                    'std::string', 
  1267                    is_const=True, template_parameters=['ns3::Object'], custom_template_method_name='GetObject')
  1693                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1268     ## object.h: void ns3::Object::Dispose() [member function]
  1694                    is_const=True, is_virtual=True)
  1269     cls.add_method('Dispose', 
  1695     ## random-variable.h: bool ns3::RandomVariableValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1270                    'void', 
  1696     cls.add_method('DeserializeFromString', 
  1271                    [])
  1697                    'bool', 
  1272     ## object.h: void ns3::Object::AggregateObject(ns3::Ptr<ns3::Object> other) [member function]
  1698                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1273     cls.add_method('AggregateObject', 
  1699                    is_virtual=True)
  1274                    'void', 
       
  1275                    [param('ns3::Ptr< ns3::Object >', 'other')])
       
  1276     ## object.h: ns3::Object::AggregateIterator ns3::Object::GetAggregateIterator() const [member function]
       
  1277     cls.add_method('GetAggregateIterator', 
       
  1278                    'ns3::Object::AggregateIterator', 
       
  1279                    [], 
       
  1280                    is_const=True)
       
  1281     ## object.h: void ns3::Object::DoDispose() [member function]
       
  1282     cls.add_method('DoDispose', 
       
  1283                    'void', 
       
  1284                    [], 
       
  1285                    visibility='protected', is_virtual=True)
       
  1286     ## object.h: ns3::Object::Object(ns3::Object const & o) [copy constructor]
       
  1287     cls.add_constructor([param('ns3::Object const &', 'o')], 
       
  1288                         visibility='protected')
       
  1289     return
       
  1290 
       
  1291 def register_Ns3ObjectAggregateIterator_methods(root_module, cls):
       
  1292     ## object.h: ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [copy constructor]
       
  1293     cls.add_constructor([param('ns3::Object::AggregateIterator const &', 'arg0')])
       
  1294     ## object.h: ns3::Object::AggregateIterator::AggregateIterator() [constructor]
       
  1295     cls.add_constructor([])
       
  1296     ## object.h: bool ns3::Object::AggregateIterator::HasNext() const [member function]
       
  1297     cls.add_method('HasNext', 
       
  1298                    'bool', 
       
  1299                    [], 
       
  1300                    is_const=True)
       
  1301     ## object.h: ns3::Ptr<ns3::Object const> ns3::Object::AggregateIterator::Next() [member function]
       
  1302     cls.add_method('Next', 
       
  1303                    'ns3::Ptr< ns3::Object const >', 
       
  1304                    [])
       
  1305     return
       
  1306 
       
  1307 def register_Ns3SystemCondition_methods(root_module, cls):
       
  1308     ## system-condition.h: ns3::SystemCondition::SystemCondition(ns3::SystemCondition const & arg0) [copy constructor]
       
  1309     cls.add_constructor([param('ns3::SystemCondition const &', 'arg0')])
       
  1310     ## system-condition.h: ns3::SystemCondition::SystemCondition() [constructor]
       
  1311     cls.add_constructor([])
       
  1312     ## system-condition.h: void ns3::SystemCondition::SetCondition(bool condition) [member function]
       
  1313     cls.add_method('SetCondition', 
       
  1314                    'void', 
       
  1315                    [param('bool', 'condition')])
       
  1316     ## system-condition.h: bool ns3::SystemCondition::GetCondition() [member function]
       
  1317     cls.add_method('GetCondition', 
       
  1318                    'bool', 
       
  1319                    [])
       
  1320     ## system-condition.h: void ns3::SystemCondition::Signal() [member function]
       
  1321     cls.add_method('Signal', 
       
  1322                    'void', 
       
  1323                    [])
       
  1324     ## system-condition.h: void ns3::SystemCondition::Broadcast() [member function]
       
  1325     cls.add_method('Broadcast', 
       
  1326                    'void', 
       
  1327                    [])
       
  1328     ## system-condition.h: void ns3::SystemCondition::Wait() [member function]
       
  1329     cls.add_method('Wait', 
       
  1330                    'void', 
       
  1331                    [])
       
  1332     ## system-condition.h: bool ns3::SystemCondition::TimedWait(uint64_t ns) [member function]
       
  1333     cls.add_method('TimedWait', 
       
  1334                    'bool', 
       
  1335                    [param('uint64_t', 'ns')])
       
  1336     return
       
  1337 
       
  1338 def register_Ns3SequentialVariable_methods(root_module, cls):
       
  1339     ## random-variable.h: ns3::SequentialVariable::SequentialVariable(ns3::SequentialVariable const & arg0) [copy constructor]
       
  1340     cls.add_constructor([param('ns3::SequentialVariable const &', 'arg0')])
       
  1341     ## random-variable.h: ns3::SequentialVariable::SequentialVariable(double f, double l, double i=1, uint32_t c=1) [constructor]
       
  1342     cls.add_constructor([param('double', 'f'), param('double', 'l'), param('double', 'i', default_value='1'), param('uint32_t', 'c', default_value='1')])
       
  1343     ## random-variable.h: ns3::SequentialVariable::SequentialVariable(double f, double l, ns3::RandomVariable const & i, uint32_t c=1) [constructor]
       
  1344     cls.add_constructor([param('double', 'f'), param('double', 'l'), param('ns3::RandomVariable const &', 'i'), param('uint32_t', 'c', default_value='1')])
       
  1345     return
       
  1346 
       
  1347 def register_Ns3ObjectVectorChecker_methods(root_module, cls):
       
  1348     ## object-vector.h: ns3::ObjectVectorChecker::ObjectVectorChecker(ns3::ObjectVectorChecker const & arg0) [copy constructor]
       
  1349     cls.add_constructor([param('ns3::ObjectVectorChecker const &', 'arg0')])
       
  1350     ## object-vector.h: ns3::ObjectVectorChecker::ObjectVectorChecker() [constructor]
       
  1351     cls.add_constructor([])
       
  1352     ## object-vector.h: ns3::TypeId ns3::ObjectVectorChecker::GetItemTypeId() const [member function]
       
  1353     cls.add_method('GetItemTypeId', 
       
  1354                    'ns3::TypeId', 
       
  1355                    [], 
       
  1356                    is_pure_virtual=True, is_const=True, is_virtual=True)
       
  1357     return
  1700     return
  1358 
  1701 
  1359 def register_Ns3StringChecker_methods(root_module, cls):
  1702 def register_Ns3StringChecker_methods(root_module, cls):
  1360     ## string.h: ns3::StringChecker::StringChecker(ns3::StringChecker const & arg0) [copy constructor]
  1703     ## string.h: ns3::StringChecker::StringChecker(ns3::StringChecker const & arg0) [copy constructor]
  1361     cls.add_constructor([param('ns3::StringChecker const &', 'arg0')])
  1704     cls.add_constructor([param('ns3::StringChecker const &', 'arg0')])
  1362     ## string.h: ns3::StringChecker::StringChecker() [constructor]
  1705     ## string.h: ns3::StringChecker::StringChecker() [constructor]
  1363     cls.add_constructor([])
  1706     cls.add_constructor([])
  1364     return
  1707     return
  1365 
  1708 
  1366 def register_Ns3ObjectVectorValue_methods(root_module, cls):
  1709 def register_Ns3StringValue_methods(root_module, cls):
  1367     ## object-vector.h: ns3::ObjectVectorValue::ObjectVectorValue(ns3::ObjectVectorValue const & arg0) [copy constructor]
  1710     ## string.h: ns3::StringValue::StringValue(ns3::StringValue const & arg0) [copy constructor]
  1368     cls.add_constructor([param('ns3::ObjectVectorValue const &', 'arg0')])
  1711     cls.add_constructor([param('ns3::StringValue const &', 'arg0')])
  1369     ## object-vector.h: ns3::ObjectVectorValue::ObjectVectorValue() [constructor]
  1712     ## string.h: ns3::StringValue::StringValue() [constructor]
  1370     cls.add_constructor([])
  1713     cls.add_constructor([])
  1371     ## object-vector.h: __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Object>*,std::vector<ns3::Ptr<ns3::Object>, std::allocator<ns3::Ptr<ns3::Object> > > > ns3::ObjectVectorValue::Begin() const [member function]
  1714     ## string.h: ns3::StringValue::StringValue(std::string const & value) [constructor]
  1372     cls.add_method('Begin', 
  1715     cls.add_constructor([param('std::string const &', 'value')])
  1373                    '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Object >, std::vector< ns3::Ptr< ns3::Object > > >', 
  1716     ## string.h: void ns3::StringValue::Set(std::string const & value) [member function]
  1374                    [], 
  1717     cls.add_method('Set', 
  1375                    is_const=True)
  1718                    'void', 
  1376     ## object-vector.h: __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Object>*,std::vector<ns3::Ptr<ns3::Object>, std::allocator<ns3::Ptr<ns3::Object> > > > ns3::ObjectVectorValue::End() const [member function]
  1719                    [param('std::string const &', 'value')])
  1377     cls.add_method('End', 
  1720     ## string.h: std::string ns3::StringValue::Get() const [member function]
  1378                    '__gnu_cxx::__normal_iterator< const ns3::Ptr< ns3::Object >, std::vector< ns3::Ptr< ns3::Object > > >', 
       
  1379                    [], 
       
  1380                    is_const=True)
       
  1381     ## object-vector.h: uint32_t ns3::ObjectVectorValue::GetN() const [member function]
       
  1382     cls.add_method('GetN', 
       
  1383                    'uint32_t', 
       
  1384                    [], 
       
  1385                    is_const=True)
       
  1386     ## object-vector.h: ns3::Ptr<ns3::Object> ns3::ObjectVectorValue::Get(uint32_t i) const [member function]
       
  1387     cls.add_method('Get', 
  1721     cls.add_method('Get', 
  1388                    'ns3::Ptr< ns3::Object >', 
  1722                    'std::string', 
  1389                    [param('uint32_t', 'i')], 
  1723                    [], 
  1390                    is_const=True)
  1724                    is_const=True)
  1391     ## object-vector.h: ns3::Ptr<ns3::AttributeValue> ns3::ObjectVectorValue::Copy() const [member function]
  1725     ## string.h: ns3::Ptr<ns3::AttributeValue> ns3::StringValue::Copy() const [member function]
  1392     cls.add_method('Copy', 
  1726     cls.add_method('Copy', 
  1393                    'ns3::Ptr< ns3::AttributeValue >', 
  1727                    'ns3::Ptr< ns3::AttributeValue >', 
  1394                    [], 
  1728                    [], 
  1395                    is_const=True, is_virtual=True)
  1729                    is_const=True, is_virtual=True)
  1396     ## object-vector.h: std::string ns3::ObjectVectorValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1730     ## string.h: std::string ns3::StringValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
  1397     cls.add_method('SerializeToString', 
  1731     cls.add_method('SerializeToString', 
  1398                    'std::string', 
  1732                    'std::string', 
  1399                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1733                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1400                    is_const=True, is_virtual=True)
  1734                    is_const=True, is_virtual=True)
  1401     ## object-vector.h: bool ns3::ObjectVectorValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1735     ## string.h: bool ns3::StringValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
  1402     cls.add_method('DeserializeFromString', 
  1736     cls.add_method('DeserializeFromString', 
  1403                    'bool', 
  1737                    'bool', 
  1404                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1738                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1405                    is_virtual=True)
  1739                    is_virtual=True)
  1406     return
  1740     return
  1407 
  1741 
  1408 def register_Ns3BooleanChecker_methods(root_module, cls):
  1742 def register_Ns3TypeIdChecker_methods(root_module, cls):
  1409     ## boolean.h: ns3::BooleanChecker::BooleanChecker(ns3::BooleanChecker const & arg0) [copy constructor]
  1743     ## type-id.h: ns3::TypeIdChecker::TypeIdChecker(ns3::TypeIdChecker const & arg0) [copy constructor]
  1410     cls.add_constructor([param('ns3::BooleanChecker const &', 'arg0')])
  1744     cls.add_constructor([param('ns3::TypeIdChecker const &', 'arg0')])
  1411     ## boolean.h: ns3::BooleanChecker::BooleanChecker() [constructor]
  1745     ## type-id.h: ns3::TypeIdChecker::TypeIdChecker() [constructor]
  1412     cls.add_constructor([])
  1746     cls.add_constructor([])
       
  1747     return
       
  1748 
       
  1749 def register_Ns3TypeIdValue_methods(root_module, cls):
       
  1750     ## type-id.h: ns3::TypeIdValue::TypeIdValue(ns3::TypeIdValue const & arg0) [copy constructor]
       
  1751     cls.add_constructor([param('ns3::TypeIdValue const &', 'arg0')])
       
  1752     ## type-id.h: ns3::TypeIdValue::TypeIdValue() [constructor]
       
  1753     cls.add_constructor([])
       
  1754     ## type-id.h: ns3::TypeIdValue::TypeIdValue(ns3::TypeId const & value) [constructor]
       
  1755     cls.add_constructor([param('ns3::TypeId const &', 'value')])
       
  1756     ## type-id.h: void ns3::TypeIdValue::Set(ns3::TypeId const & value) [member function]
       
  1757     cls.add_method('Set', 
       
  1758                    'void', 
       
  1759                    [param('ns3::TypeId const &', 'value')])
       
  1760     ## type-id.h: ns3::TypeId ns3::TypeIdValue::Get() const [member function]
       
  1761     cls.add_method('Get', 
       
  1762                    'ns3::TypeId', 
       
  1763                    [], 
       
  1764                    is_const=True)
       
  1765     ## type-id.h: ns3::Ptr<ns3::AttributeValue> ns3::TypeIdValue::Copy() const [member function]
       
  1766     cls.add_method('Copy', 
       
  1767                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1768                    [], 
       
  1769                    is_const=True, is_virtual=True)
       
  1770     ## type-id.h: std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
       
  1771     cls.add_method('SerializeToString', 
       
  1772                    'std::string', 
       
  1773                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1774                    is_const=True, is_virtual=True)
       
  1775     ## type-id.h: bool ns3::TypeIdValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
       
  1776     cls.add_method('DeserializeFromString', 
       
  1777                    'bool', 
       
  1778                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1779                    is_virtual=True)
  1413     return
  1780     return
  1414 
  1781 
  1415 def register_Ns3UintegerValue_methods(root_module, cls):
  1782 def register_Ns3UintegerValue_methods(root_module, cls):
  1416     ## uinteger.h: ns3::UintegerValue::UintegerValue(ns3::UintegerValue const & arg0) [copy constructor]
  1783     ## uinteger.h: ns3::UintegerValue::UintegerValue(ns3::UintegerValue const & arg0) [copy constructor]
  1417     cls.add_constructor([param('ns3::UintegerValue const &', 'arg0')])
  1784     cls.add_constructor([param('ns3::UintegerValue const &', 'arg0')])
  1443                    'bool', 
  1810                    'bool', 
  1444                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1811                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
  1445                    is_virtual=True)
  1812                    is_virtual=True)
  1446     return
  1813     return
  1447 
  1814 
  1448 def register_Ns3ObjectVectorAccessor_methods(root_module, cls):
       
  1449     ## object-vector.h: ns3::ObjectVectorAccessor::ObjectVectorAccessor(ns3::ObjectVectorAccessor const & arg0) [copy constructor]
       
  1450     cls.add_constructor([param('ns3::ObjectVectorAccessor const &', 'arg0')])
       
  1451     ## object-vector.h: ns3::ObjectVectorAccessor::ObjectVectorAccessor() [constructor]
       
  1452     cls.add_constructor([])
       
  1453     ## object-vector.h: bool ns3::ObjectVectorAccessor::Set(ns3::ObjectBase * object, ns3::AttributeValue const & value) const [member function]
       
  1454     cls.add_method('Set', 
       
  1455                    'bool', 
       
  1456                    [param('ns3::ObjectBase *', 'object'), param('ns3::AttributeValue const &', 'value')], 
       
  1457                    is_const=True, is_virtual=True)
       
  1458     ## object-vector.h: bool ns3::ObjectVectorAccessor::Get(ns3::ObjectBase const * object, ns3::AttributeValue & value) const [member function]
       
  1459     cls.add_method('Get', 
       
  1460                    'bool', 
       
  1461                    [param('ns3::ObjectBase const *', 'object'), param('ns3::AttributeValue &', 'value')], 
       
  1462                    is_const=True, is_virtual=True)
       
  1463     ## object-vector.h: bool ns3::ObjectVectorAccessor::HasGetter() const [member function]
       
  1464     cls.add_method('HasGetter', 
       
  1465                    'bool', 
       
  1466                    [], 
       
  1467                    is_const=True, is_virtual=True)
       
  1468     ## object-vector.h: bool ns3::ObjectVectorAccessor::HasSetter() const [member function]
       
  1469     cls.add_method('HasSetter', 
       
  1470                    'bool', 
       
  1471                    [], 
       
  1472                    is_const=True, is_virtual=True)
       
  1473     ## object-vector.h: bool ns3::ObjectVectorAccessor::DoGetN(ns3::ObjectBase const * object, uint32_t * n) const [member function]
       
  1474     cls.add_method('DoGetN', 
       
  1475                    'bool', 
       
  1476                    [param('ns3::ObjectBase const *', 'object'), param('uint32_t *', 'n')], 
       
  1477                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1478     ## object-vector.h: ns3::Ptr<ns3::Object> ns3::ObjectVectorAccessor::DoGet(ns3::ObjectBase const * object, uint32_t i) const [member function]
       
  1479     cls.add_method('DoGet', 
       
  1480                    'ns3::Ptr< ns3::Object >', 
       
  1481                    [param('ns3::ObjectBase const *', 'object'), param('uint32_t', 'i')], 
       
  1482                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
       
  1483     return
       
  1484 
       
  1485 def register_Ns3PointerValue_methods(root_module, cls):
       
  1486     ## pointer.h: ns3::PointerValue::PointerValue(ns3::PointerValue const & arg0) [copy constructor]
       
  1487     cls.add_constructor([param('ns3::PointerValue const &', 'arg0')])
       
  1488     ## pointer.h: ns3::PointerValue::PointerValue() [constructor]
       
  1489     cls.add_constructor([])
       
  1490     ## pointer.h: ns3::PointerValue::PointerValue(ns3::Ptr<ns3::Object> object) [constructor]
       
  1491     cls.add_constructor([param('ns3::Ptr< ns3::Object >', 'object')])
       
  1492     ## pointer.h: void ns3::PointerValue::SetObject(ns3::Ptr<ns3::Object> object) [member function]
       
  1493     cls.add_method('SetObject', 
       
  1494                    'void', 
       
  1495                    [param('ns3::Ptr< ns3::Object >', 'object')])
       
  1496     ## pointer.h: ns3::Ptr<ns3::Object> ns3::PointerValue::GetObject() const [member function]
       
  1497     cls.add_method('GetObject', 
       
  1498                    'ns3::Ptr< ns3::Object >', 
       
  1499                    [], 
       
  1500                    is_const=True)
       
  1501     ## pointer.h: ns3::Ptr<ns3::AttributeValue> ns3::PointerValue::Copy() const [member function]
       
  1502     cls.add_method('Copy', 
       
  1503                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1504                    [], 
       
  1505                    is_const=True, is_virtual=True)
       
  1506     ## pointer.h: std::string ns3::PointerValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
       
  1507     cls.add_method('SerializeToString', 
       
  1508                    'std::string', 
       
  1509                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1510                    is_const=True, is_virtual=True)
       
  1511     ## pointer.h: bool ns3::PointerValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
       
  1512     cls.add_method('DeserializeFromString', 
       
  1513                    'bool', 
       
  1514                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1515                    is_virtual=True)
       
  1516     return
       
  1517 
       
  1518 def register_Ns3ObjectFactoryChecker_methods(root_module, cls):
       
  1519     ## object-factory.h: ns3::ObjectFactoryChecker::ObjectFactoryChecker(ns3::ObjectFactoryChecker const & arg0) [copy constructor]
       
  1520     cls.add_constructor([param('ns3::ObjectFactoryChecker const &', 'arg0')])
       
  1521     ## object-factory.h: ns3::ObjectFactoryChecker::ObjectFactoryChecker() [constructor]
       
  1522     cls.add_constructor([])
       
  1523     return
       
  1524 
       
  1525 def register_Ns3TypeIdChecker_methods(root_module, cls):
       
  1526     ## type-id.h: ns3::TypeIdChecker::TypeIdChecker(ns3::TypeIdChecker const & arg0) [copy constructor]
       
  1527     cls.add_constructor([param('ns3::TypeIdChecker const &', 'arg0')])
       
  1528     ## type-id.h: ns3::TypeIdChecker::TypeIdChecker() [constructor]
       
  1529     cls.add_constructor([])
       
  1530     return
       
  1531 
       
  1532 def register_Ns3DoubleValue_methods(root_module, cls):
       
  1533     ## double.h: ns3::DoubleValue::DoubleValue(ns3::DoubleValue const & arg0) [copy constructor]
       
  1534     cls.add_constructor([param('ns3::DoubleValue const &', 'arg0')])
       
  1535     ## double.h: ns3::DoubleValue::DoubleValue() [constructor]
       
  1536     cls.add_constructor([])
       
  1537     ## double.h: ns3::DoubleValue::DoubleValue(double const & value) [constructor]
       
  1538     cls.add_constructor([param('double const &', 'value')])
       
  1539     ## double.h: void ns3::DoubleValue::Set(double const & value) [member function]
       
  1540     cls.add_method('Set', 
       
  1541                    'void', 
       
  1542                    [param('double const &', 'value')])
       
  1543     ## double.h: double ns3::DoubleValue::Get() const [member function]
       
  1544     cls.add_method('Get', 
       
  1545                    'double', 
       
  1546                    [], 
       
  1547                    is_const=True)
       
  1548     ## double.h: ns3::Ptr<ns3::AttributeValue> ns3::DoubleValue::Copy() const [member function]
       
  1549     cls.add_method('Copy', 
       
  1550                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1551                    [], 
       
  1552                    is_const=True, is_virtual=True)
       
  1553     ## double.h: std::string ns3::DoubleValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
       
  1554     cls.add_method('SerializeToString', 
       
  1555                    'std::string', 
       
  1556                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1557                    is_const=True, is_virtual=True)
       
  1558     ## double.h: bool ns3::DoubleValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
       
  1559     cls.add_method('DeserializeFromString', 
       
  1560                    'bool', 
       
  1561                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1562                    is_virtual=True)
       
  1563     return
       
  1564 
       
  1565 def register_Ns3TypeIdValue_methods(root_module, cls):
       
  1566     ## type-id.h: ns3::TypeIdValue::TypeIdValue(ns3::TypeIdValue const & arg0) [copy constructor]
       
  1567     cls.add_constructor([param('ns3::TypeIdValue const &', 'arg0')])
       
  1568     ## type-id.h: ns3::TypeIdValue::TypeIdValue() [constructor]
       
  1569     cls.add_constructor([])
       
  1570     ## type-id.h: ns3::TypeIdValue::TypeIdValue(ns3::TypeId const & value) [constructor]
       
  1571     cls.add_constructor([param('ns3::TypeId const &', 'value')])
       
  1572     ## type-id.h: void ns3::TypeIdValue::Set(ns3::TypeId const & value) [member function]
       
  1573     cls.add_method('Set', 
       
  1574                    'void', 
       
  1575                    [param('ns3::TypeId const &', 'value')])
       
  1576     ## type-id.h: ns3::TypeId ns3::TypeIdValue::Get() const [member function]
       
  1577     cls.add_method('Get', 
       
  1578                    'ns3::TypeId', 
       
  1579                    [], 
       
  1580                    is_const=True)
       
  1581     ## type-id.h: ns3::Ptr<ns3::AttributeValue> ns3::TypeIdValue::Copy() const [member function]
       
  1582     cls.add_method('Copy', 
       
  1583                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1584                    [], 
       
  1585                    is_const=True, is_virtual=True)
       
  1586     ## type-id.h: std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
       
  1587     cls.add_method('SerializeToString', 
       
  1588                    'std::string', 
       
  1589                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1590                    is_const=True, is_virtual=True)
       
  1591     ## type-id.h: bool ns3::TypeIdValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
       
  1592     cls.add_method('DeserializeFromString', 
       
  1593                    'bool', 
       
  1594                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1595                    is_virtual=True)
       
  1596     return
       
  1597 
       
  1598 def register_Ns3EnumValue_methods(root_module, cls):
       
  1599     ## enum.h: ns3::EnumValue::EnumValue(ns3::EnumValue const & arg0) [copy constructor]
       
  1600     cls.add_constructor([param('ns3::EnumValue const &', 'arg0')])
       
  1601     ## enum.h: ns3::EnumValue::EnumValue() [constructor]
       
  1602     cls.add_constructor([])
       
  1603     ## enum.h: ns3::EnumValue::EnumValue(int v) [constructor]
       
  1604     cls.add_constructor([param('int', 'v')])
       
  1605     ## enum.h: void ns3::EnumValue::Set(int v) [member function]
       
  1606     cls.add_method('Set', 
       
  1607                    'void', 
       
  1608                    [param('int', 'v')])
       
  1609     ## enum.h: int ns3::EnumValue::Get() const [member function]
       
  1610     cls.add_method('Get', 
       
  1611                    'int', 
       
  1612                    [], 
       
  1613                    is_const=True)
       
  1614     ## enum.h: ns3::Ptr<ns3::AttributeValue> ns3::EnumValue::Copy() const [member function]
       
  1615     cls.add_method('Copy', 
       
  1616                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1617                    [], 
       
  1618                    is_const=True, is_virtual=True)
       
  1619     ## enum.h: std::string ns3::EnumValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
       
  1620     cls.add_method('SerializeToString', 
       
  1621                    'std::string', 
       
  1622                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1623                    is_const=True, is_virtual=True)
       
  1624     ## enum.h: bool ns3::EnumValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
       
  1625     cls.add_method('DeserializeFromString', 
       
  1626                    'bool', 
       
  1627                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1628                    is_virtual=True)
       
  1629     return
       
  1630 
       
  1631 def register_Ns3RandomVariableValue_methods(root_module, cls):
       
  1632     ## random-variable.h: ns3::RandomVariableValue::RandomVariableValue(ns3::RandomVariableValue const & arg0) [copy constructor]
       
  1633     cls.add_constructor([param('ns3::RandomVariableValue const &', 'arg0')])
       
  1634     ## random-variable.h: ns3::RandomVariableValue::RandomVariableValue() [constructor]
       
  1635     cls.add_constructor([])
       
  1636     ## random-variable.h: ns3::RandomVariableValue::RandomVariableValue(ns3::RandomVariable const & value) [constructor]
       
  1637     cls.add_constructor([param('ns3::RandomVariable const &', 'value')])
       
  1638     ## random-variable.h: void ns3::RandomVariableValue::Set(ns3::RandomVariable const & value) [member function]
       
  1639     cls.add_method('Set', 
       
  1640                    'void', 
       
  1641                    [param('ns3::RandomVariable const &', 'value')])
       
  1642     ## random-variable.h: ns3::RandomVariable ns3::RandomVariableValue::Get() const [member function]
       
  1643     cls.add_method('Get', 
       
  1644                    'ns3::RandomVariable', 
       
  1645                    [], 
       
  1646                    is_const=True)
       
  1647     ## random-variable.h: ns3::Ptr<ns3::AttributeValue> ns3::RandomVariableValue::Copy() const [member function]
       
  1648     cls.add_method('Copy', 
       
  1649                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1650                    [], 
       
  1651                    is_const=True, is_virtual=True)
       
  1652     ## random-variable.h: std::string ns3::RandomVariableValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
       
  1653     cls.add_method('SerializeToString', 
       
  1654                    'std::string', 
       
  1655                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1656                    is_const=True, is_virtual=True)
       
  1657     ## random-variable.h: bool ns3::RandomVariableValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
       
  1658     cls.add_method('DeserializeFromString', 
       
  1659                    'bool', 
       
  1660                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1661                    is_virtual=True)
       
  1662     return
       
  1663 
       
  1664 def register_Ns3ObjectFactoryValue_methods(root_module, cls):
       
  1665     ## object-factory.h: ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactoryValue const & arg0) [copy constructor]
       
  1666     cls.add_constructor([param('ns3::ObjectFactoryValue const &', 'arg0')])
       
  1667     ## object-factory.h: ns3::ObjectFactoryValue::ObjectFactoryValue() [constructor]
       
  1668     cls.add_constructor([])
       
  1669     ## object-factory.h: ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactory const & value) [constructor]
       
  1670     cls.add_constructor([param('ns3::ObjectFactory const &', 'value')])
       
  1671     ## object-factory.h: void ns3::ObjectFactoryValue::Set(ns3::ObjectFactory const & value) [member function]
       
  1672     cls.add_method('Set', 
       
  1673                    'void', 
       
  1674                    [param('ns3::ObjectFactory const &', 'value')])
       
  1675     ## object-factory.h: ns3::ObjectFactory ns3::ObjectFactoryValue::Get() const [member function]
       
  1676     cls.add_method('Get', 
       
  1677                    'ns3::ObjectFactory', 
       
  1678                    [], 
       
  1679                    is_const=True)
       
  1680     ## object-factory.h: ns3::Ptr<ns3::AttributeValue> ns3::ObjectFactoryValue::Copy() const [member function]
       
  1681     cls.add_method('Copy', 
       
  1682                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1683                    [], 
       
  1684                    is_const=True, is_virtual=True)
       
  1685     ## object-factory.h: std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
       
  1686     cls.add_method('SerializeToString', 
       
  1687                    'std::string', 
       
  1688                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1689                    is_const=True, is_virtual=True)
       
  1690     ## object-factory.h: bool ns3::ObjectFactoryValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
       
  1691     cls.add_method('DeserializeFromString', 
       
  1692                    'bool', 
       
  1693                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1694                    is_virtual=True)
       
  1695     return
       
  1696 
       
  1697 def register_Ns3IntegerValue_methods(root_module, cls):
       
  1698     ## integer.h: ns3::IntegerValue::IntegerValue(ns3::IntegerValue const & arg0) [copy constructor]
       
  1699     cls.add_constructor([param('ns3::IntegerValue const &', 'arg0')])
       
  1700     ## integer.h: ns3::IntegerValue::IntegerValue() [constructor]
       
  1701     cls.add_constructor([])
       
  1702     ## integer.h: ns3::IntegerValue::IntegerValue(int64_t const & value) [constructor]
       
  1703     cls.add_constructor([param('int64_t const &', 'value')])
       
  1704     ## integer.h: void ns3::IntegerValue::Set(int64_t const & value) [member function]
       
  1705     cls.add_method('Set', 
       
  1706                    'void', 
       
  1707                    [param('int64_t const &', 'value')])
       
  1708     ## integer.h: int64_t ns3::IntegerValue::Get() const [member function]
       
  1709     cls.add_method('Get', 
       
  1710                    'int64_t', 
       
  1711                    [], 
       
  1712                    is_const=True)
       
  1713     ## integer.h: ns3::Ptr<ns3::AttributeValue> ns3::IntegerValue::Copy() const [member function]
       
  1714     cls.add_method('Copy', 
       
  1715                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1716                    [], 
       
  1717                    is_const=True, is_virtual=True)
       
  1718     ## integer.h: std::string ns3::IntegerValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
       
  1719     cls.add_method('SerializeToString', 
       
  1720                    'std::string', 
       
  1721                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1722                    is_const=True, is_virtual=True)
       
  1723     ## integer.h: bool ns3::IntegerValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
       
  1724     cls.add_method('DeserializeFromString', 
       
  1725                    'bool', 
       
  1726                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1727                    is_virtual=True)
       
  1728     return
       
  1729 
       
  1730 def register_Ns3BooleanValue_methods(root_module, cls):
       
  1731     ## boolean.h: ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [copy constructor]
       
  1732     cls.add_constructor([param('ns3::BooleanValue const &', 'arg0')])
       
  1733     ## boolean.h: ns3::BooleanValue::BooleanValue() [constructor]
       
  1734     cls.add_constructor([])
       
  1735     ## boolean.h: ns3::BooleanValue::BooleanValue(bool value) [constructor]
       
  1736     cls.add_constructor([param('bool', 'value')])
       
  1737     ## boolean.h: ns3::Ptr<ns3::AttributeValue> ns3::BooleanValue::Copy() const [member function]
       
  1738     cls.add_method('Copy', 
       
  1739                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1740                    [], 
       
  1741                    is_const=True, is_virtual=True)
       
  1742     ## boolean.h: bool ns3::BooleanValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
       
  1743     cls.add_method('DeserializeFromString', 
       
  1744                    'bool', 
       
  1745                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1746                    is_virtual=True)
       
  1747     ## boolean.h: bool ns3::BooleanValue::Get() const [member function]
       
  1748     cls.add_method('Get', 
       
  1749                    'bool', 
       
  1750                    [], 
       
  1751                    is_const=True)
       
  1752     ## boolean.h: std::string ns3::BooleanValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
       
  1753     cls.add_method('SerializeToString', 
       
  1754                    'std::string', 
       
  1755                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1756                    is_const=True, is_virtual=True)
       
  1757     ## boolean.h: void ns3::BooleanValue::Set(bool value) [member function]
       
  1758     cls.add_method('Set', 
       
  1759                    'void', 
       
  1760                    [param('bool', 'value')])
       
  1761     cls.add_output_stream_operator()
       
  1762     return
       
  1763 
       
  1764 def register_Ns3StringValue_methods(root_module, cls):
       
  1765     ## string.h: ns3::StringValue::StringValue(ns3::StringValue const & arg0) [copy constructor]
       
  1766     cls.add_constructor([param('ns3::StringValue const &', 'arg0')])
       
  1767     ## string.h: ns3::StringValue::StringValue() [constructor]
       
  1768     cls.add_constructor([])
       
  1769     ## string.h: ns3::StringValue::StringValue(std::string const & value) [constructor]
       
  1770     cls.add_constructor([param('std::string const &', 'value')])
       
  1771     ## string.h: void ns3::StringValue::Set(std::string const & value) [member function]
       
  1772     cls.add_method('Set', 
       
  1773                    'void', 
       
  1774                    [param('std::string const &', 'value')])
       
  1775     ## string.h: std::string ns3::StringValue::Get() const [member function]
       
  1776     cls.add_method('Get', 
       
  1777                    'std::string', 
       
  1778                    [], 
       
  1779                    is_const=True)
       
  1780     ## string.h: ns3::Ptr<ns3::AttributeValue> ns3::StringValue::Copy() const [member function]
       
  1781     cls.add_method('Copy', 
       
  1782                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1783                    [], 
       
  1784                    is_const=True, is_virtual=True)
       
  1785     ## string.h: std::string ns3::StringValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
       
  1786     cls.add_method('SerializeToString', 
       
  1787                    'std::string', 
       
  1788                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1789                    is_const=True, is_virtual=True)
       
  1790     ## string.h: bool ns3::StringValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
       
  1791     cls.add_method('DeserializeFromString', 
       
  1792                    'bool', 
       
  1793                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1794                    is_virtual=True)
       
  1795     return
       
  1796 
       
  1797 def register_Ns3EmptyAttributeValue_methods(root_module, cls):
       
  1798     ## attribute.h: ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [copy constructor]
       
  1799     cls.add_constructor([param('ns3::EmptyAttributeValue const &', 'arg0')])
       
  1800     ## attribute.h: ns3::EmptyAttributeValue::EmptyAttributeValue() [constructor]
       
  1801     cls.add_constructor([])
       
  1802     ## attribute.h: ns3::Ptr<ns3::AttributeValue> ns3::EmptyAttributeValue::Copy() const [member function]
       
  1803     cls.add_method('Copy', 
       
  1804                    'ns3::Ptr< ns3::AttributeValue >', 
       
  1805                    [], 
       
  1806                    is_const=True, visibility='private', is_virtual=True)
       
  1807     ## attribute.h: std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
       
  1808     cls.add_method('SerializeToString', 
       
  1809                    'std::string', 
       
  1810                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1811                    is_const=True, visibility='private', is_virtual=True)
       
  1812     ## attribute.h: bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
       
  1813     cls.add_method('DeserializeFromString', 
       
  1814                    'bool', 
       
  1815                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
       
  1816                    visibility='private', is_virtual=True)
       
  1817     return
       
  1818 
       
  1819 def register_Ns3TracedValue__Unsigned_int_methods(root_module, cls):
  1815 def register_Ns3TracedValue__Unsigned_int_methods(root_module, cls):
  1820     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue() [constructor]
  1816     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue() [constructor]
  1821     cls.add_constructor([])
  1817     cls.add_constructor([])
  1822     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::TracedValue<unsigned int> const & o) [copy constructor]
  1818     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::TracedValue<unsigned int> const & o) [copy constructor]
  1823     cls.add_constructor([param('ns3::TracedValue< unsigned int >', 'o')])
  1819     cls.add_constructor([param('ns3::TracedValue< unsigned int > const &', 'o')])
  1824     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(unsigned int const & v) [constructor]
  1820     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(unsigned int const & v) [constructor]
  1825     cls.add_constructor([param('unsigned int const &', 'v')])
  1821     cls.add_constructor([param('unsigned int const &', 'v')])
  1826     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::IntegerValue const & value) [constructor]
  1822     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::IntegerValue const & value) [constructor]
  1827     cls.add_constructor([param('ns3::IntegerValue const &', 'value')])
  1823     cls.add_constructor([param('ns3::IntegerValue const &', 'value')])
  1828     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::UintegerValue const & value) [constructor]
  1824     ## traced-value.h: ns3::TracedValue<unsigned int>::TracedValue(ns3::UintegerValue const & value) [constructor]
  1854     ## traced-value.h: unsigned int ns3::TracedValue<unsigned int>::Get() const [member function]
  1850     ## traced-value.h: unsigned int ns3::TracedValue<unsigned int>::Get() const [member function]
  1855     cls.add_method('Get', 
  1851     cls.add_method('Get', 
  1856                    'unsigned int', 
  1852                    'unsigned int', 
  1857                    [], 
  1853                    [], 
  1858                    is_const=True)
  1854                    is_const=True)
  1859     cls.add_copy_constructor()
       
  1860     return
  1855     return
  1861 
  1856 
  1862 def register_functions(root_module):
  1857 def register_functions(root_module):
  1863     module = root_module
  1858     module = root_module
  1864     ## boolean.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeBooleanChecker() [free function]
  1859     ## boolean.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeBooleanChecker() [free function]