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::registerInstance()
 447 {
 448     registerInstance(_objectClass.get());
 449 }
 450
 451 void
 452 HLAObjectInstance::registerInstance(HLAObjectClass* objectClass)
 453 {
 454     if (_rtiObjectInstance.valid()) {
 455         SG_LOG(SG_IO, SG_ALERT, "Trying to register object " << getName() << " already known to the RTI!");
 456         return;
 457     }
 458     if (!objectClass) {
 459         SG_LOG(SG_IO, SG_ALERT, "Could not register object with unknown object class!");
 460         return;
 461     }
 462     if (_objectClass.valid() && objectClass != _objectClass.get()) {
 463         SG_LOG(SG_IO, SG_ALERT, "Could not change object class while registering!");
 464         return;
 465     }
 466     _objectClass = objectClass;
 467     _federate = _objectClass->_federate;
 468     // This error must have been flagged before
 469     if (!_objectClass->_rtiObjectClass.valid())
 470         return;
 471     _setRTIObjectInstance(_objectClass->_rtiObjectClass->registerObjectInstance(this));
 472     if (!_rtiObjectInstance.valid()) {
 473         SG_LOG(SG_IO, SG_ALERT, "Could not register object at the RTI!");
 474         return;
 475     }
 476     _objectClass->_registerInstance(this);
 477 }
 478
 479 void
 480 HLAObjectInstance::deleteInstance(const RTIData& tag)
 481 {
 482     if (!_rtiObjectInstance.valid()) {
 483         SG_LOG(SG_IO, SG_ALERT, "Trying to delete inactive object!");
 484         return;
 485     }
 486     if (!_objectClass.valid())
 487         return;
 488     _objectClass->_deleteInstance(*this);
 489     _rtiObjectInstance->deleteObjectInstance(tag);
 490 }
 491
 492 void
 493 HLAObjectInstance::updateAttributeValues(const RTIData& tag)
 494 {
 495     if (_updateCallback.valid()) {
 496         _updateCallback->updateAttributeValues(*this, tag);
 497     } else {
 498         encodeAttributeValues();
 499         sendAttributeValues(tag);
 500     }
 501 }
 502
 503 void
 504 HLAObjectInstance::updateAttributeValues(const SGTimeStamp& timeStamp, const RTIData& tag)
 505 {
 506     if (_updateCallback.valid()) {
 507         _updateCallback->updateAttributeValues(*this, timeStamp, tag);
 508     } else {
 509         encodeAttributeValues();
 510         sendAttributeValues(timeStamp, tag);
 511     }
 512 }
 513
 514 void
 515 HLAObjectInstance::encodeAttributeValues()
 516 {
 517     unsigned numAttributes = _attributeVector.size();
 518     for (unsigned i = 0; i < numAttributes;++i) {
 519         if (_attributeVector[i]._unconditionalUpdate) {
 520             encodeAttributeValue(i);
 521         } else if (_attributeVector[i]._enabledUpdate) {
 522             const HLADataElement* dataElement = getAttributeDataElement(i);
 523             if (dataElement && dataElement->getDirty())
 524                 encodeAttributeValue(i);
 525         }
 526     }
 527 }
 528
 529 void
 530 HLAObjectInstance::encodeAttributeValue(unsigned index)
 531 {
 532     if (!_rtiObjectInstance.valid()) {
 533         SG_LOG(SG_IO, SG_INFO, "Not updating inactive object!");
 534         return;
 535     }
 536     HLADataElement* dataElement = getAttributeDataElement(index);
 537     if (!dataElement)
 538         return;
 539     _rtiObjectInstance->encodeAttributeData(index, *dataElement);
 540     dataElement->setDirty(false);
 541 }
 542
 543 void
 544 HLAObjectInstance::sendAttributeValues(const RTIData& tag)
 545 {
 546     if (!_rtiObjectInstance.valid()) {
 547         SG_LOG(SG_IO, SG_INFO, "Not updating inactive object!");
 548         return;
 549     }
 550     _rtiObjectInstance->updateAttributeValues(tag);
 551 }
 552
 553 void
 554 HLAObjectInstance::sendAttributeValues(const SGTimeStamp& timeStamp, const RTIData& tag)
 555 {
 556     if (!_rtiObjectInstance.valid()) {
 557         SG_LOG(SG_IO, SG_INFO, "Not updating inactive object!");
 558         return;
 559     }
 560     _rtiObjectInstance->updateAttributeValues(timeStamp, tag);
 561 }
 562
 563 void
 564 HLAObjectInstance::reflectAttributeValues(const HLAIndexList& indexList, const RTIData& tag)
 565 {
 566     for (HLAIndexList::const_iterator i = indexList.begin(); i != indexList.end(); ++i)
 567         reflectAttributeValue(*i, tag);
 568 }
 569
 570 void
 571 HLAObjectInstance::reflectAttributeValues(const HLAIndexList& indexList,
 572                                           const SGTimeStamp& timeStamp, const RTIData& tag)
 573 {
 574     for (HLAIndexList::const_iterator i = indexList.begin(); i != indexList.end(); ++i)
 575         reflectAttributeValue(*i, timeStamp, tag);
 576 }
 577
 578 void
 579 HLAObjectInstance::reflectAttributeValue(unsigned index, const RTIData& tag)
 580 {
 581     HLADataElement* dataElement = getAttributeDataElement(index);
 582     if (!dataElement)
 583         return;
 584     dataElement->setTimeStampValid(false);
 585     _rtiObjectInstance->decodeAttributeData(index, *dataElement);
 586 }
 587
 588 void
 589 HLAObjectInstance::reflectAttributeValue(unsigned index, const SGTimeStamp& timeStamp, const RTIData& tag)
 590 {
 591     HLADataElement* dataElement = getAttributeDataElement(index);
 592     if (!dataElement)
 593         return;
 594     dataElement->setTimeStamp(timeStamp);
 595     dataElement->setTimeStampValid(true);
 596     _rtiObjectInstance->decodeAttributeData(index, *dataElement);
 597 }
 598
 599 void
 600 HLAObjectInstance::_setRTIObjectInstance(RTIObjectInstance* rtiObjectInstance)
 601 {
 602     if (!_objectClass.valid())
 603         return;
 604
 605     _rtiObjectInstance = rtiObjectInstance;
 606     _rtiObjectInstance->setObjectInstance(this);
 607     _name = _rtiObjectInstance->getName();
 608
 609     unsigned numAttributes = getNumAttributes();
 610     _attributeVector.resize(numAttributes);
 611     for (unsigned i = 0; i < numAttributes; ++i) {
 612         HLAUpdateType updateType = _objectClass->getAttributeUpdateType(i);
 613         if (getAttributeOwned(i) && updateType != HLAUndefinedUpdate) {
 614             _attributeVector[i]._enabledUpdate = true;
 615             _attributeVector[i]._unconditionalUpdate = (updateType == HLAPeriodicUpdate);
 616             // In case of an owned attribute, now encode its value
 617             encodeAttributeValue(i);
 618         } else {
 619             _attributeVector[i]._enabledUpdate = false;
 620             _attributeVector[i]._unconditionalUpdate = false;
 621         }
 622     }
 623
 624     // This makes sense with any new object. Even if we registered one, there might be unpublished attributes.
 625     HLAIndexList indexList;
 626     for (unsigned i = 0; i < numAttributes; ++i) {
 627         HLAUpdateType updateType = _objectClass->getAttributeUpdateType(i);
 628         if (getAttributeOwned(i))
 629             continue;
 630         if (updateType == HLAUndefinedUpdate)
 631             continue;
 632         if (updateType == HLAPeriodicUpdate)
 633             continue;
 634         indexList.push_back(i);
 635     }
 636     _rtiObjectInstance->requestObjectAttributeValueUpdate(indexList);
 637 }
 638
 639 void
 640 HLAObjectInstance::_clearRTIObjectInstance()
 641 {
 642     if (!_rtiObjectInstance.valid())
 643         return;
 644
 645     for (unsigned i = 0; i < _attributeVector.size(); ++i) {
 646         _attributeVector[i]._enabledUpdate = false;
 647         _attributeVector[i]._unconditionalUpdate = false;
 648     }
 649
 650     _rtiObjectInstance->setObjectInstance(0);
 651     _rtiObjectInstance = 0;
 652 }
 653
 654 void
 655 HLAObjectInstance::_removeInstance(const RTIData& tag)
 656 {
 657     if (!_objectClass.valid())
 658         return;
 659     _objectClass->_removeInstance(*this, tag);
 660 }
 661
 662 void
 663 HLAObjectInstance::_reflectAttributeValues(const HLAIndexList& indexList, const RTIData& tag)
 664 {
 665     if (_reflectCallback.valid()) {
 666         _reflectCallback->reflectAttributeValues(*this, indexList, tag);
 667     } else {
 668         reflectAttributeValues(indexList, tag);
 669     }
 670 }
 671
 672 void
 673 HLAObjectInstance::_reflectAttributeValues(const HLAIndexList& indexList, const SGTimeStamp& timeStamp, const RTIData& tag)
 674 {
 675     if (_reflectCallback.valid()) {
 676         _reflectCallback->reflectAttributeValues(*this, indexList, timeStamp, tag);
 677     } else {
 678         reflectAttributeValues(indexList, timeStamp, tag);
 679     }
 680 }
 681
 682 } // namespace simgear