simgear/hla/HLAObjectInstance.cxx

   1 // Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Library General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Library General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU General Public License
  14 // along with this program; if not, write to the Free Software
  15 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  16 //
  17
  18 #ifdef HAVE_CONFIG_H
  19 #  include <simgear_config.h>
  20 #endif
  21
  22 #include <simgear/compiler.h>
  23
  24 #include "HLAObjectInstance.hxx"
  25
  26 #include <algorithm>
  27 #include "simgear/debug/logstream.hxx"
  28 #include "HLAArrayDataElement.hxx"
  29 #include "HLABasicDataElement.hxx"
  30 #include "HLADataElement.hxx"
  31 #include "HLAEnumeratedDataElement.hxx"
  32 #include "HLAFederate.hxx"
  33 #include "HLAFixedRecordDataElement.hxx"
  34 #include "HLAObjectClass.hxx"
  35 #include "HLAVariantRecordDataElement.hxx"
  36 #include "RTIObjectClass.hxx"
  37 #include "RTIObjectInstance.hxx"
  38
  39 namespace simgear {
  40
  41 HLAObjectInstance::UpdateCallback::~UpdateCallback()
  42 {
  43 }
  44
  45 HLAObjectInstance::ReflectCallback::~ReflectCallback()
  46 {
  47 }
  48
  49 HLAObjectInstance::HLAObjectInstance(HLAObjectClass* objectClass) :
  50     _objectClass(objectClass)
  51 {
  52     if (objectClass)
  53         _federate = objectClass->_federate;
  54 }
  55
  56 HLAObjectInstance::~HLAObjectInstance()
  57 {
  58     _clearRTIObjectInstance();
  59 }
  60
  61 const std::string&
  62 HLAObjectInstance::getName() const
  63 {
  64     return _name;
  65 }
  66
  67 const SGWeakPtr<HLAFederate>&
  68 HLAObjectInstance::getFederate() const
  69 {
  70     return _federate;
  71 }
  72
  73 const SGSharedPtr<HLAObjectClass>&
  74 HLAObjectInstance::getObjectClass() const
  75 {
  76     return _objectClass;
  77 }
  78
  79 unsigned
  80 HLAObjectInstance::getNumAttributes() const
  81 {
  82     if (!_objectClass.valid())
  83         return 0;
  84     return _objectClass->getNumAttributes();
  85 }
  86
  87 unsigned
  88 HLAObjectInstance::getAttributeIndex(const std::string& name) const
  89 {
  90     if (!_objectClass.valid())
  91         return ~0u;
  92     return _objectClass->getAttributeIndex(name);
  93 }
  94
  95 std::string
  96 HLAObjectInstance::getAttributeName(unsigned index) const
  97 {
  98     if (!_objectClass.valid())
  99         return std::string();
 100     return _objectClass->getAttributeName(index);
 101 }
 102
 103 bool
 104 HLAObjectInstance::getAttributeOwned(unsigned index) const
 105 {
 106     if (!_rtiObjectInstance.valid())
 107         return false;
 108     return _rtiObjectInstance->getAttributeOwned(index);
 109 }
 110
 111 const HLADataType*
 112 HLAObjectInstance::getAttributeDataType(unsigned index) const
 113 {
 114     if (!_objectClass.valid())
 115         return 0;
 116     return _objectClass->getAttributeDataType(index);
 117 }
 118
 119 HLADataElement*
 120 HLAObjectInstance::getAttributeDataElement(unsigned index)
 121 {
 122     if (_attributeVector.size() <= index)
 123         return 0;
 124     return _attributeVector[index]._dataElement.get();
 125 }
 126
 127 const HLADataElement*
 128 HLAObjectInstance::getAttributeDataElement(unsigned index) const
 129 {
 130     if (_attributeVector.size() <= index)
 131         return 0;
 132     return _attributeVector[index]._dataElement.get();
 133 }
 134
 135 bool
 136 HLAObjectInstance::getAttributeData(unsigned index, RTIData& data) const
 137 {
 138     if (!_rtiObjectInstance.valid()) {
 139         SG_LOG(SG_IO, SG_ALERT, "Trying to get raw attribute data without rti object instance for \"" << getName() << "\"!");
 140         return false;
 141     }
 142     return _rtiObjectInstance->getAttributeData(index, data);
 143 }
 144
 145 void
 146 HLAObjectInstance::setAttributeDataElement(unsigned index, const SGSharedPtr<HLADataElement>& dataElement)
 147 {
 148     unsigned numAttributes = getNumAttributes();
 149     if (numAttributes <= index)
 150         return;
 151     _attributeVector.resize(numAttributes);
 152     if (_attributeVector[index]._dataElement.valid())
 153         _attributeVector[index]._dataElement->clearStamp();
 154     _attributeVector[index]._dataElement = dataElement;
 155     if (_attributeVector[index]._dataElement.valid())
 156         _attributeVector[index]._dataElement->createStamp();
 157 }
 158
 159 class HLAObjectInstance::DataElementFactoryVisitor : public HLADataElementFactoryVisitor {
 160 public:
 161     DataElementFactoryVisitor(const HLAPathElementMap& pathElementMap) :
 162         _pathElementMap(pathElementMap)
 163     { }
 164     DataElementFactoryVisitor(const HLADataElement::Path& path, const HLAPathElementMap& pathElementMap) :
 165         _pathElementMap(pathElementMap),
 166         _path(path)
 167     { }
 168     virtual ~DataElementFactoryVisitor() {}
 169
 170     virtual void apply(const HLADataType& dataType)
 171     {
 172         _dataElement = createDataElement(_path, dataType);
 173         if (_dataElement.valid())
 174             return;
 175
 176         SG_LOG(SG_NETWORK, SG_ALERT, "HLA: Can not find a suitable data element for data type \""
 177                << dataType.getName() << "\"");
 178     }
 179
 180     virtual void apply(const HLAInt8DataType& dataType)
 181     {
 182         _dataElement = createDataElement(_path, dataType);
 183         if (_dataElement.valid())
 184             return;
 185
 186         HLADataElementFactoryVisitor::apply(dataType);
 187     }
 188     virtual void apply(const HLAUInt8DataType& dataType)
 189     {
 190         _dataElement = createDataElement(_path, dataType);
 191         if (_dataElement.valid())
 192             return;
 193
 194         HLADataElementFactoryVisitor::apply(dataType);
 195     }
 196     virtual void apply(const HLAInt16DataType& dataType)
 197     {
 198         _dataElement = createDataElement(_path, dataType);
 199         if (_dataElement.valid())
 200             return;
 201
 202         HLADataElementFactoryVisitor::apply(dataType);
 203     }
 204     virtual void apply(const HLAUInt16DataType& dataType)
 205     {
 206         _dataElement = createDataElement(_path, dataType);
 207         if (_dataElement.valid())
 208             return;
 209
 210         HLADataElementFactoryVisitor::apply(dataType);
 211     }
 212     virtual void apply(const HLAInt32DataType& dataType)
 213     {
 214         _dataElement = createDataElement(_path, dataType);
 215         if (_dataElement.valid())
 216             return;
 217
 218         HLADataElementFactoryVisitor::apply(dataType);
 219     }
 220     virtual void apply(const HLAUInt32DataType& dataType)
 221     {
 222         _dataElement = createDataElement(_path, dataType);
 223         if (_dataElement.valid())
 224             return;
 225
 226         HLADataElementFactoryVisitor::apply(dataType);
 227     }
 228     virtual void apply(const HLAInt64DataType& dataType)
 229     {
 230         _dataElement = createDataElement(_path, dataType);
 231         if (_dataElement.valid())
 232             return;
 233
 234         HLADataElementFactoryVisitor::apply(dataType);
 235     }
 236     virtual void apply(const HLAUInt64DataType& dataType)
 237     {
 238         _dataElement = createDataElement(_path, dataType);
 239         if (_dataElement.valid())
 240             return;
 241
 242         HLADataElementFactoryVisitor::apply(dataType);
 243     }
 244     virtual void apply(const HLAFloat32DataType& dataType)
 245     {
 246         _dataElement = createDataElement(_path, dataType);
 247         if (_dataElement.valid())
 248             return;
 249
 250         HLADataElementFactoryVisitor::apply(dataType);
 251     }
 252     virtual void apply(const HLAFloat64DataType& dataType)
 253     {
 254         _dataElement = createDataElement(_path, dataType);
 255         if (_dataElement.valid())
 256             return;
 257
 258         HLADataElementFactoryVisitor::apply(dataType);
 259     }
 260
 261     class ArrayDataElementFactory : public HLAArrayDataElement::DataElementFactory {
 262     public:
 263         ArrayDataElementFactory(const HLADataElement::Path& path, const HLAPathElementMap& pathElementMap) :
 264             _path(path)
 265         {
 266             for (HLAPathElementMap::const_iterator i = pathElementMap.lower_bound(path);
 267                  i != pathElementMap.end(); ++i) {
 268                 if (i->first.begin() != std::search(i->first.begin(), i->first.end(),
 269                                                     path.begin(), path.end()))
 270                     break;
 271                 _pathElementMap.insert(*i);
 272             }
 273         }
 274         virtual HLADataElement* createElement(const HLAArrayDataElement& element, unsigned index)
 275         {
 276             const HLADataType* dataType = element.getElementDataType();
 277             if (!dataType)
 278                 return 0;
 279             HLADataElement::Path path = _path;
 280             path.push_back(HLADataElement::PathElement(index));
 281             DataElementFactoryVisitor visitor(path, _pathElementMap);
 282             dataType->accept(visitor);
 283             return visitor._dataElement.release();
 284         }
 285     private:
 286         HLADataElement::Path _path;
 287         HLAPathElementMap _pathElementMap;
 288     };
 289
 290     virtual void apply(const HLAFixedArrayDataType& dataType)
 291     {
 292         _dataElement = createDataElement(_path, dataType);
 293         if (_dataElement.valid())
 294             return;
 295
 296         SGSharedPtr<HLAArrayDataElement> arrayDataElement;
 297         arrayDataElement = new HLAArrayDataElement(&dataType);
 298         arrayDataElement->setDataElementFactory(new ArrayDataElementFactory(_path, _pathElementMap));
 299         arrayDataElement->setNumElements(dataType.getNumElements());
 300
 301         _dataElement = arrayDataElement;
 302     }
 303
 304     virtual void apply(const HLAVariableArrayDataType& dataType)
 305     {
 306         _dataElement = createDataElement(_path, dataType);
 307         if (_dataElement.valid())
 308             return;
 309
 310         SGSharedPtr<HLAArrayDataElement> arrayDataElement;
 311         arrayDataElement = new HLAArrayDataElement(&dataType);
 312         arrayDataElement->setDataElementFactory(new ArrayDataElementFactory(_path, _pathElementMap));
 313
 314         _dataElement = arrayDataElement;
 315     }
 316
 317     virtual void apply(const HLAEnumeratedDataType& dataType)
 318     {
 319         _dataElement = createDataElement(_path, dataType);
 320         if (_dataElement.valid())
 321             return;
 322
 323         HLADataElementFactoryVisitor::apply(dataType);
 324     }
 325
 326     virtual void apply(const HLAFixedRecordDataType& dataType)
 327     {
 328         _dataElement = createDataElement(_path, dataType);
 329         if (_dataElement.valid())
 330             return;
 331
 332         SGSharedPtr<HLAFixedRecordDataElement> recordDataElement;
 333         recordDataElement = new HLAFixedRecordDataElement(&dataType);
 334
 335         unsigned numFields = dataType.getNumFields();
 336         for (unsigned i = 0; i < numFields; ++i) {
 337
 338             _path.push_back(HLADataElement::PathElement(dataType.getFieldName(i)));
 339
 340             dataType.getFieldDataType(i)->accept(*this);
 341             recordDataElement->setField(i, _dataElement.release());
 342
 343             _path.pop_back();
 344         }
 345         _dataElement = recordDataElement;
 346     }
 347
 348     class VariantRecordDataElementFactory : public HLAVariantRecordDataElement::DataElementFactory {
 349     public:
 350         VariantRecordDataElementFactory(const HLADataElement::Path& path, const HLAPathElementMap& pathElementMap) :
 351             _path(path)
 352         {
 353             for (HLAPathElementMap::const_iterator i = pathElementMap.lower_bound(path);
 354                  i != pathElementMap.end(); ++i) {
 355                 if (i->first.begin() != std::search(i->first.begin(), i->first.end(),
 356                                                     path.begin(), path.end()))
 357                     break;
 358                 _pathElementMap.insert(*i);
 359             }
 360         }
 361         virtual HLADataElement* createElement(const HLAVariantRecordDataElement& element, unsigned index)
 362         {
 363             const HLAVariantRecordDataType* dataType = element.getDataType();
 364             if (!dataType)
 365                 return 0;
 366             const HLADataType* alternativeDataType = element.getAlternativeDataType();
 367             if (!alternativeDataType)
 368                 return 0;
 369             HLADataElement::Path path = _path;
 370             path.push_back(HLADataElement::PathElement(dataType->getAlternativeName(index)));
 371             DataElementFactoryVisitor visitor(path, _pathElementMap);
 372             alternativeDataType->accept(visitor);
 373             return visitor._dataElement.release();
 374         }
 375     private:
 376         HLADataElement::Path _path;
 377         HLAPathElementMap _pathElementMap;
 378     };
 379
 380     virtual void apply(const HLAVariantRecordDataType& dataType)
 381     {
 382         _dataElement = createDataElement(_path, dataType);
 383         if (_dataElement.valid())
 384             return;
 385
 386         SGSharedPtr<HLAVariantRecordDataElement> variantRecordDataElement;
 387         variantRecordDataElement = new HLAVariantRecordDataElement(&dataType);
 388         variantRecordDataElement->setDataElementFactory(new VariantRecordDataElementFactory(_path, _pathElementMap));
 389
 390         _dataElement = variantRecordDataElement;
 391     }
 392
 393 private:
 394     SGSharedPtr<HLADataElement> createDataElement(const HLADataElement::Path& path, const HLADataType& dataType)
 395     {
 396         HLAPathElementMap::const_iterator i = _pathElementMap.find(path);
 397         if (i == _pathElementMap.end()) {
 398             SG_LOG(SG_IO, SG_WARN, "No dataElement provided for \""
 399                    << HLADataElement::toString(path) << "\".");
 400
 401             return 0;
 402         }
 403         SGSharedPtr<HLADataElement> dataElement = i->second.getDataElement(path);
 404         if (!dataElement->setDataType(&dataType)) {
 405             SG_LOG(SG_IO, SG_ALERT, "Cannot set data type for data element at \""
 406                    << HLADataElement::toString(path) <<  "\"!");
 407             return 0;
 408         }
 409         SG_LOG(SG_IO, SG_DEBUG, "Using provided dataElement for \""
 410                << HLADataElement::toString(path) << "\".");
 411         return dataElement;
 412     }
 413
 414     const HLAPathElementMap& _pathElementMap;
 415     HLADataElement::Path _path;
 416 };
 417
 418 void
 419 HLAObjectInstance::setAttribute(unsigned index, const HLAPathElementMap& pathElementMap)
 420 {
 421     const HLADataType* dataType = getAttributeDataType(index);
 422     if (!dataType) {
 423         SG_LOG(SG_IO, SG_ALERT, "Cannot get attribute data type for setting attribute \""
 424                << getAttributeName(index) << "\" at index " << index << "!");
 425         return;
 426     }
 427
 428     SG_LOG(SG_IO, SG_DEBUG, "Setting DataElement for attribute \""
 429            << getAttributeName(index) << "\".");
 430
 431     DataElementFactoryVisitor visitor(pathElementMap);
 432     dataType->accept(visitor);
 433     setAttributeDataElement(index, visitor.getDataElement());
 434 }
 435
 436 void
 437 HLAObjectInstance::setAttributes(const HLAAttributePathElementMap& attributePathElementMap)
 438 {
 439     for (HLAAttributePathElementMap::const_iterator i = attributePathElementMap.begin();
 440          i != attributePathElementMap.end(); ++i) {
 441         setAttribute(i->first, i->second);
 442     }
 443 }
 444
 445 void
 446 HLAObjectInstance::discoverInstance(const RTIData& tag)
 447 {
 448     HLAObjectClass* objectClass = getObjectClass().get();
 449     if (!objectClass) {
 450         SG_LOG(SG_IO, SG_ALERT, "Could not discover instance of unknown object class!");
 451         return;
 452     }
 453     objectClass->discoverInstance(*this, tag);
 454 }
 455
 456 void
 457 HLAObjectInstance::removeInstance(const RTIData& tag)
 458 {
 459     HLAObjectClass* objectClass = getObjectClass().get();
 460     if (!objectClass) {
 461         SG_LOG(SG_IO, SG_ALERT, "Could not remove instance of unknown object class!");
 462         return;
 463     }
 464     objectClass->removeInstance(*this, tag);
 465 }
 466
 467 void
 468 HLAObjectInstance::registerInstance()
 469 {
 470     registerInstance(_objectClass.get());
 471 }
 472
 473 void
 474 HLAObjectInstance::registerInstance(HLAObjectClass* objectClass)
 475 {
 476     if (_rtiObjectInstance.valid()) {
 477         SG_LOG(SG_IO, SG_ALERT, "Trying to register object " << getName() << " already known to the RTI!");
 478         return;
 479     }
 480     if (!objectClass) {
 481         SG_LOG(SG_IO, SG_ALERT, "Could not register object with unknown object class!");
 482         return;
 483     }
 484     if (_objectClass.valid() && objectClass != _objectClass.get()) {
 485         SG_LOG(SG_IO, SG_ALERT, "Could not change object class while registering!");
 486         return;
 487     }
 488     _objectClass = objectClass;
 489     _federate = _objectClass->_federate;
 490     // This error must have been flagged before
 491     if (!_objectClass->_rtiObjectClass.valid())
 492         return;
 493     _setRTIObjectInstance(_objectClass->_rtiObjectClass->registerObjectInstance(this));
 494     if (!_rtiObjectInstance.valid()) {
 495         SG_LOG(SG_IO, SG_ALERT, "Could not register object at the RTI!");
 496         return;
 497     }
 498     _objectClass->_registerInstance(this);
 499 }
 500
 501 void
 502 HLAObjectInstance::deleteInstance(const RTIData& tag)
 503 {
 504     if (!_rtiObjectInstance.valid()) {
 505         SG_LOG(SG_IO, SG_ALERT, "Trying to delete inactive object!");
 506         return;
 507     }
 508     if (!_objectClass.valid())
 509         return;
 510     _objectClass->_deleteInstance(*this);
 511     _rtiObjectInstance->deleteObjectInstance(tag);
 512 }
 513
 514 void
 515 HLAObjectInstance::createAttributeDataElements()
 516 {
 517     HLAObjectClass* objectClass = getObjectClass().get();
 518     if (!objectClass) {
 519         SG_LOG(SG_IO, SG_ALERT, "Could not create data elements for instance of unknown object class!");
 520         return;
 521     }
 522     objectClass->createAttributeDataElements(*this);
 523 }
 524
 525 void
 526 HLAObjectInstance::createAndSetAttributeDataElement(unsigned index)
 527 {
 528     if (getAttributeDataElement(index)) {
 529         SG_LOG(SG_IO, SG_DEBUG, "Attribute data element for attribute \""
 530                << getAttributeName(index) << "\" is already set.");
 531         return;
 532     }
 533     SGSharedPtr<HLADataElement> dataElement = createAttributeDataElement(index);
 534     setAttributeDataElement(index, dataElement);
 535 }
 536
 537 HLADataElement*
 538 HLAObjectInstance::createAttributeDataElement(unsigned index)
 539 {
 540     HLAObjectClass* objectClass = getObjectClass().get();
 541     if (!objectClass) {
 542         SG_LOG(SG_IO, SG_ALERT, "Could not create data element for instance of unknown object class!");
 543         return 0;
 544     }
 545     return objectClass->createAttributeDataElement(*this, index);
 546 }
 547
 548 void
 549 HLAObjectInstance::updateAttributeValues(const RTIData& tag)
 550 {
 551     if (_updateCallback.valid()) {
 552         _updateCallback->updateAttributeValues(*this, tag);
 553     } else {
 554         encodeAttributeValues();
 555         sendAttributeValues(tag);
 556     }
 557 }
 558
 559 void
 560 HLAObjectInstance::updateAttributeValues(const SGTimeStamp& timeStamp, const RTIData& tag)
 561 {
 562     if (_updateCallback.valid()) {
 563         _updateCallback->updateAttributeValues(*this, timeStamp, tag);
 564     } else {
 565         encodeAttributeValues();
 566         sendAttributeValues(timeStamp, tag);
 567     }
 568 }
 569
 570 void
 571 HLAObjectInstance::encodeAttributeValues()
 572 {
 573     unsigned numAttributes = _attributeVector.size();
 574     for (unsigned i = 0; i < numAttributes;++i) {
 575         if (_attributeVector[i]._unconditionalUpdate) {
 576             encodeAttributeValue(i);
 577         } else if (_attributeVector[i]._enabledUpdate) {
 578             const HLADataElement* dataElement = getAttributeDataElement(i);
 579             if (dataElement && dataElement->getDirty())
 580                 encodeAttributeValue(i);
 581         }
 582     }
 583 }
 584
 585 void
 586 HLAObjectInstance::encodeAttributeValue(unsigned index)
 587 {
 588     if (!_rtiObjectInstance.valid()) {
 589         SG_LOG(SG_IO, SG_INFO, "Not updating inactive object!");
 590         return;
 591     }
 592     HLADataElement* dataElement = getAttributeDataElement(index);
 593     if (!dataElement)
 594         return;
 595     _rtiObjectInstance->encodeAttributeData(index, *dataElement);
 596     dataElement->setDirty(false);
 597 }
 598
 599 void
 600 HLAObjectInstance::sendAttributeValues(const RTIData& tag)
 601 {
 602     if (!_rtiObjectInstance.valid()) {
 603         SG_LOG(SG_IO, SG_INFO, "Not updating inactive object!");
 604         return;
 605     }
 606     _rtiObjectInstance->updateAttributeValues(tag);
 607 }
 608
 609 void
 610 HLAObjectInstance::sendAttributeValues(const SGTimeStamp& timeStamp, const RTIData& tag)
 611 {
 612     if (!_rtiObjectInstance.valid()) {
 613         SG_LOG(SG_IO, SG_INFO, "Not updating inactive object!");
 614         return;
 615     }
 616     _rtiObjectInstance->updateAttributeValues(timeStamp, tag);
 617 }
 618
 619 void
 620 HLAObjectInstance::reflectAttributeValues(const HLAIndexList& indexList, const RTIData& tag)
 621 {
 622     for (HLAIndexList::const_iterator i = indexList.begin(); i != indexList.end(); ++i)
 623         reflectAttributeValue(*i, tag);
 624 }
 625
 626 void
 627 HLAObjectInstance::reflectAttributeValues(const HLAIndexList& indexList,
 628                                           const SGTimeStamp& timeStamp, const RTIData& tag)
 629 {
 630     for (HLAIndexList::const_iterator i = indexList.begin(); i != indexList.end(); ++i)
 631         reflectAttributeValue(*i, timeStamp, tag);
 632 }
 633
 634 void
 635 HLAObjectInstance::reflectAttributeValue(unsigned index, const RTIData& tag)
 636 {
 637     HLADataElement* dataElement = getAttributeDataElement(index);
 638     if (!dataElement)
 639         return;
 640     dataElement->setTimeStampValid(false);
 641     _rtiObjectInstance->decodeAttributeData(index, *dataElement);
 642 }
 643
 644 void
 645 HLAObjectInstance::reflectAttributeValue(unsigned index, const SGTimeStamp& timeStamp, const RTIData& tag)
 646 {
 647     HLADataElement* dataElement = getAttributeDataElement(index);
 648     if (!dataElement)
 649         return;
 650     dataElement->setTimeStamp(timeStamp);
 651     dataElement->setTimeStampValid(true);
 652     _rtiObjectInstance->decodeAttributeData(index, *dataElement);
 653 }
 654
 655 void
 656 HLAObjectInstance::_setRTIObjectInstance(RTIObjectInstance* rtiObjectInstance)
 657 {
 658     if (!_objectClass.valid())
 659         return;
 660
 661     _rtiObjectInstance = rtiObjectInstance;
 662     _rtiObjectInstance->setObjectInstance(this);
 663     _name = _rtiObjectInstance->getName();
 664
 665     unsigned numAttributes = getNumAttributes();
 666     _attributeVector.resize(numAttributes);
 667     for (unsigned i = 0; i < numAttributes; ++i) {
 668         HLAUpdateType updateType = _objectClass->getAttributeUpdateType(i);
 669         if (getAttributeOwned(i) && updateType != HLAUndefinedUpdate) {
 670             _attributeVector[i]._enabledUpdate = true;
 671             _attributeVector[i]._unconditionalUpdate = (updateType == HLAPeriodicUpdate);
 672             // In case of an owned attribute, now encode its value
 673             encodeAttributeValue(i);
 674         } else {
 675             _attributeVector[i]._enabledUpdate = false;
 676             _attributeVector[i]._unconditionalUpdate = false;
 677         }
 678     }
 679
 680     // This makes sense with any new object. Even if we registered one, there might be unpublished attributes.
 681     HLAIndexList indexList;
 682     for (unsigned i = 0; i < numAttributes; ++i) {
 683         HLAUpdateType updateType = _objectClass->getAttributeUpdateType(i);
 684         if (getAttributeOwned(i))
 685             continue;
 686         if (updateType == HLAUndefinedUpdate)
 687             continue;
 688         if (updateType == HLAPeriodicUpdate)
 689             continue;
 690         indexList.push_back(i);
 691     }
 692     _rtiObjectInstance->requestObjectAttributeValueUpdate(indexList);
 693 }
 694
 695 void
 696 HLAObjectInstance::_clearRTIObjectInstance()
 697 {
 698     if (!_rtiObjectInstance.valid())
 699         return;
 700
 701     for (unsigned i = 0; i < _attributeVector.size(); ++i) {
 702         _attributeVector[i]._enabledUpdate = false;
 703         _attributeVector[i]._unconditionalUpdate = false;
 704     }
 705
 706     _rtiObjectInstance->setObjectInstance(0);
 707     _rtiObjectInstance = 0;
 708 }
 709
 710 void
 711 HLAObjectInstance::_removeInstance(const RTIData& tag)
 712 {
 713     if (!_objectClass.valid())
 714         return;
 715     _objectClass->_removeInstance(*this, tag);
 716 }
 717
 718 void
 719 HLAObjectInstance::_reflectAttributeValues(const HLAIndexList& indexList, const RTIData& tag)
 720 {
 721     if (_reflectCallback.valid()) {
 722         _reflectCallback->reflectAttributeValues(*this, indexList, tag);
 723     } else {
 724         reflectAttributeValues(indexList, tag);
 725     }
 726 }
 727
 728 void
 729 HLAObjectInstance::_reflectAttributeValues(const HLAIndexList& indexList, const SGTimeStamp& timeStamp, const RTIData& tag)
 730 {
 731     if (_reflectCallback.valid()) {
 732         _reflectCallback->reflectAttributeValues(*this, indexList, timeStamp, tag);
 733     } else {
 734         reflectAttributeValues(indexList, timeStamp, tag);
 735     }
 736 }
 737
 738 } // namespace simgear