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

     2 

     3 

     4 import pybindgen.settings

     5 import warnings

     6 

     7 class ErrorHandler(pybindgen.settings.ErrorHandler):

     8     def handle_error(self, wrapper, exception, traceback_):

     9         warnings.warn("exception %r in wrapper %s" % (exception, wrapper))

    10         return True

    11 pybindgen.settings.error_handler = ErrorHandler()

    12 

    13 

    14 import sys

    15 

    16 def module_init():

    17     root_module = Module('ns.mobility', cpp_namespace='::ns3')

    18     return root_module

    19 

    20 def register_types(module):

    21     root_module = module.get_root()

    22     

    23     ## address.h (module 'network'): ns3::Address [class]

    24     module.add_class('Address', import_from_module='ns.network')

    25     ## address.h (module 'network'): ns3::Address::MaxSize_e [enumeration]

    26     module.add_enum('MaxSize_e', ['MAX_SIZE'], outer_class=root_module['ns3::Address'], import_from_module='ns.network')

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

    28     module.add_class('AttributeList', import_from_module='ns.core')

    29     ## box.h (module 'mobility'): ns3::Box [class]

    30     module.add_class('Box')

    31     ## box.h (module 'mobility'): ns3::Box::Side [enumeration]

    32     module.add_enum('Side', ['RIGHT', 'LEFT', 'TOP', 'BOTTOM', 'UP', 'DOWN'], outer_class=root_module['ns3::Box'])

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

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

    35     ## constant-velocity-helper.h (module 'mobility'): ns3::ConstantVelocityHelper [class]

    36     module.add_class('ConstantVelocityHelper')

    37     ## event-id.h (module 'core'): ns3::EventId [class]

    38     module.add_class('EventId', import_from_module='ns.core')

    39     ## high-precision-128.h (module 'core'): ns3::HighPrecision [class]

    40     module.add_class('HighPrecision', import_from_module='ns.core')

    41     ## ipv4-address.h (module 'network'): ns3::Ipv4Address [class]

    42     module.add_class('Ipv4Address', import_from_module='ns.network')

    43     ## ipv4-address.h (module 'network'): ns3::Ipv4Address [class]

    44     root_module['ns3::Ipv4Address'].implicitly_converts_to(root_module['ns3::Address'])

    45     ## ipv4-address.h (module 'network'): ns3::Ipv4Mask [class]

    46     module.add_class('Ipv4Mask', import_from_module='ns.network')

    47     ## ipv6-address.h (module 'network'): ns3::Ipv6Address [class]

    48     module.add_class('Ipv6Address', import_from_module='ns.network')

    49     ## ipv6-address.h (module 'network'): ns3::Ipv6Address [class]

    50     root_module['ns3::Ipv6Address'].implicitly_converts_to(root_module['ns3::Address'])

    51     ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix [class]

    52     module.add_class('Ipv6Prefix', import_from_module='ns.network')

    53     ## mobility-helper.h (module 'mobility'): ns3::MobilityHelper [class]

    54     module.add_class('MobilityHelper')

    55     ## node-container.h (module 'network'): ns3::NodeContainer [class]

    56     module.add_class('NodeContainer', import_from_module='ns.network')

    57     ## ns2-mobility-helper.h (module 'mobility'): ns3::Ns2MobilityHelper [class]

    58     module.add_class('Ns2MobilityHelper')

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

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

    61     ## object.h (module 'core'): ns3::ObjectDeleter [struct]

    62     module.add_class('ObjectDeleter', import_from_module='ns.core')

    63     ## object-factory.h (module 'core'): ns3::ObjectFactory [class]

    64     module.add_class('ObjectFactory', import_from_module='ns.core')

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

    66     module.add_class('RandomVariable', import_from_module='ns.core')

    67     ## rectangle.h (module 'mobility'): ns3::Rectangle [class]

    68     module.add_class('Rectangle')

    69     ## rectangle.h (module 'mobility'): ns3::Rectangle::Side [enumeration]

    70     module.add_enum('Side', ['RIGHT', 'LEFT', 'TOP', 'BOTTOM'], outer_class=root_module['ns3::Rectangle'])

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

    72     module.add_class('SeedManager', import_from_module='ns.core')

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

    74     module.add_class('SequentialVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

    75     ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter> [class]

    76     module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::Object', 'ns3::ObjectBase', 'ns3::ObjectDeleter'], parent=root_module['ns3::ObjectBase'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))

    77     ## tag-buffer.h (module 'network'): ns3::TagBuffer [class]

    78     module.add_class('TagBuffer', import_from_module='ns.network')

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

    80     module.add_class('Time', import_from_module='ns.core')

    81     ## nstime.h (module 'core'): ns3::Time::Unit [enumeration]

    82     module.add_enum('Unit', ['S', 'MS', 'US', 'NS', 'PS', 'FS', 'LAST'], outer_class=root_module['ns3::Time'], import_from_module='ns.core')

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

    84     module.add_class('TriangularVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

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

    86     module.add_class('TypeId', import_from_module='ns.core')

    87     ## type-id.h (module 'core'): ns3::TypeId::AttributeFlag [enumeration]

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

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

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

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

    92     module.add_class('UniformVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

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

    94     module.add_class('UnsafeAttributeList', import_from_module='ns.core')

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

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

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

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

    99     ## waypoint.h (module 'mobility'): ns3::Waypoint [class]

   100     module.add_class('Waypoint')

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

   102     module.add_class('WeibullVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

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

   104     module.add_class('ZetaVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

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

   106     module.add_class('ZipfVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

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

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

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

   110     module.add_class('ConstantVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

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

   112     module.add_class('DeterministicVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

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

   114     module.add_class('EmpiricalVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

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

   116     module.add_class('ErlangVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

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

   118     module.add_class('ExponentialVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

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

   120     module.add_class('GammaVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

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

   122     module.add_class('IntEmpiricalVariable', import_from_module='ns.core', parent=root_module['ns3::EmpiricalVariable'])

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

   124     module.add_class('LogNormalVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

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

   126     module.add_class('NormalVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

   127     ## object.h (module 'core'): ns3::Object [class]

   128     module.add_class('Object', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter >'])

   129     ## object.h (module 'core'): ns3::Object::AggregateIterator [class]

   130     module.add_class('AggregateIterator', import_from_module='ns.core', outer_class=root_module['ns3::Object'])

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

   132     module.add_class('ParetoVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

   133     ## position-allocator.h (module 'mobility'): ns3::PositionAllocator [class]

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

   135     ## position-allocator.h (module 'mobility'): ns3::RandomBoxPositionAllocator [class]

   136     module.add_class('RandomBoxPositionAllocator', parent=root_module['ns3::PositionAllocator'])

   137     ## position-allocator.h (module 'mobility'): ns3::RandomDiscPositionAllocator [class]

   138     module.add_class('RandomDiscPositionAllocator', parent=root_module['ns3::PositionAllocator'])

   139     ## position-allocator.h (module 'mobility'): ns3::RandomRectanglePositionAllocator [class]

   140     module.add_class('RandomRectanglePositionAllocator', parent=root_module['ns3::PositionAllocator'])

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

   142     module.add_class('Scalar', import_from_module='ns.core')

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

   144     root_module['ns3::Scalar'].implicitly_converts_to(root_module['ns3::Time'])

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

   146     module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::AttributeAccessor', 'ns3::empty', 'ns3::DefaultDeleter<ns3::AttributeAccessor>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))

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

   148     module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::AttributeChecker', 'ns3::empty', 'ns3::DefaultDeleter<ns3::AttributeChecker>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))

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

   150     module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::AttributeValue', 'ns3::empty', 'ns3::DefaultDeleter<ns3::AttributeValue>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))

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

   152     module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::CallbackImplBase', 'ns3::empty', 'ns3::DefaultDeleter<ns3::CallbackImplBase>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))

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

   154     module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::EventImpl', 'ns3::empty', 'ns3::DefaultDeleter<ns3::EventImpl>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))

   155     ## position-allocator.h (module 'mobility'): ns3::UniformDiscPositionAllocator [class]

   156     module.add_class('UniformDiscPositionAllocator', parent=root_module['ns3::PositionAllocator'])

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

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

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

   160     module.add_class('AttributeChecker', allow_subclassing=False, automatic_type_narrowing=True, import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> >'])

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

   162     module.add_class('AttributeValue', allow_subclassing=False, automatic_type_narrowing=True, import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> >'])

   163     ## box.h (module 'mobility'): ns3::BoxChecker [class]

   164     module.add_class('BoxChecker', parent=root_module['ns3::AttributeChecker'])

   165     ## box.h (module 'mobility'): ns3::BoxValue [class]

   166     module.add_class('BoxValue', parent=root_module['ns3::AttributeValue'])

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

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

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

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

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

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

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

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

   175     ## event-impl.h (module 'core'): ns3::EventImpl [class]

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

   177     ## position-allocator.h (module 'mobility'): ns3::GridPositionAllocator [class]

   178     module.add_class('GridPositionAllocator', parent=root_module['ns3::PositionAllocator'])

   179     ## position-allocator.h (module 'mobility'): ns3::GridPositionAllocator::LayoutType [enumeration]

   180     module.add_enum('LayoutType', ['ROW_FIRST', 'COLUMN_FIRST'], outer_class=root_module['ns3::GridPositionAllocator'])

   181     ## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker [class]

   182     module.add_class('Ipv4AddressChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker'])

   183     ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue [class]

   184     module.add_class('Ipv4AddressValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue'])

   185     ## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker [class]

   186     module.add_class('Ipv4MaskChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker'])

   187     ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue [class]

   188     module.add_class('Ipv4MaskValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue'])

   189     ## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker [class]

   190     module.add_class('Ipv6AddressChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker'])

   191     ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue [class]

   192     module.add_class('Ipv6AddressValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue'])

   193     ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker [class]

   194     module.add_class('Ipv6PrefixChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker'])

   195     ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue [class]

   196     module.add_class('Ipv6PrefixValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue'])

   197     ## position-allocator.h (module 'mobility'): ns3::ListPositionAllocator [class]

   198     module.add_class('ListPositionAllocator', parent=root_module['ns3::PositionAllocator'])

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

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

   201     ## net-device.h (module 'network'): ns3::NetDevice [class]

   202     module.add_class('NetDevice', import_from_module='ns.network', parent=root_module['ns3::Object'])

   203     ## net-device.h (module 'network'): ns3::NetDevice::PacketType [enumeration]

   204     module.add_enum('PacketType', ['PACKET_HOST', 'NS3_PACKET_HOST', 'PACKET_BROADCAST', 'NS3_PACKET_BROADCAST', 'PACKET_MULTICAST', 'NS3_PACKET_MULTICAST', 'PACKET_OTHERHOST', 'NS3_PACKET_OTHERHOST'], outer_class=root_module['ns3::NetDevice'], import_from_module='ns.network')

   205     ## node.h (module 'network'): ns3::Node [class]

   206     module.add_class('Node', import_from_module='ns.network', parent=root_module['ns3::Object'])

   207     ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker [class]

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

   209     ## object-factory.h (module 'core'): ns3::ObjectFactoryValue [class]

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

   211     ## random-direction-2d-mobility-model.h (module 'mobility'): ns3::RandomDirection2dMobilityModel [class]

   212     module.add_class('RandomDirection2dMobilityModel', parent=root_module['ns3::MobilityModel'])

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

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

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

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

   217     ## random-walk-2d-mobility-model.h (module 'mobility'): ns3::RandomWalk2dMobilityModel [class]

   218     module.add_class('RandomWalk2dMobilityModel', parent=root_module['ns3::MobilityModel'])

   219     ## random-walk-2d-mobility-model.h (module 'mobility'): ns3::RandomWalk2dMobilityModel::Mode [enumeration]

   220     module.add_enum('Mode', ['MODE_DISTANCE', 'MODE_TIME'], outer_class=root_module['ns3::RandomWalk2dMobilityModel'])

   221     ## random-waypoint-mobility-model.h (module 'mobility'): ns3::RandomWaypointMobilityModel [class]

   222     module.add_class('RandomWaypointMobilityModel', parent=root_module['ns3::MobilityModel'])

   223     ## rectangle.h (module 'mobility'): ns3::RectangleChecker [class]

   224     module.add_class('RectangleChecker', parent=root_module['ns3::AttributeChecker'])

   225     ## rectangle.h (module 'mobility'): ns3::RectangleValue [class]

   226     module.add_class('RectangleValue', parent=root_module['ns3::AttributeValue'])

   227     ## steady-state-random-waypoint-mobility-model.h (module 'mobility'): ns3::SteadyStateRandomWaypointMobilityModel [class]

   228     module.add_class('SteadyStateRandomWaypointMobilityModel', parent=root_module['ns3::MobilityModel'])

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

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

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

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

   233     ## type-id.h (module 'core'): ns3::TypeIdChecker [class]

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

   235     ## type-id.h (module 'core'): ns3::TypeIdValue [class]

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

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

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

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

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

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

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

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

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

   245     ## waypoint.h (module 'mobility'): ns3::WaypointChecker [class]

   246     module.add_class('WaypointChecker', parent=root_module['ns3::AttributeChecker'])

   247     ## waypoint-mobility-model.h (module 'mobility'): ns3::WaypointMobilityModel [class]

   248     module.add_class('WaypointMobilityModel', parent=root_module['ns3::MobilityModel'])

   249     ## waypoint.h (module 'mobility'): ns3::WaypointValue [class]

   250     module.add_class('WaypointValue', parent=root_module['ns3::AttributeValue'])

   251     ## address.h (module 'network'): ns3::AddressChecker [class]

   252     module.add_class('AddressChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker'])

   253     ## address.h (module 'network'): ns3::AddressValue [class]

   254     module.add_class('AddressValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue'])

   255     ## constant-acceleration-mobility-model.h (module 'mobility'): ns3::ConstantAccelerationMobilityModel [class]

   256     module.add_class('ConstantAccelerationMobilityModel', parent=root_module['ns3::MobilityModel'])

   257     ## constant-position-mobility-model.h (module 'mobility'): ns3::ConstantPositionMobilityModel [class]

   258     module.add_class('ConstantPositionMobilityModel', parent=root_module['ns3::MobilityModel'])

   259     ## constant-velocity-mobility-model.h (module 'mobility'): ns3::ConstantVelocityMobilityModel [class]

   260     module.add_class('ConstantVelocityMobilityModel', parent=root_module['ns3::MobilityModel'])

   261     ## gauss-markov-mobility-model.h (module 'mobility'): ns3::GaussMarkovMobilityModel [class]

   262     module.add_class('GaussMarkovMobilityModel', parent=root_module['ns3::MobilityModel'])

   263     ## hierarchical-mobility-model.h (module 'mobility'): ns3::HierarchicalMobilityModel [class]

   264     module.add_class('HierarchicalMobilityModel', parent=root_module['ns3::MobilityModel'])

   265     typehandlers.add_type_alias('ns3::Time', 'ns3::TimeSquare')

   266     typehandlers.add_type_alias('ns3::Time*', 'ns3::TimeSquare*')

   267     typehandlers.add_type_alias('ns3::Time&', 'ns3::TimeSquare&')

   268     module.add_typedef(root_module['ns3::Time'], 'TimeSquare')

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

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

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

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

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

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

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

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

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

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

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

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

   281     typehandlers.add_type_alias('ns3::Time', 'ns3::TimeInvert')

   282     typehandlers.add_type_alias('ns3::Time*', 'ns3::TimeInvert*')

   283     typehandlers.add_type_alias('ns3::Time&', 'ns3::TimeInvert&')

   284     module.add_typedef(root_module['ns3::Time'], 'TimeInvert')

   285     

   286     ## Register a nested module for the namespace FatalImpl

   287     

   288     nested_module = module.add_cpp_namespace('FatalImpl')

   289     register_types_ns3_FatalImpl(nested_module)

   290     

   291 

   292 def register_types_ns3_FatalImpl(module):

   293     root_module = module.get_root()

   294     

   295 

   296 def register_methods(root_module):

   297     register_Ns3Address_methods(root_module, root_module['ns3::Address'])

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

   299     register_Ns3Box_methods(root_module, root_module['ns3::Box'])

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

   301     register_Ns3ConstantVelocityHelper_methods(root_module, root_module['ns3::ConstantVelocityHelper'])

   302     register_Ns3EventId_methods(root_module, root_module['ns3::EventId'])

   303     register_Ns3HighPrecision_methods(root_module, root_module['ns3::HighPrecision'])

   304     register_Ns3Ipv4Address_methods(root_module, root_module['ns3::Ipv4Address'])

   305     register_Ns3Ipv4Mask_methods(root_module, root_module['ns3::Ipv4Mask'])

   306     register_Ns3Ipv6Address_methods(root_module, root_module['ns3::Ipv6Address'])

   307     register_Ns3Ipv6Prefix_methods(root_module, root_module['ns3::Ipv6Prefix'])

   308     register_Ns3MobilityHelper_methods(root_module, root_module['ns3::MobilityHelper'])

   309     register_Ns3NodeContainer_methods(root_module, root_module['ns3::NodeContainer'])

   310     register_Ns3Ns2MobilityHelper_methods(root_module, root_module['ns3::Ns2MobilityHelper'])

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

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

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

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

   315     register_Ns3Rectangle_methods(root_module, root_module['ns3::Rectangle'])

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

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

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

   319     register_Ns3TagBuffer_methods(root_module, root_module['ns3::TagBuffer'])

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

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

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

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

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

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

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

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

   328     register_Ns3Waypoint_methods(root_module, root_module['ns3::Waypoint'])

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

   330     register_Ns3ZetaVariable_methods(root_module, root_module['ns3::ZetaVariable'])

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   345     register_Ns3PositionAllocator_methods(root_module, root_module['ns3::PositionAllocator'])

   346     register_Ns3RandomBoxPositionAllocator_methods(root_module, root_module['ns3::RandomBoxPositionAllocator'])

   347     register_Ns3RandomDiscPositionAllocator_methods(root_module, root_module['ns3::RandomDiscPositionAllocator'])

   348     register_Ns3RandomRectanglePositionAllocator_methods(root_module, root_module['ns3::RandomRectanglePositionAllocator'])

   349     register_Ns3Scalar_methods(root_module, root_module['ns3::Scalar'])

   350     register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >'])

   351     register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeChecker__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> >'])

   352     register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeValue__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> >'])

   353     register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__lt__ns3CallbackImplBase__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> >'])

   354     register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3EventImpl__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::EventImpl, ns3::empty, ns3::DefaultDeleter<ns3::EventImpl> >'])

   355     register_Ns3UniformDiscPositionAllocator_methods(root_module, root_module['ns3::UniformDiscPositionAllocator'])

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

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

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

   359     register_Ns3BoxChecker_methods(root_module, root_module['ns3::BoxChecker'])

   360     register_Ns3BoxValue_methods(root_module, root_module['ns3::BoxValue'])

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

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

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

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

   365     register_Ns3EventImpl_methods(root_module, root_module['ns3::EventImpl'])

   366     register_Ns3GridPositionAllocator_methods(root_module, root_module['ns3::GridPositionAllocator'])

   367     register_Ns3Ipv4AddressChecker_methods(root_module, root_module['ns3::Ipv4AddressChecker'])

   368     register_Ns3Ipv4AddressValue_methods(root_module, root_module['ns3::Ipv4AddressValue'])

   369     register_Ns3Ipv4MaskChecker_methods(root_module, root_module['ns3::Ipv4MaskChecker'])

   370     register_Ns3Ipv4MaskValue_methods(root_module, root_module['ns3::Ipv4MaskValue'])

   371     register_Ns3Ipv6AddressChecker_methods(root_module, root_module['ns3::Ipv6AddressChecker'])

   372     register_Ns3Ipv6AddressValue_methods(root_module, root_module['ns3::Ipv6AddressValue'])

   373     register_Ns3Ipv6PrefixChecker_methods(root_module, root_module['ns3::Ipv6PrefixChecker'])

   374     register_Ns3Ipv6PrefixValue_methods(root_module, root_module['ns3::Ipv6PrefixValue'])

   375     register_Ns3ListPositionAllocator_methods(root_module, root_module['ns3::ListPositionAllocator'])

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

   377     register_Ns3NetDevice_methods(root_module, root_module['ns3::NetDevice'])

   378     register_Ns3Node_methods(root_module, root_module['ns3::Node'])

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

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

   381     register_Ns3RandomDirection2dMobilityModel_methods(root_module, root_module['ns3::RandomDirection2dMobilityModel'])

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

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

   384     register_Ns3RandomWalk2dMobilityModel_methods(root_module, root_module['ns3::RandomWalk2dMobilityModel'])

   385     register_Ns3RandomWaypointMobilityModel_methods(root_module, root_module['ns3::RandomWaypointMobilityModel'])

   386     register_Ns3RectangleChecker_methods(root_module, root_module['ns3::RectangleChecker'])

   387     register_Ns3RectangleValue_methods(root_module, root_module['ns3::RectangleValue'])

   388     register_Ns3SteadyStateRandomWaypointMobilityModel_methods(root_module, root_module['ns3::SteadyStateRandomWaypointMobilityModel'])

   389     register_Ns3TimeChecker_methods(root_module, root_module['ns3::TimeChecker'])

   390     register_Ns3TimeValue_methods(root_module, root_module['ns3::TimeValue'])

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

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

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

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

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

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

   397     register_Ns3WaypointChecker_methods(root_module, root_module['ns3::WaypointChecker'])

   398     register_Ns3WaypointMobilityModel_methods(root_module, root_module['ns3::WaypointMobilityModel'])

   399     register_Ns3WaypointValue_methods(root_module, root_module['ns3::WaypointValue'])

   400     register_Ns3AddressChecker_methods(root_module, root_module['ns3::AddressChecker'])

   401     register_Ns3AddressValue_methods(root_module, root_module['ns3::AddressValue'])

   402     register_Ns3ConstantAccelerationMobilityModel_methods(root_module, root_module['ns3::ConstantAccelerationMobilityModel'])

   403     register_Ns3ConstantPositionMobilityModel_methods(root_module, root_module['ns3::ConstantPositionMobilityModel'])

   404     register_Ns3ConstantVelocityMobilityModel_methods(root_module, root_module['ns3::ConstantVelocityMobilityModel'])

   405     register_Ns3GaussMarkovMobilityModel_methods(root_module, root_module['ns3::GaussMarkovMobilityModel'])

   406     register_Ns3HierarchicalMobilityModel_methods(root_module, root_module['ns3::HierarchicalMobilityModel'])

   407     return

   408 

   409 def register_Ns3Address_methods(root_module, cls):

   410     cls.add_binary_comparison_operator('<')

   411     cls.add_binary_comparison_operator('!=')

   412     cls.add_output_stream_operator()

   413     cls.add_binary_comparison_operator('==')

   414     ## address.h (module 'network'): ns3::Address::Address() [constructor]

   415     cls.add_constructor([])

   416     ## address.h (module 'network'): ns3::Address::Address(uint8_t type, uint8_t const * buffer, uint8_t len) [constructor]

   417     cls.add_constructor([param('uint8_t', 'type'), param('uint8_t const *', 'buffer'), param('uint8_t', 'len')])

   418     ## address.h (module 'network'): ns3::Address::Address(ns3::Address const & address) [copy constructor]

   419     cls.add_constructor([param('ns3::Address const &', 'address')])

   420     ## address.h (module 'network'): bool ns3::Address::CheckCompatible(uint8_t type, uint8_t len) const [member function]

   421     cls.add_method('CheckCompatible', 

   422                    'bool', 

   423                    [param('uint8_t', 'type'), param('uint8_t', 'len')], 

   424                    is_const=True)

   425     ## address.h (module 'network'): uint32_t ns3::Address::CopyAllFrom(uint8_t const * buffer, uint8_t len) [member function]

   426     cls.add_method('CopyAllFrom', 

   427                    'uint32_t', 

   428                    [param('uint8_t const *', 'buffer'), param('uint8_t', 'len')])

   429     ## address.h (module 'network'): uint32_t ns3::Address::CopyAllTo(uint8_t * buffer, uint8_t len) const [member function]

   430     cls.add_method('CopyAllTo', 

   431                    'uint32_t', 

   432                    [param('uint8_t *', 'buffer'), param('uint8_t', 'len')], 

   433                    is_const=True)

   434     ## address.h (module 'network'): uint32_t ns3::Address::CopyFrom(uint8_t const * buffer, uint8_t len) [member function]

   435     cls.add_method('CopyFrom', 

   436                    'uint32_t', 

   437                    [param('uint8_t const *', 'buffer'), param('uint8_t', 'len')])

   438     ## address.h (module 'network'): uint32_t ns3::Address::CopyTo(uint8_t * buffer) const [member function]

   439     cls.add_method('CopyTo', 

   440                    'uint32_t', 

   441                    [param('uint8_t *', 'buffer')], 

   442                    is_const=True)

   443     ## address.h (module 'network'): void ns3::Address::Deserialize(ns3::TagBuffer buffer) [member function]

   444     cls.add_method('Deserialize', 

   445                    'void', 

   446                    [param('ns3::TagBuffer', 'buffer')])

   447     ## address.h (module 'network'): uint8_t ns3::Address::GetLength() const [member function]

   448     cls.add_method('GetLength', 

   449                    'uint8_t', 

   450                    [], 

   451                    is_const=True)

   452     ## address.h (module 'network'): uint32_t ns3::Address::GetSerializedSize() const [member function]

   453     cls.add_method('GetSerializedSize', 

   454                    'uint32_t', 

   455                    [], 

   456                    is_const=True)

   457     ## address.h (module 'network'): bool ns3::Address::IsInvalid() const [member function]

   458     cls.add_method('IsInvalid', 

   459                    'bool', 

   460                    [], 

   461                    is_const=True)

   462     ## address.h (module 'network'): bool ns3::Address::IsMatchingType(uint8_t type) const [member function]

   463     cls.add_method('IsMatchingType', 

   464                    'bool', 

   465                    [param('uint8_t', 'type')], 

   466                    is_const=True)

   467     ## address.h (module 'network'): static uint8_t ns3::Address::Register() [member function]

   468     cls.add_method('Register', 

   469                    'uint8_t', 

   470                    [], 

   471                    is_static=True)

   472     ## address.h (module 'network'): void ns3::Address::Serialize(ns3::TagBuffer buffer) const [member function]

   473     cls.add_method('Serialize', 

   474                    'void', 

   475                    [param('ns3::TagBuffer', 'buffer')], 

   476                    is_const=True)

   477     return

   478 

   479 def register_Ns3AttributeList_methods(root_module, cls):

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

   481     cls.add_constructor([])

   482     ## attribute-list.h (module 'core'): ns3::AttributeList::AttributeList(ns3::AttributeList const & o) [copy constructor]

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

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

   485     cls.add_method('DeserializeFromString', 

   486                    'bool', 

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

   488     ## attribute-list.h (module 'core'): static ns3::AttributeList * ns3::AttributeList::GetGlobal() [member function]

   489     cls.add_method('GetGlobal', 

   490                    'ns3::AttributeList *', 

   491                    [], 

   492                    is_static=True)

   493     ## attribute-list.h (module 'core'): void ns3::AttributeList::Reset() [member function]

   494     cls.add_method('Reset', 

   495                    'void', 

   496                    [])

   497     ## attribute-list.h (module 'core'): std::string ns3::AttributeList::SerializeToString() const [member function]

   498     cls.add_method('SerializeToString', 

   499                    'std::string', 

   500                    [], 

   501                    is_const=True)

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

   503     cls.add_method('Set', 

   504                    'void', 

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

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

   507     cls.add_method('SetFailSafe', 

   508                    'bool', 

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

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

   511     cls.add_method('SetWithTid', 

   512                    'void', 

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

   514     return

   515 

   516 def register_Ns3Box_methods(root_module, cls):

   517     cls.add_output_stream_operator()

   518     ## box.h (module 'mobility'): ns3::Box::Box(ns3::Box const & arg0) [copy constructor]

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

   520     ## box.h (module 'mobility'): ns3::Box::Box(double _xMin, double _xMax, double _yMin, double _yMax, double _zMin, double _zMax) [constructor]

   521     cls.add_constructor([param('double', '_xMin'), param('double', '_xMax'), param('double', '_yMin'), param('double', '_yMax'), param('double', '_zMin'), param('double', '_zMax')])

   522     ## box.h (module 'mobility'): ns3::Box::Box() [constructor]

   523     cls.add_constructor([])

   524     ## box.h (module 'mobility'): ns3::Vector ns3::Box::CalculateIntersection(ns3::Vector const & current, ns3::Vector const & speed) const [member function]

   525     cls.add_method('CalculateIntersection', 

   526                    'ns3::Vector', 

   527                    [param('ns3::Vector const &', 'current'), param('ns3::Vector const &', 'speed')], 

   528                    is_const=True)

   529     ## box.h (module 'mobility'): ns3::Box::Side ns3::Box::GetClosestSide(ns3::Vector const & position) const [member function]

   530     cls.add_method('GetClosestSide', 

   531                    'ns3::Box::Side', 

   532                    [param('ns3::Vector const &', 'position')], 

   533                    is_const=True)

   534     ## box.h (module 'mobility'): bool ns3::Box::IsInside(ns3::Vector const & position) const [member function]

   535     cls.add_method('IsInside', 

   536                    'bool', 

   537                    [param('ns3::Vector const &', 'position')], 

   538                    is_const=True)

   539     ## box.h (module 'mobility'): ns3::Box::xMax [variable]

   540     cls.add_instance_attribute('xMax', 'double', is_const=False)

   541     ## box.h (module 'mobility'): ns3::Box::xMin [variable]

   542     cls.add_instance_attribute('xMin', 'double', is_const=False)

   543     ## box.h (module 'mobility'): ns3::Box::yMax [variable]

   544     cls.add_instance_attribute('yMax', 'double', is_const=False)

   545     ## box.h (module 'mobility'): ns3::Box::yMin [variable]

   546     cls.add_instance_attribute('yMin', 'double', is_const=False)

   547     ## box.h (module 'mobility'): ns3::Box::zMax [variable]

   548     cls.add_instance_attribute('zMax', 'double', is_const=False)

   549     ## box.h (module 'mobility'): ns3::Box::zMin [variable]

   550     cls.add_instance_attribute('zMin', 'double', is_const=False)

   551     return

   552 

   553 def register_Ns3CallbackBase_methods(root_module, cls):

   554     ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [copy constructor]

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

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

   557     cls.add_constructor([])

   558     ## callback.h (module 'core'): ns3::Ptr<ns3::CallbackImplBase> ns3::CallbackBase::GetImpl() const [member function]

   559     cls.add_method('GetImpl', 

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

   561                    [], 

   562                    is_const=True)

   563     ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::Ptr<ns3::CallbackImplBase> impl) [constructor]

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

   565                         visibility='protected')

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

   567     cls.add_method('Demangle', 

   568                    'std::string', 

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

   570                    is_static=True, visibility='protected')

   571     return

   572 

   573 def register_Ns3ConstantVelocityHelper_methods(root_module, cls):

   574     ## constant-velocity-helper.h (module 'mobility'): ns3::ConstantVelocityHelper::ConstantVelocityHelper(ns3::ConstantVelocityHelper const & arg0) [copy constructor]

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

   576     ## constant-velocity-helper.h (module 'mobility'): ns3::ConstantVelocityHelper::ConstantVelocityHelper() [constructor]

   577     cls.add_constructor([])

   578     ## constant-velocity-helper.h (module 'mobility'): ns3::ConstantVelocityHelper::ConstantVelocityHelper(ns3::Vector const & position) [constructor]

   579     cls.add_constructor([param('ns3::Vector const &', 'position')])

   580     ## constant-velocity-helper.h (module 'mobility'): ns3::ConstantVelocityHelper::ConstantVelocityHelper(ns3::Vector const & position, ns3::Vector const & vel) [constructor]

   581     cls.add_constructor([param('ns3::Vector const &', 'position'), param('ns3::Vector const &', 'vel')])

   582     ## constant-velocity-helper.h (module 'mobility'): ns3::Vector ns3::ConstantVelocityHelper::GetCurrentPosition() const [member function]

   583     cls.add_method('GetCurrentPosition', 

   584                    'ns3::Vector', 

   585                    [], 

   586                    is_const=True)

   587     ## constant-velocity-helper.h (module 'mobility'): ns3::Vector ns3::ConstantVelocityHelper::GetVelocity() const [member function]

   588     cls.add_method('GetVelocity', 

   589                    'ns3::Vector', 

   590                    [], 

   591                    is_const=True)

   592     ## constant-velocity-helper.h (module 'mobility'): void ns3::ConstantVelocityHelper::Pause() [member function]

   593     cls.add_method('Pause', 

   594                    'void', 

   595                    [])

   596     ## constant-velocity-helper.h (module 'mobility'): void ns3::ConstantVelocityHelper::SetPosition(ns3::Vector const & position) [member function]

   597     cls.add_method('SetPosition', 

   598                    'void', 

   599                    [param('ns3::Vector const &', 'position')])

   600     ## constant-velocity-helper.h (module 'mobility'): void ns3::ConstantVelocityHelper::SetVelocity(ns3::Vector const & vel) [member function]

   601     cls.add_method('SetVelocity', 

   602                    'void', 

   603                    [param('ns3::Vector const &', 'vel')])

   604     ## constant-velocity-helper.h (module 'mobility'): void ns3::ConstantVelocityHelper::Unpause() [member function]

   605     cls.add_method('Unpause', 

   606                    'void', 

   607                    [])

   608     ## constant-velocity-helper.h (module 'mobility'): void ns3::ConstantVelocityHelper::Update() const [member function]

   609     cls.add_method('Update', 

   610                    'void', 

   611                    [], 

   612                    is_const=True)

   613     ## constant-velocity-helper.h (module 'mobility'): void ns3::ConstantVelocityHelper::UpdateWithBounds(ns3::Rectangle const & rectangle) const [member function]

   614     cls.add_method('UpdateWithBounds', 

   615                    'void', 

   616                    [param('ns3::Rectangle const &', 'rectangle')], 

   617                    is_const=True)

   618     ## constant-velocity-helper.h (module 'mobility'): void ns3::ConstantVelocityHelper::UpdateWithBounds(ns3::Box const & bounds) const [member function]

   619     cls.add_method('UpdateWithBounds', 

   620                    'void', 

   621                    [param('ns3::Box const &', 'bounds')], 

   622                    is_const=True)

   623     return

   624 

   625 def register_Ns3EventId_methods(root_module, cls):

   626     cls.add_binary_comparison_operator('!=')

   627     cls.add_binary_comparison_operator('==')

   628     ## event-id.h (module 'core'): ns3::EventId::EventId(ns3::EventId const & arg0) [copy constructor]

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

   630     ## event-id.h (module 'core'): ns3::EventId::EventId() [constructor]

   631     cls.add_constructor([])

   632     ## event-id.h (module 'core'): ns3::EventId::EventId(ns3::Ptr<ns3::EventImpl> const & impl, uint64_t ts, uint32_t context, uint32_t uid) [constructor]

   633     cls.add_constructor([param('ns3::Ptr< ns3::EventImpl > const &', 'impl'), param('uint64_t', 'ts'), param('uint32_t', 'context'), param('uint32_t', 'uid')])

   634     ## event-id.h (module 'core'): void ns3::EventId::Cancel() [member function]

   635     cls.add_method('Cancel', 

   636                    'void', 

   637                    [])

   638     ## event-id.h (module 'core'): uint32_t ns3::EventId::GetContext() const [member function]

   639     cls.add_method('GetContext', 

   640                    'uint32_t', 

   641                    [], 

   642                    is_const=True)

   643     ## event-id.h (module 'core'): uint64_t ns3::EventId::GetTs() const [member function]

   644     cls.add_method('GetTs', 

   645                    'uint64_t', 

   646                    [], 

   647                    is_const=True)

   648     ## event-id.h (module 'core'): uint32_t ns3::EventId::GetUid() const [member function]

   649     cls.add_method('GetUid', 

   650                    'uint32_t', 

   651                    [], 

   652                    is_const=True)

   653     ## event-id.h (module 'core'): bool ns3::EventId::IsExpired() const [member function]

   654     cls.add_method('IsExpired', 

   655                    'bool', 

   656                    [], 

   657                    is_const=True)

   658     ## event-id.h (module 'core'): bool ns3::EventId::IsRunning() const [member function]

   659     cls.add_method('IsRunning', 

   660                    'bool', 

   661                    [], 

   662                    is_const=True)

   663     ## event-id.h (module 'core'): ns3::EventImpl * ns3::EventId::PeekEventImpl() const [member function]

   664     cls.add_method('PeekEventImpl', 

   665                    'ns3::EventImpl *', 

   666                    [], 

   667                    is_const=True)

   668     return

   669 

   670 def register_Ns3HighPrecision_methods(root_module, cls):

   671     cls.add_output_stream_operator()

   672     ## high-precision-128.h (module 'core'): ns3::HighPrecision::HighPrecision(ns3::HighPrecision const & arg0) [copy constructor]

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

   674     ## high-precision-128.h (module 'core'): ns3::HighPrecision::HighPrecision(int64_t high, uint64_t low) [constructor]

   675     cls.add_constructor([param('int64_t', 'high'), param('uint64_t', 'low')])

   676     ## high-precision-128.h (module 'core'): ns3::HighPrecision::HighPrecision() [constructor]

   677     cls.add_constructor([])

   678     ## high-precision-128.h (module 'core'): ns3::HighPrecision::HighPrecision(int64_t value, bool dummy) [constructor]

   679     cls.add_constructor([param('int64_t', 'value'), param('bool', 'dummy')])

   680     ## high-precision-128.h (module 'core'): ns3::HighPrecision::HighPrecision(double value) [constructor]

   681     cls.add_constructor([param('double', 'value')])

   682     ## high-precision-128.h (module 'core'): void ns3::HighPrecision::Add(ns3::HighPrecision const & o) [member function]

   683     cls.add_method('Add', 

   684                    'void', 

   685                    [param('ns3::HighPrecision const &', 'o')])

   686     ## high-precision-128.h (module 'core'): int ns3::HighPrecision::Compare(ns3::HighPrecision const & o) const [member function]

   687     cls.add_method('Compare', 

   688                    'int', 

   689                    [param('ns3::HighPrecision const &', 'o')], 

   690                    is_const=True)

   691     ## high-precision-128.h (module 'core'): void ns3::HighPrecision::Div(ns3::HighPrecision const & o) [member function]

   692     cls.add_method('Div', 

   693                    'void', 

   694                    [param('ns3::HighPrecision const &', 'o')])

   695     ## high-precision-128.h (module 'core'): double ns3::HighPrecision::GetDouble() const [member function]

   696     cls.add_method('GetDouble', 

   697                    'double', 

   698                    [], 

   699                    is_const=True)

   700     ## high-precision-128.h (module 'core'): int64_t ns3::HighPrecision::GetHigh() const [member function]

   701     cls.add_method('GetHigh', 

   702                    'int64_t', 

   703                    [], 

   704                    is_const=True)

   705     ## high-precision-128.h (module 'core'): int64_t ns3::HighPrecision::GetInteger() const [member function]

   706     cls.add_method('GetInteger', 

   707                    'int64_t', 

   708                    [], 

   709                    is_const=True)

   710     ## high-precision-128.h (module 'core'): uint64_t ns3::HighPrecision::GetLow() const [member function]

   711     cls.add_method('GetLow', 

   712                    'uint64_t', 

   713                    [], 

   714                    is_const=True)

   715     ## high-precision-128.h (module 'core'): static ns3::HighPrecision ns3::HighPrecision::Invert(uint64_t v) [member function]

   716     cls.add_method('Invert', 

   717                    'ns3::HighPrecision', 

   718                    [param('uint64_t', 'v')], 

   719                    is_static=True)

   720     ## high-precision-128.h (module 'core'): void ns3::HighPrecision::Mul(ns3::HighPrecision const & o) [member function]

   721     cls.add_method('Mul', 

   722                    'void', 

   723                    [param('ns3::HighPrecision const &', 'o')])

   724     ## high-precision-128.h (module 'core'): void ns3::HighPrecision::MulByInvert(ns3::HighPrecision const & o) [member function]

   725     cls.add_method('MulByInvert', 

   726                    'void', 

   727                    [param('ns3::HighPrecision const &', 'o')])

   728     ## high-precision-128.h (module 'core'): void ns3::HighPrecision::Sub(ns3::HighPrecision const & o) [member function]

   729     cls.add_method('Sub', 

   730                    'void', 

   731                    [param('ns3::HighPrecision const &', 'o')])

   732     ## high-precision-128.h (module 'core'): static ns3::HighPrecision ns3::HighPrecision::Zero() [member function]

   733     cls.add_method('Zero', 

   734                    'ns3::HighPrecision', 

   735                    [], 

   736                    is_static=True)

   737     return

   738 

   739 def register_Ns3Ipv4Address_methods(root_module, cls):

   740     cls.add_binary_comparison_operator('<')

   741     cls.add_binary_comparison_operator('!=')

   742     cls.add_output_stream_operator()

   743     cls.add_binary_comparison_operator('==')

   744     ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [copy constructor]

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

   746     ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address() [constructor]

   747     cls.add_constructor([])

   748     ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address(uint32_t address) [constructor]

   749     cls.add_constructor([param('uint32_t', 'address')])

   750     ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address(char const * address) [constructor]

   751     cls.add_constructor([param('char const *', 'address')])

   752     ## ipv4-address.h (module 'network'): ns3::Ipv4Address ns3::Ipv4Address::CombineMask(ns3::Ipv4Mask const & mask) const [member function]

   753     cls.add_method('CombineMask', 

   754                    'ns3::Ipv4Address', 

   755                    [param('ns3::Ipv4Mask const &', 'mask')], 

   756                    is_const=True)

   757     ## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::ConvertFrom(ns3::Address const & address) [member function]

   758     cls.add_method('ConvertFrom', 

   759                    'ns3::Ipv4Address', 

   760                    [param('ns3::Address const &', 'address')], 

   761                    is_static=True)

   762     ## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::Deserialize(uint8_t const * buf) [member function]

   763     cls.add_method('Deserialize', 

   764                    'ns3::Ipv4Address', 

   765                    [param('uint8_t const *', 'buf')], 

   766                    is_static=True)

   767     ## ipv4-address.h (module 'network'): uint32_t ns3::Ipv4Address::Get() const [member function]

   768     cls.add_method('Get', 

   769                    'uint32_t', 

   770                    [], 

   771                    is_const=True)

   772     ## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::GetAny() [member function]

   773     cls.add_method('GetAny', 

   774                    'ns3::Ipv4Address', 

   775                    [], 

   776                    is_static=True)

   777     ## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::GetBroadcast() [member function]

   778     cls.add_method('GetBroadcast', 

   779                    'ns3::Ipv4Address', 

   780                    [], 

   781                    is_static=True)

   782     ## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::GetLoopback() [member function]

   783     cls.add_method('GetLoopback', 

   784                    'ns3::Ipv4Address', 

   785                    [], 

   786                    is_static=True)

   787     ## ipv4-address.h (module 'network'): ns3::Ipv4Address ns3::Ipv4Address::GetSubnetDirectedBroadcast(ns3::Ipv4Mask const & mask) const [member function]

   788     cls.add_method('GetSubnetDirectedBroadcast', 

   789                    'ns3::Ipv4Address', 

   790                    [param('ns3::Ipv4Mask const &', 'mask')], 

   791                    is_const=True)

   792     ## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::GetZero() [member function]

   793     cls.add_method('GetZero', 

   794                    'ns3::Ipv4Address', 

   795                    [], 

   796                    is_static=True)

   797     ## ipv4-address.h (module 'network'): bool ns3::Ipv4Address::IsBroadcast() const [member function]

   798     cls.add_method('IsBroadcast', 

   799                    'bool', 

   800                    [], 

   801                    is_const=True)

   802     ## ipv4-address.h (module 'network'): bool ns3::Ipv4Address::IsEqual(ns3::Ipv4Address const & other) const [member function]

   803     cls.add_method('IsEqual', 

   804                    'bool', 

   805                    [param('ns3::Ipv4Address const &', 'other')], 

   806                    is_const=True)

   807     ## ipv4-address.h (module 'network'): bool ns3::Ipv4Address::IsLocalMulticast() const [member function]

   808     cls.add_method('IsLocalMulticast', 

   809                    'bool', 

   810                    [], 

   811                    is_const=True)

   812     ## ipv4-address.h (module 'network'): static bool ns3::Ipv4Address::IsMatchingType(ns3::Address const & address) [member function]

   813     cls.add_method('IsMatchingType', 

   814                    'bool', 

   815                    [param('ns3::Address const &', 'address')], 

   816                    is_static=True)

   817     ## ipv4-address.h (module 'network'): bool ns3::Ipv4Address::IsMulticast() const [member function]

   818     cls.add_method('IsMulticast', 

   819                    'bool', 

   820                    [], 

   821                    is_const=True)

   822     ## ipv4-address.h (module 'network'): bool ns3::Ipv4Address::IsSubnetDirectedBroadcast(ns3::Ipv4Mask const & mask) const [member function]

   823     cls.add_method('IsSubnetDirectedBroadcast', 

   824                    'bool', 

   825                    [param('ns3::Ipv4Mask const &', 'mask')], 

   826                    is_const=True)

   827     ## ipv4-address.h (module 'network'): void ns3::Ipv4Address::Print(std::ostream & os) const [member function]

   828     cls.add_method('Print', 

   829                    'void', 

   830                    [param('std::ostream &', 'os')], 

   831                    is_const=True)

   832     ## ipv4-address.h (module 'network'): void ns3::Ipv4Address::Serialize(uint8_t * buf) const [member function]

   833     cls.add_method('Serialize', 

   834                    'void', 

   835                    [param('uint8_t *', 'buf')], 

   836                    is_const=True)

   837     ## ipv4-address.h (module 'network'): void ns3::Ipv4Address::Set(uint32_t address) [member function]

   838     cls.add_method('Set', 

   839                    'void', 

   840                    [param('uint32_t', 'address')])

   841     ## ipv4-address.h (module 'network'): void ns3::Ipv4Address::Set(char const * address) [member function]

   842     cls.add_method('Set', 

   843                    'void', 

   844                    [param('char const *', 'address')])

   845     return

   846 

   847 def register_Ns3Ipv4Mask_methods(root_module, cls):

   848     cls.add_binary_comparison_operator('!=')

   849     cls.add_output_stream_operator()

   850     cls.add_binary_comparison_operator('==')

   851     ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [copy constructor]

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

   853     ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask() [constructor]

   854     cls.add_constructor([])

   855     ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask(uint32_t mask) [constructor]

   856     cls.add_constructor([param('uint32_t', 'mask')])

   857     ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask(char const * mask) [constructor]

   858     cls.add_constructor([param('char const *', 'mask')])

   859     ## ipv4-address.h (module 'network'): uint32_t ns3::Ipv4Mask::Get() const [member function]

   860     cls.add_method('Get', 

   861                    'uint32_t', 

   862                    [], 

   863                    is_const=True)

   864     ## ipv4-address.h (module 'network'): uint32_t ns3::Ipv4Mask::GetInverse() const [member function]

   865     cls.add_method('GetInverse', 

   866                    'uint32_t', 

   867                    [], 

   868                    is_const=True)

   869     ## ipv4-address.h (module 'network'): static ns3::Ipv4Mask ns3::Ipv4Mask::GetLoopback() [member function]

   870     cls.add_method('GetLoopback', 

   871                    'ns3::Ipv4Mask', 

   872                    [], 

   873                    is_static=True)

   874     ## ipv4-address.h (module 'network'): static ns3::Ipv4Mask ns3::Ipv4Mask::GetOnes() [member function]

   875     cls.add_method('GetOnes', 

   876                    'ns3::Ipv4Mask', 

   877                    [], 

   878                    is_static=True)

   879     ## ipv4-address.h (module 'network'): uint16_t ns3::Ipv4Mask::GetPrefixLength() const [member function]

   880     cls.add_method('GetPrefixLength', 

   881                    'uint16_t', 

   882                    [], 

   883                    is_const=True)

   884     ## ipv4-address.h (module 'network'): static ns3::Ipv4Mask ns3::Ipv4Mask::GetZero() [member function]

   885     cls.add_method('GetZero', 

   886                    'ns3::Ipv4Mask', 

   887                    [], 

   888                    is_static=True)

   889     ## ipv4-address.h (module 'network'): bool ns3::Ipv4Mask::IsEqual(ns3::Ipv4Mask other) const [member function]

   890     cls.add_method('IsEqual', 

   891                    'bool', 

   892                    [param('ns3::Ipv4Mask', 'other')], 

   893                    is_const=True)

   894     ## ipv4-address.h (module 'network'): bool ns3::Ipv4Mask::IsMatch(ns3::Ipv4Address a, ns3::Ipv4Address b) const [member function]

   895     cls.add_method('IsMatch', 

   896                    'bool', 

   897                    [param('ns3::Ipv4Address', 'a'), param('ns3::Ipv4Address', 'b')], 

   898                    is_const=True)

   899     ## ipv4-address.h (module 'network'): void ns3::Ipv4Mask::Print(std::ostream & os) const [member function]

   900     cls.add_method('Print', 

   901                    'void', 

   902                    [param('std::ostream &', 'os')], 

   903                    is_const=True)

   904     ## ipv4-address.h (module 'network'): void ns3::Ipv4Mask::Set(uint32_t mask) [member function]

   905     cls.add_method('Set', 

   906                    'void', 

   907                    [param('uint32_t', 'mask')])

   908     return

   909 

   910 def register_Ns3Ipv6Address_methods(root_module, cls):

   911     cls.add_binary_comparison_operator('<')

   912     cls.add_binary_comparison_operator('!=')

   913     cls.add_output_stream_operator()

   914     cls.add_binary_comparison_operator('==')

   915     ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address() [constructor]

   916     cls.add_constructor([])

   917     ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(char const * address) [constructor]

   918     cls.add_constructor([param('char const *', 'address')])

   919     ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(uint8_t * address) [constructor]

   920     cls.add_constructor([param('uint8_t *', 'address')])

   921     ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const & addr) [copy constructor]

   922     cls.add_constructor([param('ns3::Ipv6Address const &', 'addr')])

   923     ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const * addr) [constructor]

   924     cls.add_constructor([param('ns3::Ipv6Address const *', 'addr')])

   925     ## ipv6-address.h (module 'network'): ns3::Ipv6Address ns3::Ipv6Address::CombinePrefix(ns3::Ipv6Prefix const & prefix) [member function]

   926     cls.add_method('CombinePrefix', 

   927                    'ns3::Ipv6Address', 

   928                    [param('ns3::Ipv6Prefix const &', 'prefix')])

   929     ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::ConvertFrom(ns3::Address const & address) [member function]

   930     cls.add_method('ConvertFrom', 

   931                    'ns3::Ipv6Address', 

   932                    [param('ns3::Address const &', 'address')], 

   933                    is_static=True)

   934     ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::Deserialize(uint8_t const * buf) [member function]

   935     cls.add_method('Deserialize', 

   936                    'ns3::Ipv6Address', 

   937                    [param('uint8_t const *', 'buf')], 

   938                    is_static=True)

   939     ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetAllHostsMulticast() [member function]

   940     cls.add_method('GetAllHostsMulticast', 

   941                    'ns3::Ipv6Address', 

   942                    [], 

   943                    is_static=True)

   944     ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetAllNodesMulticast() [member function]

   945     cls.add_method('GetAllNodesMulticast', 

   946                    'ns3::Ipv6Address', 

   947                    [], 

   948                    is_static=True)

   949     ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetAllRoutersMulticast() [member function]

   950     cls.add_method('GetAllRoutersMulticast', 

   951                    'ns3::Ipv6Address', 

   952                    [], 

   953                    is_static=True)

   954     ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetAny() [member function]

   955     cls.add_method('GetAny', 

   956                    'ns3::Ipv6Address', 

   957                    [], 

   958                    is_static=True)

   959     ## ipv6-address.h (module 'network'): void ns3::Ipv6Address::GetBytes(uint8_t * buf) const [member function]

   960     cls.add_method('GetBytes', 

   961                    'void', 

   962                    [param('uint8_t *', 'buf')], 

   963                    is_const=True)

   964     ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetLoopback() [member function]

   965     cls.add_method('GetLoopback', 

   966                    'ns3::Ipv6Address', 

   967                    [], 

   968                    is_static=True)

   969     ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetOnes() [member function]

   970     cls.add_method('GetOnes', 

   971                    'ns3::Ipv6Address', 

   972                    [], 

   973                    is_static=True)

   974     ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetZero() [member function]

   975     cls.add_method('GetZero', 

   976                    'ns3::Ipv6Address', 

   977                    [], 

   978                    is_static=True)

   979     ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsAllHostsMulticast() const [member function]

   980     cls.add_method('IsAllHostsMulticast', 

   981                    'bool', 

   982                    [], 

   983                    is_const=True)

   984     ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsAllNodesMulticast() const [member function]

   985     cls.add_method('IsAllNodesMulticast', 

   986                    'bool', 

   987                    [], 

   988                    is_const=True)

   989     ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsAllRoutersMulticast() const [member function]

   990     cls.add_method('IsAllRoutersMulticast', 

   991                    'bool', 

   992                    [], 

   993                    is_const=True)

   994     ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsAny() const [member function]

   995     cls.add_method('IsAny', 

   996                    'bool', 

   997                    [], 

   998                    is_const=True)

   999     ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsEqual(ns3::Ipv6Address const & other) const [member function]

  1000     cls.add_method('IsEqual', 

  1001                    'bool', 

  1002                    [param('ns3::Ipv6Address const &', 'other')], 

  1003                    is_const=True)

  1004     ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsLinkLocal() const [member function]

  1005     cls.add_method('IsLinkLocal', 

  1006                    'bool', 

  1007                    [], 

  1008                    is_const=True)

  1009     ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsLocalhost() const [member function]

  1010     cls.add_method('IsLocalhost', 

  1011                    'bool', 

  1012                    [], 

  1013                    is_const=True)

  1014     ## ipv6-address.h (module 'network'): static bool ns3::Ipv6Address::IsMatchingType(ns3::Address const & address) [member function]

  1015     cls.add_method('IsMatchingType', 

  1016                    'bool', 

  1017                    [param('ns3::Address const &', 'address')], 

  1018                    is_static=True)

  1019     ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsMulticast() const [member function]

  1020     cls.add_method('IsMulticast', 

  1021                    'bool', 

  1022                    [], 

  1023                    is_const=True)

  1024     ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsSolicitedMulticast() const [member function]

  1025     cls.add_method('IsSolicitedMulticast', 

  1026                    'bool', 

  1027                    [], 

  1028                    is_const=True)

  1029     ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::MakeAutoconfiguredAddress(ns3::Mac48Address addr, ns3::Ipv6Address prefix) [member function]

  1030     cls.add_method('MakeAutoconfiguredAddress', 

  1031                    'ns3::Ipv6Address', 

  1032                    [param('ns3::Mac48Address', 'addr'), param('ns3::Ipv6Address', 'prefix')], 

  1033                    is_static=True)

  1034     ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::MakeAutoconfiguredLinkLocalAddress(ns3::Mac48Address mac) [member function]

  1035     cls.add_method('MakeAutoconfiguredLinkLocalAddress', 

  1036                    'ns3::Ipv6Address', 

  1037                    [param('ns3::Mac48Address', 'mac')], 

  1038                    is_static=True)

  1039     ## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::MakeSolicitedAddress(ns3::Ipv6Address addr) [member function]

  1040     cls.add_method('MakeSolicitedAddress', 

  1041                    'ns3::Ipv6Address', 

  1042                    [param('ns3::Ipv6Address', 'addr')], 

  1043                    is_static=True)

  1044     ## ipv6-address.h (module 'network'): void ns3::Ipv6Address::Print(std::ostream & os) const [member function]

  1045     cls.add_method('Print', 

  1046                    'void', 

  1047                    [param('std::ostream &', 'os')], 

  1048                    is_const=True)

  1049     ## ipv6-address.h (module 'network'): void ns3::Ipv6Address::Serialize(uint8_t * buf) const [member function]

  1050     cls.add_method('Serialize', 

  1051                    'void', 

  1052                    [param('uint8_t *', 'buf')], 

  1053                    is_const=True)

  1054     ## ipv6-address.h (module 'network'): void ns3::Ipv6Address::Set(char const * address) [member function]

  1055     cls.add_method('Set', 

  1056                    'void', 

  1057                    [param('char const *', 'address')])

  1058     ## ipv6-address.h (module 'network'): void ns3::Ipv6Address::Set(uint8_t * address) [member function]

  1059     cls.add_method('Set', 

  1060                    'void', 

  1061                    [param('uint8_t *', 'address')])

  1062     return

  1063 

  1064 def register_Ns3Ipv6Prefix_methods(root_module, cls):

  1065     cls.add_binary_comparison_operator('!=')

  1066     cls.add_output_stream_operator()

  1067     cls.add_binary_comparison_operator('==')

  1068     ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix() [constructor]

  1069     cls.add_constructor([])

  1070     ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(uint8_t * prefix) [constructor]

  1071     cls.add_constructor([param('uint8_t *', 'prefix')])

  1072     ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(char const * prefix) [constructor]

  1073     cls.add_constructor([param('char const *', 'prefix')])

  1074     ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(uint8_t prefix) [constructor]

  1075     cls.add_constructor([param('uint8_t', 'prefix')])

  1076     ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const & prefix) [copy constructor]

  1077     cls.add_constructor([param('ns3::Ipv6Prefix const &', 'prefix')])

  1078     ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const * prefix) [constructor]

  1079     cls.add_constructor([param('ns3::Ipv6Prefix const *', 'prefix')])

  1080     ## ipv6-address.h (module 'network'): void ns3::Ipv6Prefix::GetBytes(uint8_t * buf) const [member function]

  1081     cls.add_method('GetBytes', 

  1082                    'void', 

  1083                    [param('uint8_t *', 'buf')], 

  1084                    is_const=True)

  1085     ## ipv6-address.h (module 'network'): static ns3::Ipv6Prefix ns3::Ipv6Prefix::GetLoopback() [member function]

  1086     cls.add_method('GetLoopback', 

  1087                    'ns3::Ipv6Prefix', 

  1088                    [], 

  1089                    is_static=True)

  1090     ## ipv6-address.h (module 'network'): static ns3::Ipv6Prefix ns3::Ipv6Prefix::GetOnes() [member function]

  1091     cls.add_method('GetOnes', 

  1092                    'ns3::Ipv6Prefix', 

  1093                    [], 

  1094                    is_static=True)

  1095     ## ipv6-address.h (module 'network'): uint8_t ns3::Ipv6Prefix::GetPrefixLength() const [member function]

  1096     cls.add_method('GetPrefixLength', 

  1097                    'uint8_t', 

  1098                    [], 

  1099                    is_const=True)

  1100     ## ipv6-address.h (module 'network'): static ns3::Ipv6Prefix ns3::Ipv6Prefix::GetZero() [member function]

  1101     cls.add_method('GetZero', 

  1102                    'ns3::Ipv6Prefix', 

  1103                    [], 

  1104                    is_static=True)

  1105     ## ipv6-address.h (module 'network'): bool ns3::Ipv6Prefix::IsEqual(ns3::Ipv6Prefix const & other) const [member function]

  1106     cls.add_method('IsEqual', 

  1107                    'bool', 

  1108                    [param('ns3::Ipv6Prefix const &', 'other')], 

  1109                    is_const=True)

  1110     ## ipv6-address.h (module 'network'): bool ns3::Ipv6Prefix::IsMatch(ns3::Ipv6Address a, ns3::Ipv6Address b) const [member function]

  1111     cls.add_method('IsMatch', 

  1112                    'bool', 

  1113                    [param('ns3::Ipv6Address', 'a'), param('ns3::Ipv6Address', 'b')], 

  1114                    is_const=True)

  1115     ## ipv6-address.h (module 'network'): void ns3::Ipv6Prefix::Print(std::ostream & os) const [member function]

  1116     cls.add_method('Print', 

  1117                    'void', 

  1118                    [param('std::ostream &', 'os')], 

  1119                    is_const=True)

  1120     return

  1121 

  1122 def register_Ns3MobilityHelper_methods(root_module, cls):

  1123     ## mobility-helper.h (module 'mobility'): ns3::MobilityHelper::MobilityHelper(ns3::MobilityHelper const & arg0) [copy constructor]

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

  1125     ## mobility-helper.h (module 'mobility'): ns3::MobilityHelper::MobilityHelper() [constructor]

  1126     cls.add_constructor([])

  1127     ## mobility-helper.h (module 'mobility'): static void ns3::MobilityHelper::EnableAscii(std::ostream & os, uint32_t nodeid) [member function]

  1128     cls.add_method('EnableAscii', 

  1129                    'void', 

  1130                    [param('std::ostream &', 'os'), param('uint32_t', 'nodeid')], 

  1131                    is_static=True)

  1132     ## mobility-helper.h (module 'mobility'): static void ns3::MobilityHelper::EnableAscii(std::ostream & os, ns3::NodeContainer n) [member function]

  1133     cls.add_method('EnableAscii', 

  1134                    'void', 

  1135                    [param('std::ostream &', 'os'), param('ns3::NodeContainer', 'n')],