bindings/python/ns3_module_mobility.py
author Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
Sat, 04 Jul 2009 08:15:48 +0200
changeset 4654 2eaebe77d66b
parent 4454 f2af91ee09e7
permissions -rw-r--r--
Added tag ns-3.5 for changeset c975274c9707
     1 from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandlers
     2 
     3 def register_types(module):
     4     root_module = module.get_root()
     5     
     6     ## constant-velocity-helper.h: ns3::ConstantVelocityHelper [class]
     7     module.add_class('ConstantVelocityHelper', allow_subclassing=False)
     8     ## rectangle.h: ns3::Rectangle [class]
     9     module.add_class('Rectangle')
    10     ## rectangle.h: ns3::Rectangle::Side [enumeration]
    11     module.add_enum('Side', ['RIGHT', 'LEFT', 'TOP', 'BOTTOM'], outer_class=root_module['ns3::Rectangle'])
    12     ## vector.h: ns3::Vector [class]
    13     module.add_class('Vector')
    14     ## position-allocator.h: ns3::PositionAllocator [class]
    15     module.add_class('PositionAllocator', parent=root_module['ns3::Object'])
    16     ## position-allocator.h: ns3::RandomDiscPositionAllocator [class]
    17     module.add_class('RandomDiscPositionAllocator', parent=root_module['ns3::PositionAllocator'])
    18     ## position-allocator.h: ns3::RandomRectanglePositionAllocator [class]
    19     module.add_class('RandomRectanglePositionAllocator', parent=root_module['ns3::PositionAllocator'])
    20     ## rectangle.h: ns3::RectangleChecker [class]
    21     module.add_class('RectangleChecker', parent=root_module['ns3::AttributeChecker'])
    22     ## rectangle.h: ns3::RectangleValue [class]
    23     module.add_class('RectangleValue', parent=root_module['ns3::AttributeValue'])
    24     ## vector.h: ns3::VectorChecker [class]
    25     module.add_class('VectorChecker', parent=root_module['ns3::AttributeChecker'])
    26     ## vector.h: ns3::VectorValue [class]
    27     module.add_class('VectorValue', parent=root_module['ns3::AttributeValue'])
    28     ## position-allocator.h: ns3::GridPositionAllocator [class]
    29     module.add_class('GridPositionAllocator', parent=root_module['ns3::PositionAllocator'])
    30     ## position-allocator.h: ns3::GridPositionAllocator::LayoutType [enumeration]
    31     module.add_enum('LayoutType', ['ROW_FIRST', 'COLUMN_FIRST'], outer_class=root_module['ns3::GridPositionAllocator'])
    32     ## position-allocator.h: ns3::ListPositionAllocator [class]
    33     module.add_class('ListPositionAllocator', parent=root_module['ns3::PositionAllocator'])
    34     ## mobility-model.h: ns3::MobilityModel [class]
    35     module.add_class('MobilityModel', parent=root_module['ns3::Object'])
    36     ## random-direction-2d-mobility-model.h: ns3::RandomDirection2dMobilityModel [class]
    37     module.add_class('RandomDirection2dMobilityModel', parent=root_module['ns3::MobilityModel'])
    38     ## random-walk-2d-mobility-model.h: ns3::RandomWalk2dMobilityModel [class]
    39     module.add_class('RandomWalk2dMobilityModel', parent=root_module['ns3::MobilityModel'])
    40     ## random-walk-2d-mobility-model.h: ns3::RandomWalk2dMobilityModel::Mode [enumeration]
    41     module.add_enum('Mode', ['MODE_DISTANCE', 'MODE_TIME'], outer_class=root_module['ns3::RandomWalk2dMobilityModel'])
    42     ## random-waypoint-mobility-model.h: ns3::RandomWaypointMobilityModel [class]
    43     module.add_class('RandomWaypointMobilityModel', parent=root_module['ns3::MobilityModel'])
    44     ## constant-acceleration-mobility-model.h: ns3::ConstantAccelerationMobilityModel [class]
    45     module.add_class('ConstantAccelerationMobilityModel', parent=root_module['ns3::MobilityModel'])
    46     ## constant-position-mobility-model.h: ns3::ConstantPositionMobilityModel [class]
    47     module.add_class('ConstantPositionMobilityModel', parent=root_module['ns3::MobilityModel'])
    48     ## constant-velocity-mobility-model.h: ns3::ConstantVelocityMobilityModel [class]
    49     module.add_class('ConstantVelocityMobilityModel', parent=root_module['ns3::MobilityModel'])
    50     ## hierarchical-mobility-model.h: ns3::HierarchicalMobilityModel [class]
    51     module.add_class('HierarchicalMobilityModel', parent=root_module['ns3::MobilityModel'])
    52     
    53     ## Register a nested module for the namespace Config
    54     
    55     nested_module = module.add_cpp_namespace('Config')
    56     register_types_ns3_Config(nested_module)
    57     
    58     
    59     ## Register a nested module for the namespace TimeStepPrecision
    60     
    61     nested_module = module.add_cpp_namespace('TimeStepPrecision')
    62     register_types_ns3_TimeStepPrecision(nested_module)
    63     
    64     
    65     ## Register a nested module for the namespace addressUtils
    66     
    67     nested_module = module.add_cpp_namespace('addressUtils')
    68     register_types_ns3_addressUtils(nested_module)
    69     
    70     
    71     ## Register a nested module for the namespace internal
    72     
    73     nested_module = module.add_cpp_namespace('internal')
    74     register_types_ns3_internal(nested_module)
    75     
    76     
    77     ## Register a nested module for the namespace olsr
    78     
    79     nested_module = module.add_cpp_namespace('olsr')
    80     register_types_ns3_olsr(nested_module)
    81     
    82 
    83 def register_types_ns3_Config(module):
    84     root_module = module.get_root()
    85     
    86 
    87 def register_types_ns3_TimeStepPrecision(module):
    88     root_module = module.get_root()
    89     
    90 
    91 def register_types_ns3_addressUtils(module):
    92     root_module = module.get_root()
    93     
    94 
    95 def register_types_ns3_internal(module):
    96     root_module = module.get_root()
    97     
    98 
    99 def register_types_ns3_olsr(module):
   100     root_module = module.get_root()
   101     
   102 
   103 def register_methods(root_module):
   104     register_Ns3ConstantVelocityHelper_methods(root_module, root_module['ns3::ConstantVelocityHelper'])
   105     register_Ns3Rectangle_methods(root_module, root_module['ns3::Rectangle'])
   106     register_Ns3Vector_methods(root_module, root_module['ns3::Vector'])
   107     register_Ns3PositionAllocator_methods(root_module, root_module['ns3::PositionAllocator'])
   108     register_Ns3RandomDiscPositionAllocator_methods(root_module, root_module['ns3::RandomDiscPositionAllocator'])
   109     register_Ns3RandomRectanglePositionAllocator_methods(root_module, root_module['ns3::RandomRectanglePositionAllocator'])
   110     register_Ns3RectangleChecker_methods(root_module, root_module['ns3::RectangleChecker'])
   111     register_Ns3RectangleValue_methods(root_module, root_module['ns3::RectangleValue'])
   112     register_Ns3VectorChecker_methods(root_module, root_module['ns3::VectorChecker'])
   113     register_Ns3VectorValue_methods(root_module, root_module['ns3::VectorValue'])
   114     register_Ns3GridPositionAllocator_methods(root_module, root_module['ns3::GridPositionAllocator'])
   115     register_Ns3ListPositionAllocator_methods(root_module, root_module['ns3::ListPositionAllocator'])
   116     register_Ns3MobilityModel_methods(root_module, root_module['ns3::MobilityModel'])
   117     register_Ns3RandomDirection2dMobilityModel_methods(root_module, root_module['ns3::RandomDirection2dMobilityModel'])
   118     register_Ns3RandomWalk2dMobilityModel_methods(root_module, root_module['ns3::RandomWalk2dMobilityModel'])
   119     register_Ns3RandomWaypointMobilityModel_methods(root_module, root_module['ns3::RandomWaypointMobilityModel'])
   120     register_Ns3ConstantAccelerationMobilityModel_methods(root_module, root_module['ns3::ConstantAccelerationMobilityModel'])
   121     register_Ns3ConstantPositionMobilityModel_methods(root_module, root_module['ns3::ConstantPositionMobilityModel'])
   122     register_Ns3ConstantVelocityMobilityModel_methods(root_module, root_module['ns3::ConstantVelocityMobilityModel'])
   123     register_Ns3HierarchicalMobilityModel_methods(root_module, root_module['ns3::HierarchicalMobilityModel'])
   124     return
   125 
   126 def register_Ns3ConstantVelocityHelper_methods(root_module, cls):
   127     ## constant-velocity-helper.h: ns3::ConstantVelocityHelper::ConstantVelocityHelper(ns3::ConstantVelocityHelper const & arg0) [copy constructor]
   128     cls.add_constructor([param('ns3::ConstantVelocityHelper const &', 'arg0')])
   129     ## constant-velocity-helper.h: ns3::ConstantVelocityHelper::ConstantVelocityHelper() [constructor]
   130     cls.add_constructor([])
   131     ## constant-velocity-helper.h: ns3::ConstantVelocityHelper::ConstantVelocityHelper(ns3::Vector const & position) [constructor]
   132     cls.add_constructor([param('ns3::Vector const &', 'position')])
   133     ## constant-velocity-helper.h: ns3::ConstantVelocityHelper::ConstantVelocityHelper(ns3::Vector const & position, ns3::Vector const & vel) [constructor]
   134     cls.add_constructor([param('ns3::Vector const &', 'position'), param('ns3::Vector const &', 'vel')])
   135     ## constant-velocity-helper.h: void ns3::ConstantVelocityHelper::SetPosition(ns3::Vector const & position) [member function]
   136     cls.add_method('SetPosition', 
   137                    'void', 
   138                    [param('ns3::Vector const &', 'position')])
   139     ## constant-velocity-helper.h: ns3::Vector ns3::ConstantVelocityHelper::GetCurrentPosition() const [member function]
   140     cls.add_method('GetCurrentPosition', 
   141                    'ns3::Vector', 
   142                    [], 
   143                    is_const=True)
   144     ## constant-velocity-helper.h: ns3::Vector ns3::ConstantVelocityHelper::GetVelocity() const [member function]
   145     cls.add_method('GetVelocity', 
   146                    'ns3::Vector', 
   147                    [], 
   148                    is_const=True)
   149     ## constant-velocity-helper.h: void ns3::ConstantVelocityHelper::SetVelocity(ns3::Vector const & vel) [member function]
   150     cls.add_method('SetVelocity', 
   151                    'void', 
   152                    [param('ns3::Vector const &', 'vel')])
   153     ## constant-velocity-helper.h: void ns3::ConstantVelocityHelper::Pause() [member function]
   154     cls.add_method('Pause', 
   155                    'void', 
   156                    [])
   157     ## constant-velocity-helper.h: void ns3::ConstantVelocityHelper::Unpause() [member function]
   158     cls.add_method('Unpause', 
   159                    'void', 
   160                    [])
   161     ## constant-velocity-helper.h: void ns3::ConstantVelocityHelper::UpdateWithBounds(ns3::Rectangle const & rectangle) const [member function]
   162     cls.add_method('UpdateWithBounds', 
   163                    'void', 
   164                    [param('ns3::Rectangle const &', 'rectangle')], 
   165                    is_const=True)
   166     ## constant-velocity-helper.h: void ns3::ConstantVelocityHelper::Update() const [member function]
   167     cls.add_method('Update', 
   168                    'void', 
   169                    [], 
   170                    is_const=True)
   171     return
   172 
   173 def register_Ns3Rectangle_methods(root_module, cls):
   174     cls.add_output_stream_operator()
   175     ## rectangle.h: ns3::Rectangle::Rectangle(ns3::Rectangle const & arg0) [copy constructor]
   176     cls.add_constructor([param('ns3::Rectangle const &', 'arg0')])
   177     ## rectangle.h: ns3::Rectangle::Rectangle(double _xMin, double _xMax, double _yMin, double _yMax) [constructor]
   178     cls.add_constructor([param('double', '_xMin'), param('double', '_xMax'), param('double', '_yMin'), param('double', '_yMax')])
   179     ## rectangle.h: ns3::Rectangle::Rectangle() [constructor]
   180     cls.add_constructor([])
   181     ## rectangle.h: ns3::Vector ns3::Rectangle::CalculateIntersection(ns3::Vector const & current, ns3::Vector const & speed) const [member function]
   182     cls.add_method('CalculateIntersection', 
   183                    'ns3::Vector', 
   184                    [param('ns3::Vector const &', 'current'), param('ns3::Vector const &', 'speed')], 
   185                    is_const=True)
   186     ## rectangle.h: ns3::Rectangle::Side ns3::Rectangle::GetClosestSide(ns3::Vector const & position) const [member function]
   187     cls.add_method('GetClosestSide', 
   188                    'ns3::Rectangle::Side', 
   189                    [param('ns3::Vector const &', 'position')], 
   190                    is_const=True)
   191     ## rectangle.h: bool ns3::Rectangle::IsInside(ns3::Vector const & position) const [member function]
   192     cls.add_method('IsInside', 
   193                    'bool', 
   194                    [param('ns3::Vector const &', 'position')], 
   195                    is_const=True)
   196     ## rectangle.h: ns3::Rectangle::xMax [variable]
   197     cls.add_instance_attribute('xMax', 'double', is_const=False)
   198     ## rectangle.h: ns3::Rectangle::xMin [variable]
   199     cls.add_instance_attribute('xMin', 'double', is_const=False)
   200     ## rectangle.h: ns3::Rectangle::yMax [variable]
   201     cls.add_instance_attribute('yMax', 'double', is_const=False)
   202     ## rectangle.h: ns3::Rectangle::yMin [variable]
   203     cls.add_instance_attribute('yMin', 'double', is_const=False)
   204     return
   205 
   206 def register_Ns3Vector_methods(root_module, cls):
   207     cls.add_output_stream_operator()
   208     ## vector.h: ns3::Vector::Vector(ns3::Vector const & arg0) [copy constructor]
   209     cls.add_constructor([param('ns3::Vector const &', 'arg0')])
   210     ## vector.h: ns3::Vector::Vector(double _x, double _y, double _z) [constructor]
   211     cls.add_constructor([param('double', '_x'), param('double', '_y'), param('double', '_z')])
   212     ## vector.h: ns3::Vector::Vector() [constructor]
   213     cls.add_constructor([])
   214     ## vector.h: ns3::Vector::x [variable]
   215     cls.add_instance_attribute('x', 'double', is_const=False)
   216     ## vector.h: ns3::Vector::y [variable]
   217     cls.add_instance_attribute('y', 'double', is_const=False)
   218     ## vector.h: ns3::Vector::z [variable]
   219     cls.add_instance_attribute('z', 'double', is_const=False)
   220     return
   221 
   222 def register_Ns3PositionAllocator_methods(root_module, cls):
   223     ## position-allocator.h: ns3::PositionAllocator::PositionAllocator(ns3::PositionAllocator const & arg0) [copy constructor]
   224     cls.add_constructor([param('ns3::PositionAllocator const &', 'arg0')])
   225     ## position-allocator.h: static ns3::TypeId ns3::PositionAllocator::GetTypeId() [member function]
   226     cls.add_method('GetTypeId', 
   227                    'ns3::TypeId', 
   228                    [], 
   229                    is_static=True)
   230     ## position-allocator.h: ns3::PositionAllocator::PositionAllocator() [constructor]
   231     cls.add_constructor([])
   232     ## position-allocator.h: ns3::Vector ns3::PositionAllocator::GetNext() const [member function]
   233     cls.add_method('GetNext', 
   234                    'ns3::Vector', 
   235                    [], 
   236                    is_pure_virtual=True, is_const=True, is_virtual=True)
   237     return
   238 
   239 def register_Ns3RandomDiscPositionAllocator_methods(root_module, cls):
   240     ## position-allocator.h: ns3::RandomDiscPositionAllocator::RandomDiscPositionAllocator(ns3::RandomDiscPositionAllocator const & arg0) [copy constructor]
   241     cls.add_constructor([param('ns3::RandomDiscPositionAllocator const &', 'arg0')])
   242     ## position-allocator.h: static ns3::TypeId ns3::RandomDiscPositionAllocator::GetTypeId() [member function]
   243     cls.add_method('GetTypeId', 
   244                    'ns3::TypeId', 
   245                    [], 
   246                    is_static=True)
   247     ## position-allocator.h: ns3::RandomDiscPositionAllocator::RandomDiscPositionAllocator() [constructor]
   248     cls.add_constructor([])
   249     ## position-allocator.h: void ns3::RandomDiscPositionAllocator::SetTheta(ns3::RandomVariable theta) [member function]
   250     cls.add_method('SetTheta', 
   251                    'void', 
   252                    [param('ns3::RandomVariable', 'theta')])
   253     ## position-allocator.h: void ns3::RandomDiscPositionAllocator::SetRho(ns3::RandomVariable rho) [member function]
   254     cls.add_method('SetRho', 
   255                    'void', 
   256                    [param('ns3::RandomVariable', 'rho')])
   257     ## position-allocator.h: void ns3::RandomDiscPositionAllocator::SetX(double x) [member function]
   258     cls.add_method('SetX', 
   259                    'void', 
   260                    [param('double', 'x')])
   261     ## position-allocator.h: void ns3::RandomDiscPositionAllocator::SetY(double y) [member function]
   262     cls.add_method('SetY', 
   263                    'void', 
   264                    [param('double', 'y')])
   265     ## position-allocator.h: ns3::Vector ns3::RandomDiscPositionAllocator::GetNext() const [member function]
   266     cls.add_method('GetNext', 
   267                    'ns3::Vector', 
   268                    [], 
   269                    is_const=True, is_virtual=True)
   270     return
   271 
   272 def register_Ns3RandomRectanglePositionAllocator_methods(root_module, cls):
   273     ## position-allocator.h: ns3::RandomRectanglePositionAllocator::RandomRectanglePositionAllocator(ns3::RandomRectanglePositionAllocator const & arg0) [copy constructor]
   274     cls.add_constructor([param('ns3::RandomRectanglePositionAllocator const &', 'arg0')])
   275     ## position-allocator.h: static ns3::TypeId ns3::RandomRectanglePositionAllocator::GetTypeId() [member function]
   276     cls.add_method('GetTypeId', 
   277                    'ns3::TypeId', 
   278                    [], 
   279                    is_static=True)
   280     ## position-allocator.h: ns3::RandomRectanglePositionAllocator::RandomRectanglePositionAllocator() [constructor]
   281     cls.add_constructor([])
   282     ## position-allocator.h: void ns3::RandomRectanglePositionAllocator::SetX(ns3::RandomVariable x) [member function]
   283     cls.add_method('SetX', 
   284                    'void', 
   285                    [param('ns3::RandomVariable', 'x')])
   286     ## position-allocator.h: void ns3::RandomRectanglePositionAllocator::SetY(ns3::RandomVariable y) [member function]
   287     cls.add_method('SetY', 
   288                    'void', 
   289                    [param('ns3::RandomVariable', 'y')])
   290     ## position-allocator.h: ns3::Vector ns3::RandomRectanglePositionAllocator::GetNext() const [member function]
   291     cls.add_method('GetNext', 
   292                    'ns3::Vector', 
   293                    [], 
   294                    is_const=True, is_virtual=True)
   295     return
   296 
   297 def register_Ns3RectangleChecker_methods(root_module, cls):
   298     ## rectangle.h: ns3::RectangleChecker::RectangleChecker(ns3::RectangleChecker const & arg0) [copy constructor]
   299     cls.add_constructor([param('ns3::RectangleChecker const &', 'arg0')])
   300     ## rectangle.h: ns3::RectangleChecker::RectangleChecker() [constructor]
   301     cls.add_constructor([])
   302     return
   303 
   304 def register_Ns3RectangleValue_methods(root_module, cls):
   305     ## rectangle.h: ns3::RectangleValue::RectangleValue(ns3::RectangleValue const & arg0) [copy constructor]
   306     cls.add_constructor([param('ns3::RectangleValue const &', 'arg0')])
   307     ## rectangle.h: ns3::RectangleValue::RectangleValue() [constructor]
   308     cls.add_constructor([])
   309     ## rectangle.h: ns3::RectangleValue::RectangleValue(ns3::Rectangle const & value) [constructor]
   310     cls.add_constructor([param('ns3::Rectangle const &', 'value')])
   311     ## rectangle.h: void ns3::RectangleValue::Set(ns3::Rectangle const & value) [member function]
   312     cls.add_method('Set', 
   313                    'void', 
   314                    [param('ns3::Rectangle const &', 'value')])
   315     ## rectangle.h: ns3::Rectangle ns3::RectangleValue::Get() const [member function]
   316     cls.add_method('Get', 
   317                    'ns3::Rectangle', 
   318                    [], 
   319                    is_const=True)
   320     ## rectangle.h: ns3::Ptr<ns3::AttributeValue> ns3::RectangleValue::Copy() const [member function]
   321     cls.add_method('Copy', 
   322                    'ns3::Ptr< ns3::AttributeValue >', 
   323                    [], 
   324                    is_const=True, is_virtual=True)
   325     ## rectangle.h: std::string ns3::RectangleValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
   326     cls.add_method('SerializeToString', 
   327                    'std::string', 
   328                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
   329                    is_const=True, is_virtual=True)
   330     ## rectangle.h: bool ns3::RectangleValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   331     cls.add_method('DeserializeFromString', 
   332                    'bool', 
   333                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
   334                    is_virtual=True)
   335     return
   336 
   337 def register_Ns3VectorChecker_methods(root_module, cls):
   338     ## vector.h: ns3::VectorChecker::VectorChecker(ns3::VectorChecker const & arg0) [copy constructor]
   339     cls.add_constructor([param('ns3::VectorChecker const &', 'arg0')])
   340     ## vector.h: ns3::VectorChecker::VectorChecker() [constructor]
   341     cls.add_constructor([])
   342     return
   343 
   344 def register_Ns3VectorValue_methods(root_module, cls):
   345     ## vector.h: ns3::VectorValue::VectorValue(ns3::VectorValue const & arg0) [copy constructor]
   346     cls.add_constructor([param('ns3::VectorValue const &', 'arg0')])
   347     ## vector.h: ns3::VectorValue::VectorValue() [constructor]
   348     cls.add_constructor([])
   349     ## vector.h: ns3::VectorValue::VectorValue(ns3::Vector const & value) [constructor]
   350     cls.add_constructor([param('ns3::Vector const &', 'value')])
   351     ## vector.h: void ns3::VectorValue::Set(ns3::Vector const & value) [member function]
   352     cls.add_method('Set', 
   353                    'void', 
   354                    [param('ns3::Vector const &', 'value')])
   355     ## vector.h: ns3::Vector ns3::VectorValue::Get() const [member function]
   356     cls.add_method('Get', 
   357                    'ns3::Vector', 
   358                    [], 
   359                    is_const=True)
   360     ## vector.h: ns3::Ptr<ns3::AttributeValue> ns3::VectorValue::Copy() const [member function]
   361     cls.add_method('Copy', 
   362                    'ns3::Ptr< ns3::AttributeValue >', 
   363                    [], 
   364                    is_const=True, is_virtual=True)
   365     ## vector.h: std::string ns3::VectorValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
   366     cls.add_method('SerializeToString', 
   367                    'std::string', 
   368                    [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
   369                    is_const=True, is_virtual=True)
   370     ## vector.h: bool ns3::VectorValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   371     cls.add_method('DeserializeFromString', 
   372                    'bool', 
   373                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
   374                    is_virtual=True)
   375     return
   376 
   377 def register_Ns3GridPositionAllocator_methods(root_module, cls):
   378     ## position-allocator.h: ns3::GridPositionAllocator::GridPositionAllocator(ns3::GridPositionAllocator const & arg0) [copy constructor]
   379     cls.add_constructor([param('ns3::GridPositionAllocator const &', 'arg0')])
   380     ## position-allocator.h: static ns3::TypeId ns3::GridPositionAllocator::GetTypeId() [member function]
   381     cls.add_method('GetTypeId', 
   382                    'ns3::TypeId', 
   383                    [], 
   384                    is_static=True)
   385     ## position-allocator.h: ns3::GridPositionAllocator::GridPositionAllocator() [constructor]
   386     cls.add_constructor([])
   387     ## position-allocator.h: void ns3::GridPositionAllocator::SetMinX(double xMin) [member function]
   388     cls.add_method('SetMinX', 
   389                    'void', 
   390                    [param('double', 'xMin')])
   391     ## position-allocator.h: void ns3::GridPositionAllocator::SetMinY(double yMin) [member function]
   392     cls.add_method('SetMinY', 
   393                    'void', 
   394                    [param('double', 'yMin')])
   395     ## position-allocator.h: void ns3::GridPositionAllocator::SetDeltaX(double deltaX) [member function]
   396     cls.add_method('SetDeltaX', 
   397                    'void', 
   398                    [param('double', 'deltaX')])
   399     ## position-allocator.h: void ns3::GridPositionAllocator::SetDeltaY(double deltaY) [member function]
   400     cls.add_method('SetDeltaY', 
   401                    'void', 
   402                    [param('double', 'deltaY')])
   403     ## position-allocator.h: void ns3::GridPositionAllocator::SetN(uint32_t n) [member function]
   404     cls.add_method('SetN', 
   405                    'void', 
   406                    [param('uint32_t', 'n')])
   407     ## position-allocator.h: void ns3::GridPositionAllocator::SetLayoutType(ns3::GridPositionAllocator::LayoutType layoutType) [member function]
   408     cls.add_method('SetLayoutType', 
   409                    'void', 
   410                    [param('ns3::GridPositionAllocator::LayoutType', 'layoutType')])
   411     ## position-allocator.h: double ns3::GridPositionAllocator::GetMinX() const [member function]
   412     cls.add_method('GetMinX', 
   413                    'double', 
   414                    [], 
   415                    is_const=True)
   416     ## position-allocator.h: double ns3::GridPositionAllocator::GetMinY() const [member function]
   417     cls.add_method('GetMinY', 
   418                    'double', 
   419                    [], 
   420                    is_const=True)
   421     ## position-allocator.h: double ns3::GridPositionAllocator::GetDeltaX() const [member function]
   422     cls.add_method('GetDeltaX', 
   423                    'double', 
   424                    [], 
   425                    is_const=True)
   426     ## position-allocator.h: double ns3::GridPositionAllocator::GetDeltaY() const [member function]
   427     cls.add_method('GetDeltaY', 
   428                    'double', 
   429                    [], 
   430                    is_const=True)
   431     ## position-allocator.h: uint32_t ns3::GridPositionAllocator::GetN() const [member function]
   432     cls.add_method('GetN', 
   433                    'uint32_t', 
   434                    [], 
   435                    is_const=True)
   436     ## position-allocator.h: ns3::GridPositionAllocator::LayoutType ns3::GridPositionAllocator::GetLayoutType() const [member function]
   437     cls.add_method('GetLayoutType', 
   438                    'ns3::GridPositionAllocator::LayoutType', 
   439                    [], 
   440                    is_const=True)
   441     ## position-allocator.h: ns3::Vector ns3::GridPositionAllocator::GetNext() const [member function]
   442     cls.add_method('GetNext', 
   443                    'ns3::Vector', 
   444                    [], 
   445                    is_const=True, is_virtual=True)
   446     return
   447 
   448 def register_Ns3ListPositionAllocator_methods(root_module, cls):
   449     ## position-allocator.h: ns3::ListPositionAllocator::ListPositionAllocator(ns3::ListPositionAllocator const & arg0) [copy constructor]
   450     cls.add_constructor([param('ns3::ListPositionAllocator const &', 'arg0')])
   451     ## position-allocator.h: static ns3::TypeId ns3::ListPositionAllocator::GetTypeId() [member function]
   452     cls.add_method('GetTypeId', 
   453                    'ns3::TypeId', 
   454                    [], 
   455                    is_static=True)
   456     ## position-allocator.h: ns3::ListPositionAllocator::ListPositionAllocator() [constructor]
   457     cls.add_constructor([])
   458     ## position-allocator.h: void ns3::ListPositionAllocator::Add(ns3::Vector v) [member function]
   459     cls.add_method('Add', 
   460                    'void', 
   461                    [param('ns3::Vector', 'v')])
   462     ## position-allocator.h: ns3::Vector ns3::ListPositionAllocator::GetNext() const [member function]
   463     cls.add_method('GetNext', 
   464                    'ns3::Vector', 
   465                    [], 
   466                    is_const=True, is_virtual=True)
   467     return
   468 
   469 def register_Ns3MobilityModel_methods(root_module, cls):
   470     ## mobility-model.h: ns3::MobilityModel::MobilityModel(ns3::MobilityModel const & arg0) [copy constructor]
   471     cls.add_constructor([param('ns3::MobilityModel const &', 'arg0')])
   472     ## mobility-model.h: static ns3::TypeId ns3::MobilityModel::GetTypeId() [member function]
   473     cls.add_method('GetTypeId', 
   474                    'ns3::TypeId', 
   475                    [], 
   476                    is_static=True)
   477     ## mobility-model.h: ns3::MobilityModel::MobilityModel() [constructor]
   478     cls.add_constructor([])
   479     ## mobility-model.h: ns3::Vector ns3::MobilityModel::GetPosition() const [member function]
   480     cls.add_method('GetPosition', 
   481                    'ns3::Vector', 
   482                    [], 
   483                    is_const=True)
   484     ## mobility-model.h: void ns3::MobilityModel::SetPosition(ns3::Vector const & position) [member function]
   485     cls.add_method('SetPosition', 
   486                    'void', 
   487                    [param('ns3::Vector const &', 'position')])
   488     ## mobility-model.h: ns3::Vector ns3::MobilityModel::GetVelocity() const [member function]
   489     cls.add_method('GetVelocity', 
   490                    'ns3::Vector', 
   491                    [], 
   492                    is_const=True)
   493     ## mobility-model.h: double ns3::MobilityModel::GetDistanceFrom(ns3::Ptr<const ns3::MobilityModel> position) const [member function]
   494     cls.add_method('GetDistanceFrom', 
   495                    'double', 
   496                    [param('ns3::Ptr< ns3::MobilityModel const >', 'position')], 
   497                    is_const=True)
   498     ## mobility-model.h: void ns3::MobilityModel::NotifyCourseChange() const [member function]
   499     cls.add_method('NotifyCourseChange', 
   500                    'void', 
   501                    [], 
   502                    is_const=True, visibility='protected')
   503     ## mobility-model.h: ns3::Vector ns3::MobilityModel::DoGetPosition() const [member function]
   504     cls.add_method('DoGetPosition', 
   505                    'ns3::Vector', 
   506                    [], 
   507                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
   508     ## mobility-model.h: void ns3::MobilityModel::DoSetPosition(ns3::Vector const & position) [member function]
   509     cls.add_method('DoSetPosition', 
   510                    'void', 
   511                    [param('ns3::Vector const &', 'position')], 
   512                    is_pure_virtual=True, visibility='private', is_virtual=True)
   513     ## mobility-model.h: ns3::Vector ns3::MobilityModel::DoGetVelocity() const [member function]
   514     cls.add_method('DoGetVelocity', 
   515                    'ns3::Vector', 
   516                    [], 
   517                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
   518     return
   519 
   520 def register_Ns3RandomDirection2dMobilityModel_methods(root_module, cls):
   521     ## random-direction-2d-mobility-model.h: ns3::RandomDirection2dMobilityModel::RandomDirection2dMobilityModel(ns3::RandomDirection2dMobilityModel const & arg0) [copy constructor]
   522     cls.add_constructor([param('ns3::RandomDirection2dMobilityModel const &', 'arg0')])
   523     ## random-direction-2d-mobility-model.h: static ns3::TypeId ns3::RandomDirection2dMobilityModel::GetTypeId() [member function]
   524     cls.add_method('GetTypeId', 
   525                    'ns3::TypeId', 
   526                    [], 
   527                    is_static=True)
   528     ## random-direction-2d-mobility-model.h: ns3::RandomDirection2dMobilityModel::RandomDirection2dMobilityModel() [constructor]
   529     cls.add_constructor([])
   530     ## random-direction-2d-mobility-model.h: void ns3::RandomDirection2dMobilityModel::DoDispose() [member function]
   531     cls.add_method('DoDispose', 
   532                    'void', 
   533                    [], 
   534                    visibility='private', is_virtual=True)
   535     ## random-direction-2d-mobility-model.h: ns3::Vector ns3::RandomDirection2dMobilityModel::DoGetPosition() const [member function]
   536     cls.add_method('DoGetPosition', 
   537                    'ns3::Vector', 
   538                    [], 
   539                    is_const=True, visibility='private', is_virtual=True)
   540     ## random-direction-2d-mobility-model.h: void ns3::RandomDirection2dMobilityModel::DoSetPosition(ns3::Vector const & position) [member function]
   541     cls.add_method('DoSetPosition', 
   542                    'void', 
   543                    [param('ns3::Vector const &', 'position')], 
   544                    visibility='private', is_virtual=True)
   545     ## random-direction-2d-mobility-model.h: ns3::Vector ns3::RandomDirection2dMobilityModel::DoGetVelocity() const [member function]
   546     cls.add_method('DoGetVelocity', 
   547                    'ns3::Vector', 
   548                    [], 
   549                    is_const=True, visibility='private', is_virtual=True)
   550     return
   551 
   552 def register_Ns3RandomWalk2dMobilityModel_methods(root_module, cls):
   553     ## random-walk-2d-mobility-model.h: ns3::RandomWalk2dMobilityModel::RandomWalk2dMobilityModel(ns3::RandomWalk2dMobilityModel const & arg0) [copy constructor]
   554     cls.add_constructor([param('ns3::RandomWalk2dMobilityModel const &', 'arg0')])
   555     ## random-walk-2d-mobility-model.h: static ns3::TypeId ns3::RandomWalk2dMobilityModel::GetTypeId() [member function]
   556     cls.add_method('GetTypeId', 
   557                    'ns3::TypeId', 
   558                    [], 
   559                    is_static=True)
   560     ## random-walk-2d-mobility-model.h: ns3::RandomWalk2dMobilityModel::RandomWalk2dMobilityModel() [constructor]
   561     cls.add_constructor([])
   562     ## random-walk-2d-mobility-model.h: void ns3::RandomWalk2dMobilityModel::DoDispose() [member function]
   563     cls.add_method('DoDispose', 
   564                    'void', 
   565                    [], 
   566                    visibility='private', is_virtual=True)
   567     ## random-walk-2d-mobility-model.h: ns3::Vector ns3::RandomWalk2dMobilityModel::DoGetPosition() const [member function]
   568     cls.add_method('DoGetPosition', 
   569                    'ns3::Vector', 
   570                    [], 
   571                    is_const=True, visibility='private', is_virtual=True)
   572     ## random-walk-2d-mobility-model.h: void ns3::RandomWalk2dMobilityModel::DoSetPosition(ns3::Vector const & position) [member function]
   573     cls.add_method('DoSetPosition', 
   574                    'void', 
   575                    [param('ns3::Vector const &', 'position')], 
   576                    visibility='private', is_virtual=True)
   577     ## random-walk-2d-mobility-model.h: ns3::Vector ns3::RandomWalk2dMobilityModel::DoGetVelocity() const [member function]
   578     cls.add_method('DoGetVelocity', 
   579                    'ns3::Vector', 
   580                    [], 
   581                    is_const=True, visibility='private', is_virtual=True)
   582     return
   583 
   584 def register_Ns3RandomWaypointMobilityModel_methods(root_module, cls):
   585     ## random-waypoint-mobility-model.h: ns3::RandomWaypointMobilityModel::RandomWaypointMobilityModel(ns3::RandomWaypointMobilityModel const & arg0) [copy constructor]
   586     cls.add_constructor([param('ns3::RandomWaypointMobilityModel const &', 'arg0')])
   587     ## random-waypoint-mobility-model.h: static ns3::TypeId ns3::RandomWaypointMobilityModel::GetTypeId() [member function]
   588     cls.add_method('GetTypeId', 
   589                    'ns3::TypeId', 
   590                    [], 
   591                    is_static=True)
   592     ## random-waypoint-mobility-model.h: ns3::RandomWaypointMobilityModel::RandomWaypointMobilityModel() [constructor]
   593     cls.add_constructor([])
   594     ## random-waypoint-mobility-model.h: ns3::Vector ns3::RandomWaypointMobilityModel::DoGetPosition() const [member function]
   595     cls.add_method('DoGetPosition', 
   596                    'ns3::Vector', 
   597                    [], 
   598                    is_const=True, visibility='private', is_virtual=True)
   599     ## random-waypoint-mobility-model.h: void ns3::RandomWaypointMobilityModel::DoSetPosition(ns3::Vector const & position) [member function]
   600     cls.add_method('DoSetPosition', 
   601                    'void', 
   602                    [param('ns3::Vector const &', 'position')], 
   603                    visibility='private', is_virtual=True)
   604     ## random-waypoint-mobility-model.h: ns3::Vector ns3::RandomWaypointMobilityModel::DoGetVelocity() const [member function]
   605     cls.add_method('DoGetVelocity', 
   606                    'ns3::Vector', 
   607                    [], 
   608                    is_const=True, visibility='private', is_virtual=True)
   609     return
   610 
   611 def register_Ns3ConstantAccelerationMobilityModel_methods(root_module, cls):
   612     ## constant-acceleration-mobility-model.h: ns3::ConstantAccelerationMobilityModel::ConstantAccelerationMobilityModel(ns3::ConstantAccelerationMobilityModel const & arg0) [copy constructor]
   613     cls.add_constructor([param('ns3::ConstantAccelerationMobilityModel const &', 'arg0')])
   614     ## constant-acceleration-mobility-model.h: static ns3::TypeId ns3::ConstantAccelerationMobilityModel::GetTypeId() [member function]
   615     cls.add_method('GetTypeId', 
   616                    'ns3::TypeId', 
   617                    [], 
   618                    is_static=True)
   619     ## constant-acceleration-mobility-model.h: ns3::ConstantAccelerationMobilityModel::ConstantAccelerationMobilityModel() [constructor]
   620     cls.add_constructor([])
   621     ## constant-acceleration-mobility-model.h: void ns3::ConstantAccelerationMobilityModel::SetVelocityAndAcceleration(ns3::Vector const & velocity, ns3::Vector const & acceleration) [member function]
   622     cls.add_method('SetVelocityAndAcceleration', 
   623                    'void', 
   624                    [param('ns3::Vector const &', 'velocity'), param('ns3::Vector const &', 'acceleration')])
   625     ## constant-acceleration-mobility-model.h: ns3::Vector ns3::ConstantAccelerationMobilityModel::DoGetPosition() const [member function]
   626     cls.add_method('DoGetPosition', 
   627                    'ns3::Vector', 
   628                    [], 
   629                    is_const=True, visibility='private', is_virtual=True)
   630     ## constant-acceleration-mobility-model.h: void ns3::ConstantAccelerationMobilityModel::DoSetPosition(ns3::Vector const & position) [member function]
   631     cls.add_method('DoSetPosition', 
   632                    'void', 
   633                    [param('ns3::Vector const &', 'position')], 
   634                    visibility='private', is_virtual=True)
   635     ## constant-acceleration-mobility-model.h: ns3::Vector ns3::ConstantAccelerationMobilityModel::DoGetVelocity() const [member function]
   636     cls.add_method('DoGetVelocity', 
   637                    'ns3::Vector', 
   638                    [], 
   639                    is_const=True, visibility='private', is_virtual=True)
   640     return
   641 
   642 def register_Ns3ConstantPositionMobilityModel_methods(root_module, cls):
   643     ## constant-position-mobility-model.h: ns3::ConstantPositionMobilityModel::ConstantPositionMobilityModel(ns3::ConstantPositionMobilityModel const & arg0) [copy constructor]
   644     cls.add_constructor([param('ns3::ConstantPositionMobilityModel const &', 'arg0')])
   645     ## constant-position-mobility-model.h: static ns3::TypeId ns3::ConstantPositionMobilityModel::GetTypeId() [member function]
   646     cls.add_method('GetTypeId', 
   647                    'ns3::TypeId', 
   648                    [], 
   649                    is_static=True)
   650     ## constant-position-mobility-model.h: ns3::ConstantPositionMobilityModel::ConstantPositionMobilityModel() [constructor]
   651     cls.add_constructor([])
   652     ## constant-position-mobility-model.h: ns3::Vector ns3::ConstantPositionMobilityModel::DoGetPosition() const [member function]
   653     cls.add_method('DoGetPosition', 
   654                    'ns3::Vector', 
   655                    [], 
   656                    is_const=True, visibility='private', is_virtual=True)
   657     ## constant-position-mobility-model.h: void ns3::ConstantPositionMobilityModel::DoSetPosition(ns3::Vector const & position) [member function]
   658     cls.add_method('DoSetPosition', 
   659                    'void', 
   660                    [param('ns3::Vector const &', 'position')], 
   661                    visibility='private', is_virtual=True)
   662     ## constant-position-mobility-model.h: ns3::Vector ns3::ConstantPositionMobilityModel::DoGetVelocity() const [member function]
   663     cls.add_method('DoGetVelocity', 
   664                    'ns3::Vector', 
   665                    [], 
   666                    is_const=True, visibility='private', is_virtual=True)
   667     return
   668 
   669 def register_Ns3ConstantVelocityMobilityModel_methods(root_module, cls):
   670     ## constant-velocity-mobility-model.h: ns3::ConstantVelocityMobilityModel::ConstantVelocityMobilityModel(ns3::ConstantVelocityMobilityModel const & arg0) [copy constructor]
   671     cls.add_constructor([param('ns3::ConstantVelocityMobilityModel const &', 'arg0')])
   672     ## constant-velocity-mobility-model.h: static ns3::TypeId ns3::ConstantVelocityMobilityModel::GetTypeId() [member function]
   673     cls.add_method('GetTypeId', 
   674                    'ns3::TypeId', 
   675                    [], 
   676                    is_static=True)
   677     ## constant-velocity-mobility-model.h: ns3::ConstantVelocityMobilityModel::ConstantVelocityMobilityModel() [constructor]
   678     cls.add_constructor([])
   679     ## constant-velocity-mobility-model.h: void ns3::ConstantVelocityMobilityModel::SetVelocity(ns3::Vector const & speed) [member function]
   680     cls.add_method('SetVelocity', 
   681                    'void', 
   682                    [param('ns3::Vector const &', 'speed')])
   683     ## constant-velocity-mobility-model.h: ns3::Vector ns3::ConstantVelocityMobilityModel::DoGetPosition() const [member function]
   684     cls.add_method('DoGetPosition', 
   685                    'ns3::Vector', 
   686                    [], 
   687                    is_const=True, visibility='private', is_virtual=True)
   688     ## constant-velocity-mobility-model.h: void ns3::ConstantVelocityMobilityModel::DoSetPosition(ns3::Vector const & position) [member function]
   689     cls.add_method('DoSetPosition', 
   690                    'void', 
   691                    [param('ns3::Vector const &', 'position')], 
   692                    visibility='private', is_virtual=True)
   693     ## constant-velocity-mobility-model.h: ns3::Vector ns3::ConstantVelocityMobilityModel::DoGetVelocity() const [member function]
   694     cls.add_method('DoGetVelocity', 
   695                    'ns3::Vector', 
   696                    [], 
   697                    is_const=True, visibility='private', is_virtual=True)
   698     return
   699 
   700 def register_Ns3HierarchicalMobilityModel_methods(root_module, cls):
   701     ## hierarchical-mobility-model.h: ns3::HierarchicalMobilityModel::HierarchicalMobilityModel(ns3::HierarchicalMobilityModel const & arg0) [copy constructor]
   702     cls.add_constructor([param('ns3::HierarchicalMobilityModel const &', 'arg0')])
   703     ## hierarchical-mobility-model.h: static ns3::TypeId ns3::HierarchicalMobilityModel::GetTypeId() [member function]
   704     cls.add_method('GetTypeId', 
   705                    'ns3::TypeId', 
   706                    [], 
   707                    is_static=True)
   708     ## hierarchical-mobility-model.h: ns3::HierarchicalMobilityModel::HierarchicalMobilityModel() [constructor]
   709     cls.add_constructor([])
   710     ## hierarchical-mobility-model.h: ns3::Ptr<ns3::MobilityModel> ns3::HierarchicalMobilityModel::GetChild() const [member function]
   711     cls.add_method('GetChild', 
   712                    'ns3::Ptr< ns3::MobilityModel >', 
   713                    [], 
   714                    is_const=True)
   715     ## hierarchical-mobility-model.h: ns3::Ptr<ns3::MobilityModel> ns3::HierarchicalMobilityModel::GetParent() const [member function]
   716     cls.add_method('GetParent', 
   717                    'ns3::Ptr< ns3::MobilityModel >', 
   718                    [], 
   719                    is_const=True)
   720     ## hierarchical-mobility-model.h: void ns3::HierarchicalMobilityModel::SetChild(ns3::Ptr<ns3::MobilityModel> model) [member function]
   721     cls.add_method('SetChild', 
   722                    'void', 
   723                    [param('ns3::Ptr< ns3::MobilityModel >', 'model')])
   724     ## hierarchical-mobility-model.h: void ns3::HierarchicalMobilityModel::SetParent(ns3::Ptr<ns3::MobilityModel> model) [member function]
   725     cls.add_method('SetParent', 
   726                    'void', 
   727                    [param('ns3::Ptr< ns3::MobilityModel >', 'model')])
   728     ## hierarchical-mobility-model.h: ns3::Vector ns3::HierarchicalMobilityModel::DoGetPosition() const [member function]
   729     cls.add_method('DoGetPosition', 
   730                    'ns3::Vector', 
   731                    [], 
   732                    is_const=True, visibility='private', is_virtual=True)
   733     ## hierarchical-mobility-model.h: void ns3::HierarchicalMobilityModel::DoSetPosition(ns3::Vector const & position) [member function]
   734     cls.add_method('DoSetPosition', 
   735                    'void', 
   736                    [param('ns3::Vector const &', 'position')], 
   737                    visibility='private', is_virtual=True)
   738     ## hierarchical-mobility-model.h: ns3::Vector ns3::HierarchicalMobilityModel::DoGetVelocity() const [member function]
   739     cls.add_method('DoGetVelocity', 
   740                    'ns3::Vector', 
   741                    [], 
   742                    is_const=True, visibility='private', is_virtual=True)
   743     return
   744 
   745 def register_functions(root_module):
   746     module = root_module
   747     ## vector.h: extern double ns3::CalculateDistance(ns3::Vector const & a, ns3::Vector const & b) [free function]
   748     module.add_function('CalculateDistance', 
   749                         'double', 
   750                         [param('ns3::Vector const &', 'a'), param('ns3::Vector const &', 'b')])
   751     ## rectangle.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeRectangleChecker() [free function]
   752     module.add_function('MakeRectangleChecker', 
   753                         'ns3::Ptr< ns3::AttributeChecker const >', 
   754                         [])
   755     ## vector.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeVectorChecker() [free function]
   756     module.add_function('MakeVectorChecker', 
   757                         'ns3::Ptr< ns3::AttributeChecker const >', 
   758                         [])
   759     register_functions_ns3_Config(module.get_submodule('Config'), root_module)
   760     register_functions_ns3_TimeStepPrecision(module.get_submodule('TimeStepPrecision'), root_module)
   761     register_functions_ns3_addressUtils(module.get_submodule('addressUtils'), root_module)
   762     register_functions_ns3_internal(module.get_submodule('internal'), root_module)
   763     register_functions_ns3_olsr(module.get_submodule('olsr'), root_module)
   764     return
   765 
   766 def register_functions_ns3_Config(module, root_module):
   767     return
   768 
   769 def register_functions_ns3_TimeStepPrecision(module, root_module):
   770     return
   771 
   772 def register_functions_ns3_addressUtils(module, root_module):
   773     return
   774 
   775 def register_functions_ns3_internal(module, root_module):
   776     return
   777 
   778 def register_functions_ns3_olsr(module, root_module):
   779     return
   780