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 (_attributeCallback.valid())
 496         _attributeCallback->updateAttributeValues(*this, tag);
 497     if (_updateCallback.valid()) {
 498         _updateCallback->updateAttributeValues(*this, tag);
 499     } else {
 500         encodeAttributeValues();
 501         sendAttributeValues(tag);
 502     }
 503 }
 504
 505 void
 506 HLAObjectInstance::updateAttributeValues(const SGTimeStamp& timeStamp, const RTIData& tag)
 507 {
 508     if (_attributeCallback.valid())
 509         _attributeCallback->updateAttributeValues(*this, tag);
 510     if (_updateCallback.valid()) {
 511         _updateCallback->updateAttributeValues(*this, timeStamp, tag);
 512     } else {
 513         encodeAttributeValues();
 514         sendAttributeValues(timeStamp, tag);
 515     }
 516 }
 517
 518 void
 519 HLAObjectInstance::encodeAttributeValues()
 520 {
 521     unsigned numAttributes = _attributeVector.size();
 522     for (unsigned i = 0; i < numAttributes;++i) {
 523         if (_attributeVector[i]._unconditionalUpdate) {
 524             encodeAttributeValue(i);
 525         } else if (_attributeVector[i]._enabledUpdate) {
 526             const HLADataElement* dataElement = getAttributeDataElement(i);
 527             if (dataElement && dataElement->getDirty())
 528                 encodeAttributeValue(i);
 529         }
 530     }
 531 }
 532
 533 void
 534 HLAObjectInstance::encodeAttributeValue(unsigned index)
 535 {
 536     if (!_rtiObjectInstance.valid()) {
 537         SG_LOG(SG_IO, SG_INFO, "Not updating inactive object!");
 538         return;
 539     }
 540     HLADataElement* dataElement = getAttributeDataElement(index);
 541     if (!dataElement)
 542         return;
 543     _rtiObjectInstance->encodeAttributeData(index, *dataElement);
 544     dataElement->setDirty(false);
 545 }
 546
 547 void
 548 HLAObjectInstance::sendAttributeValues(const RTIData& tag)
 549 {
 550     if (!_rtiObjectInstance.valid()) {
 551         SG_LOG(SG_IO, SG_INFO, "Not updating inactive object!");
 552         return;
 553     }
 554     _rtiObjectInstance->updateAttributeValues(tag);
 555 }
 556
 557 void
 558 HLAObjectInstance::sendAttributeValues(const SGTimeStamp& timeStamp, const RTIData& tag)
 559 {
 560     if (!_rtiObjectInstance.valid()) {
 561         SG_LOG(SG_IO, SG_INFO, "Not updating inactive object!");
 562         return;
 563     }
 564     _rtiObjectInstance->updateAttributeValues(timeStamp, tag);
 565 }
 566
 567 void
 568 HLAObjectInstance::reflectAttributeValues(const HLAIndexList& indexList, const RTIData& tag)
 569 {
 570     for (HLAIndexList::const_iterator i = indexList.begin(); i != indexList.end(); ++i)
 571         reflectAttributeValue(*i, tag);
 572 }
 573
 574 void
 575 HLAObjectInstance::reflectAttributeValues(const HLAIndexList& indexList,
 576                                           const SGTimeStamp& timeStamp, const RTIData& tag)
 577 {
 578     for (HLAIndexList::const_iterator i = indexList.begin(); i != indexList.end(); ++i)
 579         reflectAttributeValue(*i, timeStamp, tag);
 580 }
 581
 582 void
 583 HLAObjectInstance::reflectAttributeValue(unsigned index, const RTIData& tag)
 584 {
 585     HLADataElement* dataElement = getAttributeDataElement(index);
 586     if (!dataElement)
 587         return;
 588     dataElement->setTimeStampValid(false);
 589     _rtiObjectInstance->decodeAttributeData(index, *dataElement);
 590 }
 591
 592 void
 593 HLAObjectInstance::reflectAttributeValue(unsigned index, const SGTimeStamp& timeStamp, const RTIData& tag)
 594 {
 595     HLADataElement* dataElement = getAttributeDataElement(index);
 596     if (!dataElement)
 597         return;
 598     dataElement->setTimeStamp(timeStamp);
 599     dataElement->setTimeStampValid(true);
 600     _rtiObjectInstance->decodeAttributeData(index, *dataElement);
 601 }
 602
 603 void
 604 HLAObjectInstance::_setRTIObjectInstance(RTIObjectInstance* rtiObjectInstance)
 605 {
 606     if (!_objectClass.valid())
 607         return;
 608
 609     _rtiObjectInstance = rtiObjectInstance;
 610     _rtiObjectInstance->setObjectInstance(this);
 611     _name = _rtiObjectInstance->getName();
 612
 613     unsigned numAttributes = getNumAttributes();
 614     _attributeVector.resize(numAttributes);
 615     for (unsigned i = 0; i < numAttributes; ++i) {
 616         HLAUpdateType updateType = _objectClass->getAttributeUpdateType(i);
 617         if (getAttributeOwned(i) && updateType != HLAUndefinedUpdate) {
 618             _attributeVector[i]._enabledUpdate = true;
 619             _attributeVector[i]._unconditionalUpdate = (updateType == HLAPeriodicUpdate);
 620             // In case of an owned attribute, now encode its value
 621             encodeAttributeValue(i);
 622         } else {
 623             _attributeVector[i]._enabledUpdate = false;
 624             _attributeVector[i]._unconditionalUpdate = false;
 625         }
 626     }
 627
 628     // This makes sense with any new object. Even if we registered one, there might be unpublished attributes.
 629     HLAIndexList indexList;
 630     for (unsigned i = 0; i < numAttributes; ++i) {
 631         HLAUpdateType updateType = _objectClass->getAttributeUpdateType(i);
 632         if (getAttributeOwned(i))
 633             continue;
 634         if (updateType == HLAUndefinedUpdate)
 635             continue;
 636         if (updateType == HLAPeriodicUpdate)
 637             continue;
 638         indexList.push_back(i);
 639     }
 640     _rtiObjectInstance->requestObjectAttributeValueUpdate(indexList);
 641 }
 642
 643 void
 644 HLAObjectInstance::_clearRTIObjectInstance()
 645 {
 646     if (!_rtiObjectInstance.valid())
 647         return;
 648
 649     for (unsigned i = 0; i < _attributeVector.size(); ++i) {
 650         _attributeVector[i]._enabledUpdate = false;
 651         _attributeVector[i]._unconditionalUpdate = false;
 652     }
 653
 654     _rtiObjectInstance->setObjectInstance(0);
 655     _rtiObjectInstance = 0;
 656 }
 657
 658 void
 659 HLAObjectInstance::_removeInstance(const RTIData& tag)
 660 {
 661     if (!_objectClass.valid())
 662         return;
 663     _objectClass->_removeInstance(*this, tag);
 664 }
 665
 666 void
 667 HLAObjectInstance::_reflectAttributeValues(const HLAIndexList& indexList, const RTIData& tag)
 668 {
 669     if (_reflectCallback.valid()) {
 670         _reflectCallback->reflectAttributeValues(*this, indexList, tag);
 671     } else if (_attributeCallback.valid()) {
 672         reflectAttributeValues(indexList, tag);
 673
 674         RTIIndexDataPairList dataPairList;
 675         for (HLAIndexList::const_iterator i = indexList.begin(); i != indexList.end(); ++i) {
 676             dataPairList.push_back(RTIIndexDataPair());
 677             dataPairList.back().first = *i;
 678             getAttributeData(*i, dataPairList.back().second);
 679         }
 680         _attributeCallback->reflectAttributeValues(*this, dataPairList, tag);
 681     } else {
 682         reflectAttributeValues(indexList, tag);
 683     }
 684 }
 685
 686 void
 687 HLAObjectInstance::_reflectAttributeValues(const HLAIndexList& indexList, const SGTimeStamp& timeStamp, const RTIData& tag)
 688 {
 689     if (_reflectCallback.valid()) {
 690         _reflectCallback->reflectAttributeValues(*this, indexList, timeStamp, tag);
 691     } else if (_attributeCallback.valid()) {
 692         reflectAttributeValues(indexList, timeStamp, tag);
 693
 694         RTIIndexDataPairList dataPairList;
 695         for (HLAIndexList::const_iterator i = indexList.begin(); i != indexList.end(); ++i) {
 696             dataPairList.push_back(RTIIndexDataPair());
 697             dataPairList.back().first = *i;
 698             getAttributeData(*i, dataPairList.back().second);
 699         }
 700         _attributeCallback->reflectAttributeValues(*this, dataPairList, timeStamp, tag);
 701     } else {
 702         reflectAttributeValues(indexList, timeStamp, tag);
 703     }
 704 }
 705
 706 } // namespace simgear