bindings/python/ns3_module_mobility.py
changeset 3567 728eb3f583b3
parent 3544 3685ab98e4b2
child 3574 b6804efbe16b
equal deleted inserted replaced
3566:b96af8dc8abf 3567:728eb3f583b3
   109     register_Ns3HierarchicalMobilityModel_methods(root_module, root_module['ns3::HierarchicalMobilityModel'])
   109     register_Ns3HierarchicalMobilityModel_methods(root_module, root_module['ns3::HierarchicalMobilityModel'])
   110     register_Ns3StaticMobilityModel_methods(root_module, root_module['ns3::StaticMobilityModel'])
   110     register_Ns3StaticMobilityModel_methods(root_module, root_module['ns3::StaticMobilityModel'])
   111     return
   111     return
   112 
   112 
   113 def register_Ns3StaticSpeedHelper_methods(root_module, cls):
   113 def register_Ns3StaticSpeedHelper_methods(root_module, cls):
       
   114     ## static-speed-helper.h: ns3::StaticSpeedHelper::StaticSpeedHelper(ns3::StaticSpeedHelper const & arg0) [copy constructor]
       
   115     cls.add_constructor([param('ns3::StaticSpeedHelper&', 'arg0', is_const=True)])
   114     ## static-speed-helper.h: ns3::StaticSpeedHelper::StaticSpeedHelper() [constructor]
   116     ## static-speed-helper.h: ns3::StaticSpeedHelper::StaticSpeedHelper() [constructor]
   115     cls.add_constructor([])
   117     cls.add_constructor([])
   116     ## static-speed-helper.h: ns3::StaticSpeedHelper::StaticSpeedHelper(ns3::Vector const & position) [constructor]
   118     ## static-speed-helper.h: ns3::StaticSpeedHelper::StaticSpeedHelper(ns3::Vector const & position) [constructor]
   117     cls.add_constructor([param('ns3::Vector&', 'position', is_const=True)])
   119     cls.add_constructor([param('ns3::Vector&', 'position', is_const=True)])
   118     ## static-speed-helper.h: ns3::StaticSpeedHelper::StaticSpeedHelper(ns3::Vector const & position, ns3::Vector const & speed) [constructor]
   120     ## static-speed-helper.h: ns3::StaticSpeedHelper::StaticSpeedHelper(ns3::Vector const & position, ns3::Vector const & speed) [constructor]
   150                    [])
   152                    [])
   151     ## static-speed-helper.h: void ns3::StaticSpeedHelper::Unpause() [member function]
   153     ## static-speed-helper.h: void ns3::StaticSpeedHelper::Unpause() [member function]
   152     cls.add_method('Unpause', 
   154     cls.add_method('Unpause', 
   153                    'void', 
   155                    'void', 
   154                    [])
   156                    [])
   155     cls.add_copy_constructor()
       
   156     return
   157     return
   157 
   158 
   158 def register_Ns3Vector_methods(root_module, cls):
   159 def register_Ns3Vector_methods(root_module, cls):
   159     ## vector.h: ns3::Vector::Vector(ns3::Vector const & arg0) [copy constructor]
   160     ## vector.h: ns3::Vector::Vector(ns3::Vector const & arg0) [copy constructor]
   160     cls.add_constructor([param('ns3::Vector&', 'arg0', is_const=True)])
   161     cls.add_constructor([param('ns3::Vector&', 'arg0', is_const=True)])
   170     cls.add_instance_attribute('z', 'double', is_const=False)
   171     cls.add_instance_attribute('z', 'double', is_const=False)
   171     cls.add_output_stream_operator()
   172     cls.add_output_stream_operator()
   172     return
   173     return
   173 
   174 
   174 def register_Ns3VectorChecker_methods(root_module, cls):
   175 def register_Ns3VectorChecker_methods(root_module, cls):
   175     cls.add_constructor([])
   176     ## vector.h: ns3::VectorChecker::VectorChecker(ns3::VectorChecker const & arg0) [copy constructor]
   176     cls.add_copy_constructor()
   177     cls.add_constructor([param('ns3::VectorChecker&', 'arg0', is_const=True)])
       
   178     ## vector.h: ns3::VectorChecker::VectorChecker() [constructor]
       
   179     cls.add_constructor([])
   177     return
   180     return
   178 
   181 
   179 def register_Ns3RectangleChecker_methods(root_module, cls):
   182 def register_Ns3RectangleChecker_methods(root_module, cls):
   180     cls.add_constructor([])
   183     ## rectangle.h: ns3::RectangleChecker::RectangleChecker(ns3::RectangleChecker const & arg0) [copy constructor]
   181     cls.add_copy_constructor()
   184     cls.add_constructor([param('ns3::RectangleChecker&', 'arg0', is_const=True)])
       
   185     ## rectangle.h: ns3::RectangleChecker::RectangleChecker() [constructor]
       
   186     cls.add_constructor([])
   182     return
   187     return
   183 
   188 
   184 def register_Ns3Rectangle_methods(root_module, cls):
   189 def register_Ns3Rectangle_methods(root_module, cls):
   185     ## rectangle.h: ns3::Rectangle::Rectangle(ns3::Rectangle const & arg0) [copy constructor]
   190     ## rectangle.h: ns3::Rectangle::Rectangle(ns3::Rectangle const & arg0) [copy constructor]
   186     cls.add_constructor([param('ns3::Rectangle&', 'arg0', is_const=True)])
   191     cls.add_constructor([param('ns3::Rectangle&', 'arg0', is_const=True)])
   213     cls.add_instance_attribute('yMin', 'double', is_const=False)
   218     cls.add_instance_attribute('yMin', 'double', is_const=False)
   214     cls.add_output_stream_operator()
   219     cls.add_output_stream_operator()
   215     return
   220     return
   216 
   221 
   217 def register_Ns3PositionAllocator_methods(root_module, cls):
   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&', 'arg0', is_const=True)])
   218     ## position-allocator.h: static ns3::TypeId ns3::PositionAllocator::GetTypeId() [member function]
   225     ## position-allocator.h: static ns3::TypeId ns3::PositionAllocator::GetTypeId() [member function]
   219     cls.add_method('GetTypeId', 
   226     cls.add_method('GetTypeId', 
   220                    'ns3::TypeId', 
   227                    'ns3::TypeId', 
   221                    [], 
   228                    [], 
   222                    is_static=True)
   229                    is_static=True)
   225     ## position-allocator.h: ns3::Vector ns3::PositionAllocator::GetNext() const [member function]
   232     ## position-allocator.h: ns3::Vector ns3::PositionAllocator::GetNext() const [member function]
   226     cls.add_method('GetNext', 
   233     cls.add_method('GetNext', 
   227                    'ns3::Vector', 
   234                    'ns3::Vector', 
   228                    [], 
   235                    [], 
   229                    is_pure_virtual=True, is_const=True, is_virtual=True)
   236                    is_pure_virtual=True, is_const=True, is_virtual=True)
   230     cls.add_copy_constructor()
       
   231     return
   237     return
   232 
   238 
   233 def register_Ns3ListPositionAllocator_methods(root_module, cls):
   239 def register_Ns3ListPositionAllocator_methods(root_module, cls):
       
   240     ## position-allocator.h: ns3::ListPositionAllocator::ListPositionAllocator(ns3::ListPositionAllocator const & arg0) [copy constructor]
       
   241     cls.add_constructor([param('ns3::ListPositionAllocator&', 'arg0', is_const=True)])
   234     ## position-allocator.h: static ns3::TypeId ns3::ListPositionAllocator::GetTypeId() [member function]
   242     ## position-allocator.h: static ns3::TypeId ns3::ListPositionAllocator::GetTypeId() [member function]
   235     cls.add_method('GetTypeId', 
   243     cls.add_method('GetTypeId', 
   236                    'ns3::TypeId', 
   244                    'ns3::TypeId', 
   237                    [], 
   245                    [], 
   238                    is_static=True)
   246                    is_static=True)
   245     ## position-allocator.h: ns3::Vector ns3::ListPositionAllocator::GetNext() const [member function]
   253     ## position-allocator.h: ns3::Vector ns3::ListPositionAllocator::GetNext() const [member function]
   246     cls.add_method('GetNext', 
   254     cls.add_method('GetNext', 
   247                    'ns3::Vector', 
   255                    'ns3::Vector', 
   248                    [], 
   256                    [], 
   249                    is_const=True, is_virtual=True)
   257                    is_const=True, is_virtual=True)
   250     cls.add_copy_constructor()
       
   251     return
   258     return
   252 
   259 
   253 def register_Ns3RectangleValue_methods(root_module, cls):
   260 def register_Ns3RectangleValue_methods(root_module, cls):
       
   261     ## rectangle.h: ns3::RectangleValue::RectangleValue(ns3::RectangleValue const & arg0) [copy constructor]
       
   262     cls.add_constructor([param('ns3::RectangleValue&', 'arg0', is_const=True)])
   254     ## rectangle.h: ns3::RectangleValue::RectangleValue() [constructor]
   263     ## rectangle.h: ns3::RectangleValue::RectangleValue() [constructor]
   255     cls.add_constructor([])
   264     cls.add_constructor([])
   256     ## rectangle.h: ns3::RectangleValue::RectangleValue(ns3::Rectangle const & value) [constructor]
   265     ## rectangle.h: ns3::RectangleValue::RectangleValue(ns3::Rectangle const & value) [constructor]
   257     cls.add_constructor([param('ns3::Rectangle&', 'value', is_const=True)])
   266     cls.add_constructor([param('ns3::Rectangle&', 'value', is_const=True)])
   258     ## rectangle.h: void ns3::RectangleValue::Set(ns3::Rectangle const & value) [member function]
   267     ## rectangle.h: void ns3::RectangleValue::Set(ns3::Rectangle const & value) [member function]
   277     ## rectangle.h: bool ns3::RectangleValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   286     ## rectangle.h: bool ns3::RectangleValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   278     cls.add_method('DeserializeFromString', 
   287     cls.add_method('DeserializeFromString', 
   279                    'bool', 
   288                    'bool', 
   280                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
   289                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
   281                    is_virtual=True)
   290                    is_virtual=True)
   282     cls.add_copy_constructor()
       
   283     return
   291     return
   284 
   292 
   285 def register_Ns3RandomRectanglePositionAllocator_methods(root_module, cls):
   293 def register_Ns3RandomRectanglePositionAllocator_methods(root_module, cls):
       
   294     ## position-allocator.h: ns3::RandomRectanglePositionAllocator::RandomRectanglePositionAllocator(ns3::RandomRectanglePositionAllocator const & arg0) [copy constructor]
       
   295     cls.add_constructor([param('ns3::RandomRectanglePositionAllocator&', 'arg0', is_const=True)])
   286     ## position-allocator.h: static ns3::TypeId ns3::RandomRectanglePositionAllocator::GetTypeId() [member function]
   296     ## position-allocator.h: static ns3::TypeId ns3::RandomRectanglePositionAllocator::GetTypeId() [member function]
   287     cls.add_method('GetTypeId', 
   297     cls.add_method('GetTypeId', 
   288                    'ns3::TypeId', 
   298                    'ns3::TypeId', 
   289                    [], 
   299                    [], 
   290                    is_static=True)
   300                    is_static=True)
   301     ## position-allocator.h: ns3::Vector ns3::RandomRectanglePositionAllocator::GetNext() const [member function]
   311     ## position-allocator.h: ns3::Vector ns3::RandomRectanglePositionAllocator::GetNext() const [member function]
   302     cls.add_method('GetNext', 
   312     cls.add_method('GetNext', 
   303                    'ns3::Vector', 
   313                    'ns3::Vector', 
   304                    [], 
   314                    [], 
   305                    is_const=True, is_virtual=True)
   315                    is_const=True, is_virtual=True)
   306     cls.add_copy_constructor()
       
   307     return
   316     return
   308 
   317 
   309 def register_Ns3VectorValue_methods(root_module, cls):
   318 def register_Ns3VectorValue_methods(root_module, cls):
       
   319     ## vector.h: ns3::VectorValue::VectorValue(ns3::VectorValue const & arg0) [copy constructor]
       
   320     cls.add_constructor([param('ns3::VectorValue&', 'arg0', is_const=True)])
   310     ## vector.h: ns3::VectorValue::VectorValue() [constructor]
   321     ## vector.h: ns3::VectorValue::VectorValue() [constructor]
   311     cls.add_constructor([])
   322     cls.add_constructor([])
   312     ## vector.h: ns3::VectorValue::VectorValue(ns3::Vector const & value) [constructor]
   323     ## vector.h: ns3::VectorValue::VectorValue(ns3::Vector const & value) [constructor]
   313     cls.add_constructor([param('ns3::Vector&', 'value', is_const=True)])
   324     cls.add_constructor([param('ns3::Vector&', 'value', is_const=True)])
   314     ## vector.h: void ns3::VectorValue::Set(ns3::Vector const & value) [member function]
   325     ## vector.h: void ns3::VectorValue::Set(ns3::Vector const & value) [member function]
   333     ## vector.h: bool ns3::VectorValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   344     ## vector.h: bool ns3::VectorValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
   334     cls.add_method('DeserializeFromString', 
   345     cls.add_method('DeserializeFromString', 
   335                    'bool', 
   346                    'bool', 
   336                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
   347                    [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
   337                    is_virtual=True)
   348                    is_virtual=True)
   338     cls.add_copy_constructor()
       
   339     return
   349     return
   340 
   350 
   341 def register_Ns3RandomDiscPositionAllocator_methods(root_module, cls):
   351 def register_Ns3RandomDiscPositionAllocator_methods(root_module, cls):
       
   352     ## position-allocator.h: ns3::RandomDiscPositionAllocator::RandomDiscPositionAllocator(ns3::RandomDiscPositionAllocator const & arg0) [copy constructor]
       
   353     cls.add_constructor([param('ns3::RandomDiscPositionAllocator&', 'arg0', is_const=True)])
   342     ## position-allocator.h: static ns3::TypeId ns3::RandomDiscPositionAllocator::GetTypeId() [member function]
   354     ## position-allocator.h: static ns3::TypeId ns3::RandomDiscPositionAllocator::GetTypeId() [member function]
   343     cls.add_method('GetTypeId', 
   355     cls.add_method('GetTypeId', 
   344                    'ns3::TypeId', 
   356                    'ns3::TypeId', 
   345                    [], 
   357                    [], 
   346                    is_static=True)
   358                    is_static=True)
   365     ## position-allocator.h: ns3::Vector ns3::RandomDiscPositionAllocator::GetNext() const [member function]
   377     ## position-allocator.h: ns3::Vector ns3::RandomDiscPositionAllocator::GetNext() const [member function]
   366     cls.add_method('GetNext', 
   378     cls.add_method('GetNext', 
   367                    'ns3::Vector', 
   379                    'ns3::Vector', 
   368                    [], 
   380                    [], 
   369                    is_const=True, is_virtual=True)
   381                    is_const=True, is_virtual=True)
   370     cls.add_copy_constructor()
       
   371     return
   382     return
   372 
   383 
   373 def register_Ns3MobilityModel_methods(root_module, cls):
   384 def register_Ns3MobilityModel_methods(root_module, cls):
       
   385     ## mobility-model.h: ns3::MobilityModel::MobilityModel(ns3::MobilityModel const & arg0) [copy constructor]
       
   386     cls.add_constructor([param('ns3::MobilityModel&', 'arg0', is_const=True)])
   374     ## mobility-model.h: static ns3::TypeId ns3::MobilityModel::GetTypeId() [member function]
   387     ## mobility-model.h: static ns3::TypeId ns3::MobilityModel::GetTypeId() [member function]
   375     cls.add_method('GetTypeId', 
   388     cls.add_method('GetTypeId', 
   376                    'ns3::TypeId', 
   389                    'ns3::TypeId', 
   377                    [], 
   390                    [], 
   378                    is_static=True)
   391                    is_static=True)
   415     ## mobility-model.h: ns3::Vector ns3::MobilityModel::DoGetVelocity() const [member function]
   428     ## mobility-model.h: ns3::Vector ns3::MobilityModel::DoGetVelocity() const [member function]
   416     cls.add_method('DoGetVelocity', 
   429     cls.add_method('DoGetVelocity', 
   417                    'ns3::Vector', 
   430                    'ns3::Vector', 
   418                    [], 
   431                    [], 
   419                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
   432                    is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
   420     cls.add_copy_constructor()
       
   421     return
   433     return
   422 
   434 
   423 def register_Ns3RandomDirection2dMobilityModel_methods(root_module, cls):
   435 def register_Ns3RandomDirection2dMobilityModel_methods(root_module, cls):
       
   436     ## random-direction-2d-mobility-model.h: ns3::RandomDirection2dMobilityModel::RandomDirection2dMobilityModel(ns3::RandomDirection2dMobilityModel const & arg0) [copy constructor]
       
   437     cls.add_constructor([param('ns3::RandomDirection2dMobilityModel&', 'arg0', is_const=True)])
   424     ## random-direction-2d-mobility-model.h: static ns3::TypeId ns3::RandomDirection2dMobilityModel::GetTypeId() [member function]
   438     ## random-direction-2d-mobility-model.h: static ns3::TypeId ns3::RandomDirection2dMobilityModel::GetTypeId() [member function]
   425     cls.add_method('GetTypeId', 
   439     cls.add_method('GetTypeId', 
   426                    'ns3::TypeId', 
   440                    'ns3::TypeId', 
   427                    [], 
   441                    [], 
   428                    is_static=True)
   442                    is_static=True)
   446     ## random-direction-2d-mobility-model.h: ns3::Vector ns3::RandomDirection2dMobilityModel::DoGetVelocity() const [member function]
   460     ## random-direction-2d-mobility-model.h: ns3::Vector ns3::RandomDirection2dMobilityModel::DoGetVelocity() const [member function]
   447     cls.add_method('DoGetVelocity', 
   461     cls.add_method('DoGetVelocity', 
   448                    'ns3::Vector', 
   462                    'ns3::Vector', 
   449                    [], 
   463                    [], 
   450                    is_const=True, visibility='private', is_virtual=True)
   464                    is_const=True, visibility='private', is_virtual=True)
   451     cls.add_copy_constructor()
       
   452     return
   465     return
   453 
   466 
   454 def register_Ns3GridPositionAllocator_methods(root_module, cls):
   467 def register_Ns3GridPositionAllocator_methods(root_module, cls):
       
   468     ## position-allocator.h: ns3::GridPositionAllocator::GridPositionAllocator(ns3::GridPositionAllocator const & arg0) [copy constructor]
       
   469     cls.add_constructor([param('ns3::GridPositionAllocator&', 'arg0', is_const=True)])
   455     ## position-allocator.h: static ns3::TypeId ns3::GridPositionAllocator::GetTypeId() [member function]
   470     ## position-allocator.h: static ns3::TypeId ns3::GridPositionAllocator::GetTypeId() [member function]
   456     cls.add_method('GetTypeId', 
   471     cls.add_method('GetTypeId', 
   457                    'ns3::TypeId', 
   472                    'ns3::TypeId', 
   458                    [], 
   473                    [], 
   459                    is_static=True)
   474                    is_static=True)
   516     ## position-allocator.h: ns3::Vector ns3::GridPositionAllocator::GetNext() const [member function]
   531     ## position-allocator.h: ns3::Vector ns3::GridPositionAllocator::GetNext() const [member function]
   517     cls.add_method('GetNext', 
   532     cls.add_method('GetNext', 
   518                    'ns3::Vector', 
   533                    'ns3::Vector', 
   519                    [], 
   534                    [], 
   520                    is_const=True, is_virtual=True)
   535                    is_const=True, is_virtual=True)
   521     cls.add_copy_constructor()
       
   522     return
   536     return
   523 
   537 
   524 def register_Ns3RandomWaypointMobilityModel_methods(root_module, cls):
   538 def register_Ns3RandomWaypointMobilityModel_methods(root_module, cls):
       
   539     ## random-waypoint-mobility-model.h: ns3::RandomWaypointMobilityModel::RandomWaypointMobilityModel(ns3::RandomWaypointMobilityModel const & arg0) [copy constructor]
       
   540     cls.add_constructor([param('ns3::RandomWaypointMobilityModel&', 'arg0', is_const=True)])
   525     ## random-waypoint-mobility-model.h: static ns3::TypeId ns3::RandomWaypointMobilityModel::GetTypeId() [member function]
   541     ## random-waypoint-mobility-model.h: static ns3::TypeId ns3::RandomWaypointMobilityModel::GetTypeId() [member function]
   526     cls.add_method('GetTypeId', 
   542     cls.add_method('GetTypeId', 
   527                    'ns3::TypeId', 
   543                    'ns3::TypeId', 
   528                    [], 
   544                    [], 
   529                    is_static=True)
   545                    is_static=True)
   542     ## random-waypoint-mobility-model.h: ns3::Vector ns3::RandomWaypointMobilityModel::DoGetVelocity() const [member function]
   558     ## random-waypoint-mobility-model.h: ns3::Vector ns3::RandomWaypointMobilityModel::DoGetVelocity() const [member function]
   543     cls.add_method('DoGetVelocity', 
   559     cls.add_method('DoGetVelocity', 
   544                    'ns3::Vector', 
   560                    'ns3::Vector', 
   545                    [], 
   561                    [], 
   546                    is_const=True, visibility='private', is_virtual=True)
   562                    is_const=True, visibility='private', is_virtual=True)
   547     cls.add_copy_constructor()
       
   548     return
   563     return
   549 
   564 
   550 def register_Ns3RandomWalk2dMobilityModel_methods(root_module, cls):
   565 def register_Ns3RandomWalk2dMobilityModel_methods(root_module, cls):
       
   566     ## random-walk-2d-mobility-model.h: ns3::RandomWalk2dMobilityModel::RandomWalk2dMobilityModel(ns3::RandomWalk2dMobilityModel const & arg0) [copy constructor]
       
   567     cls.add_constructor([param('ns3::RandomWalk2dMobilityModel&', 'arg0', is_const=True)])
   551     ## random-walk-2d-mobility-model.h: static ns3::TypeId ns3::RandomWalk2dMobilityModel::GetTypeId() [member function]
   568     ## random-walk-2d-mobility-model.h: static ns3::TypeId ns3::RandomWalk2dMobilityModel::GetTypeId() [member function]
   552     cls.add_method('GetTypeId', 
   569     cls.add_method('GetTypeId', 
   553                    'ns3::TypeId', 
   570                    'ns3::TypeId', 
   554                    [], 
   571                    [], 
   555                    is_static=True)
   572                    is_static=True)
   573     ## random-walk-2d-mobility-model.h: ns3::Vector ns3::RandomWalk2dMobilityModel::DoGetVelocity() const [member function]
   590     ## random-walk-2d-mobility-model.h: ns3::Vector ns3::RandomWalk2dMobilityModel::DoGetVelocity() const [member function]
   574     cls.add_method('DoGetVelocity', 
   591     cls.add_method('DoGetVelocity', 
   575                    'ns3::Vector', 
   592                    'ns3::Vector', 
   576                    [], 
   593                    [], 
   577                    is_const=True, visibility='private', is_virtual=True)
   594                    is_const=True, visibility='private', is_virtual=True)
   578     cls.add_copy_constructor()
       
   579     return
   595     return
   580 
   596 
   581 def register_Ns3StaticSpeedMobilityModel_methods(root_module, cls):
   597 def register_Ns3StaticSpeedMobilityModel_methods(root_module, cls):
       
   598     ## static-speed-mobility-model.h: ns3::StaticSpeedMobilityModel::StaticSpeedMobilityModel(ns3::StaticSpeedMobilityModel const & arg0) [copy constructor]
       
   599     cls.add_constructor([param('ns3::StaticSpeedMobilityModel&', 'arg0', is_const=True)])
   582     ## static-speed-mobility-model.h: static ns3::TypeId ns3::StaticSpeedMobilityModel::GetTypeId() [member function]
   600     ## static-speed-mobility-model.h: static ns3::TypeId ns3::StaticSpeedMobilityModel::GetTypeId() [member function]
   583     cls.add_method('GetTypeId', 
   601     cls.add_method('GetTypeId', 
   584                    'ns3::TypeId', 
   602                    'ns3::TypeId', 
   585                    [], 
   603                    [], 
   586                    is_static=True)
   604                    is_static=True)
   603     ## static-speed-mobility-model.h: ns3::Vector ns3::StaticSpeedMobilityModel::DoGetVelocity() const [member function]
   621     ## static-speed-mobility-model.h: ns3::Vector ns3::StaticSpeedMobilityModel::DoGetVelocity() const [member function]
   604     cls.add_method('DoGetVelocity', 
   622     cls.add_method('DoGetVelocity', 
   605                    'ns3::Vector', 
   623                    'ns3::Vector', 
   606                    [], 
   624                    [], 
   607                    is_const=True, visibility='private', is_virtual=True)
   625                    is_const=True, visibility='private', is_virtual=True)
   608     cls.add_copy_constructor()
       
   609     return
   626     return
   610 
   627 
   611 def register_Ns3HierarchicalMobilityModel_methods(root_module, cls):
   628 def register_Ns3HierarchicalMobilityModel_methods(root_module, cls):
       
   629     ## hierarchical-mobility-model.h: ns3::HierarchicalMobilityModel::HierarchicalMobilityModel(ns3::HierarchicalMobilityModel const & arg0) [copy constructor]
       
   630     cls.add_constructor([param('ns3::HierarchicalMobilityModel&', 'arg0', is_const=True)])
   612     ## hierarchical-mobility-model.h: static ns3::TypeId ns3::HierarchicalMobilityModel::GetTypeId() [member function]
   631     ## hierarchical-mobility-model.h: static ns3::TypeId ns3::HierarchicalMobilityModel::GetTypeId() [member function]
   613     cls.add_method('GetTypeId', 
   632     cls.add_method('GetTypeId', 
   614                    'ns3::TypeId', 
   633                    'ns3::TypeId', 
   615                    [], 
   634                    [], 
   616                    is_static=True)
   635                    is_static=True)
   639     ## hierarchical-mobility-model.h: ns3::Vector ns3::HierarchicalMobilityModel::DoGetVelocity() const [member function]
   658     ## hierarchical-mobility-model.h: ns3::Vector ns3::HierarchicalMobilityModel::DoGetVelocity() const [member function]
   640     cls.add_method('DoGetVelocity', 
   659     cls.add_method('DoGetVelocity', 
   641                    'ns3::Vector', 
   660                    'ns3::Vector', 
   642                    [], 
   661                    [], 
   643                    is_const=True, visibility='private', is_virtual=True)
   662                    is_const=True, visibility='private', is_virtual=True)
   644     cls.add_copy_constructor()
       
   645     return
   663     return
   646 
   664 
   647 def register_Ns3StaticMobilityModel_methods(root_module, cls):
   665 def register_Ns3StaticMobilityModel_methods(root_module, cls):
       
   666     ## static-mobility-model.h: ns3::StaticMobilityModel::StaticMobilityModel(ns3::StaticMobilityModel const & arg0) [copy constructor]
       
   667     cls.add_constructor([param('ns3::StaticMobilityModel&', 'arg0', is_const=True)])
   648     ## static-mobility-model.h: static ns3::TypeId ns3::StaticMobilityModel::GetTypeId() [member function]
   668     ## static-mobility-model.h: static ns3::TypeId ns3::StaticMobilityModel::GetTypeId() [member function]
   649     cls.add_method('GetTypeId', 
   669     cls.add_method('GetTypeId', 
   650                    'ns3::TypeId', 
   670                    'ns3::TypeId', 
   651                    [], 
   671                    [], 
   652                    is_static=True)
   672                    is_static=True)
   665     ## static-mobility-model.h: ns3::Vector ns3::StaticMobilityModel::DoGetVelocity() const [member function]
   685     ## static-mobility-model.h: ns3::Vector ns3::StaticMobilityModel::DoGetVelocity() const [member function]
   666     cls.add_method('DoGetVelocity', 
   686     cls.add_method('DoGetVelocity', 
   667                    'ns3::Vector', 
   687                    'ns3::Vector', 
   668                    [], 
   688                    [], 
   669                    is_const=True, visibility='private', is_virtual=True)
   689                    is_const=True, visibility='private', is_virtual=True)
   670     cls.add_copy_constructor()
       
   671     return
   690     return
   672 
   691 
   673 def register_functions(root_module):
   692 def register_functions(root_module):
   674     module = root_module
   693     module = root_module
   675     ## rectangle.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeRectangleChecker() [free function]
   694     ## rectangle.h: extern ns3::Ptr<ns3::AttributeChecker const> ns3::MakeRectangleChecker() [free function]