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 bool
 446 HLAObjectInstance::getAttributeIndex(HLADataElementIndex& index, const std::string& path) const
 447 {
 448     HLAObjectClass* objectClass = getObjectClass().get();
 449     if (!objectClass) {
 450         SG_LOG(SG_IO, SG_ALERT, "Could not get the data element index of an object instance with unknown class!");
 451         return false;
 452     }
 453     return objectClass->getAttributeIndex(index, path);
 454 }
 455
 456 HLADataElement*
 457 HLAObjectInstance::getAttributeDataElement(const HLADataElementIndex& index)
 458 {
 459     if (index.empty())
 460         return 0;
 461     HLADataElement* dataElement = getAttributeDataElement(index[0]);
 462     if (!dataElement)
 463         return 0;
 464     return dataElement->getDataElement(index.begin() + 1, index.end());
 465 }
 466
 467 const HLADataElement*
 468 HLAObjectInstance::getAttributeDataElement(const HLADataElementIndex& index) const
 469 {
 470     if (index.empty())
 471         return 0;
 472     const HLADataElement* dataElement = getAttributeDataElement(index[0]);
 473     if (!dataElement)
 474         return 0;
 475     return dataElement->getDataElement(index.begin() + 1, index.end());
 476 }
 477
 478 void
 479 HLAObjectInstance::setAttributeDataElement(const HLADataElementIndex& index, const SGSharedPtr<HLADataElement>& dataElement)
 480 {
 481     if (index.empty())
 482         return;
 483     if (index.size() == 1) {
 484         if (!getAttributeDataType(index[0]))
 485             return;
 486         if (dataElement.valid() && !dataElement->setDataType(getAttributeDataType(index[0])))
 487             return;
 488         setAttributeDataElement(index[0], dataElement);
 489     } else {
 490         SGSharedPtr<HLADataElement> attributeDataElement = getAttributeDataElement(index[0]);
 491         if (!attributeDataElement.valid())
 492             attributeDataElement = createAttributeDataElement(index[0]);
 493         if (!attributeDataElement.valid())
 494             return;
 495         attributeDataElement->setDataElement(index.begin() + 1, index.end(), dataElement.get());
 496     }
 497 }
 498
 499 HLADataElement*
 500 HLAObjectInstance::getAttributeDataElement(const std::string& path)
 501 {
 502     HLADataElementIndex index;
 503     if (!getAttributeIndex(index, path))
 504         return 0;
 505     return getAttributeDataElement(index);
 506 }
 507
 508 const HLADataElement*
 509 HLAObjectInstance::getAttributeDataElement(const std::string& path) const
 510 {
 511     HLADataElementIndex index;
 512     if (!getAttributeIndex(index, path))
 513         return 0;
 514     return getAttributeDataElement(index);
 515 }
 516
 517 void
 518 HLAObjectInstance::setAttributeDataElement(const std::string& path, const SGSharedPtr<HLADataElement>& dataElement)
 519 {
 520     HLADataElementIndex index;
 521     if (!getAttributeIndex(index, path))
 522         return;
 523     setAttributeDataElement(index, dataElement);
 524 }
 525
 526 void
 527 HLAObjectInstance::discoverInstance(const RTIData& tag)
 528 {
 529     HLAObjectClass* objectClass = getObjectClass().get();
 530     if (!objectClass) {
 531         SG_LOG(SG_IO, SG_ALERT, "Could not discover instance of unknown object class!");
 532         return;
 533     }
 534     objectClass->discoverInstance(*this, tag);
 535 }
 536
 537 void
 538 HLAObjectInstance::removeInstance(const RTIData& tag)
 539 {
 540     HLAObjectClass* objectClass = getObjectClass().get();
 541     if (!objectClass) {
 542         SG_LOG(SG_IO, SG_ALERT, "Could not remove instance of unknown object class!");
 543         return;
 544     }
 545     objectClass->removeInstance(*this, tag);
 546 }
 547
 548 void
 549 HLAObjectInstance::registerInstance()
 550 {
 551     registerInstance(_objectClass.get());
 552 }
 553
 554 void
 555 HLAObjectInstance::registerInstance(HLAObjectClass* objectClass)
 556 {
 557     if (_rtiObjectInstance.valid()) {
 558         SG_LOG(SG_IO, SG_ALERT, "Trying to register object " << getName() << " already known to the RTI!");
 559         return;
 560     }
 561     if (!objectClass) {
 562         SG_LOG(SG_IO, SG_ALERT, "Could not register object with unknown object class!");
 563         return;
 564     }
 565     if (_objectClass.valid() && objectClass != _objectClass.get()) {
 566         SG_LOG(SG_IO, SG_ALERT, "Could not change object class while registering!");
 567         return;
 568     }
 569     _objectClass = objectClass;
 570     _federate = _objectClass->_federate;
 571     // This error must have been flagged before
 572     if (!_objectClass->_rtiObjectClass.valid())
 573         return;
 574     _setRTIObjectInstance(_objectClass->_rtiObjectClass->registerObjectInstance(this));
 575     if (!_rtiObjectInstance.valid()) {
 576         SG_LOG(SG_IO, SG_ALERT, "Could not register object at the RTI!");
 577         return;
 578     }
 579     _objectClass->_registerInstance(this);
 580 }
 581
 582 void
 583 HLAObjectInstance::deleteInstance(const RTIData& tag)
 584 {
 585     if (!_rtiObjectInstance.valid()) {
 586         SG_LOG(SG_IO, SG_ALERT, "Trying to delete inactive object!");
 587         return;
 588     }
 589     if (!_objectClass.valid())
 590         return;
 591     _objectClass->_deleteInstance(*this);
 592     _rtiObjectInstance->deleteObjectInstance(tag);
 593 }
 594
 595 void
 596 HLAObjectInstance::createAttributeDataElements()
 597 {
 598     HLAObjectClass* objectClass = getObjectClass().get();
 599     if (!objectClass) {
 600         SG_LOG(SG_IO, SG_ALERT, "Could not create data elements for instance of unknown object class!");
 601         return;
 602     }
 603     objectClass->createAttributeDataElements(*this);
 604 }
 605
 606 void
 607 HLAObjectInstance::createAndSetAttributeDataElement(unsigned index)
 608 {
 609     if (getAttributeDataElement(index)) {
 610         SG_LOG(SG_IO, SG_DEBUG, "Attribute data element for attribute \""
 611                << getAttributeName(index) << "\" is already set.");
 612         return;
 613     }
 614     SGSharedPtr<HLADataElement> dataElement = createAttributeDataElement(index);
 615     setAttributeDataElement(index, dataElement);
 616 }
 617
 618 HLADataElement*
 619 HLAObjectInstance::createAttributeDataElement(unsigned index)
 620 {
 621     HLAObjectClass* objectClass = getObjectClass().get();
 622     if (!objectClass) {
 623         SG_LOG(SG_IO, SG_ALERT, "Could not create data element for instance of unknown object class!");
 624         return 0;
 625     }
 626     return objectClass->createAttributeDataElement(*this, index);
 627 }
 628
 629 void
 630 HLAObjectInstance::updateAttributeValues(const RTIData& tag)
 631 {
 632     if (_updateCallback.valid()) {
 633         _updateCallback->updateAttributeValues(*this, tag);
 634     } else {
 635         encodeAttributeValues();
 636         sendAttributeValues(tag);
 637     }
 638 }
 639
 640 void
 641 HLAObjectInstance::updateAttributeValues(const SGTimeStamp& timeStamp, const RTIData& tag)
 642 {
 643     if (_updateCallback.valid()) {
 644         _updateCallback->updateAttributeValues(*this, timeStamp, tag);
 645     } else {
 646         encodeAttributeValues();
 647         sendAttributeValues(timeStamp, tag);
 648     }
 649 }
 650
 651 void
 652 HLAObjectInstance::encodeAttributeValues()
 653 {
 654     unsigned numAttributes = _attributeVector.size();
 655     for (unsigned i = 0; i < numAttributes;++i) {
 656         if (_attributeVector[i]._unconditionalUpdate) {
 657             encodeAttributeValue(i);
 658         } else if (_attributeVector[i]._enabledUpdate) {
 659             const HLADataElement* dataElement = getAttributeDataElement(i);
 660             if (dataElement && dataElement->getDirty())
 661                 encodeAttributeValue(i);
 662         }
 663     }
 664 }
 665
 666 void
 667 HLAObjectInstance::encodeAttributeValue(unsigned index)
 668 {
 669     if (!_rtiObjectInstance.valid()) {
 670         SG_LOG(SG_IO, SG_INFO, "Not updating inactive object!");
 671         return;
 672     }
 673     HLADataElement* dataElement = getAttributeDataElement(index);
 674     if (!dataElement)
 675         return;
 676     _rtiObjectInstance->encodeAttributeData(index, *dataElement);
 677     dataElement->setDirty(false);
 678 }
 679
 680 void
 681 HLAObjectInstance::sendAttributeValues(const RTIData& tag)
 682 {
 683     if (!_rtiObjectInstance.valid()) {
 684         SG_LOG(SG_IO, SG_INFO, "Not updating inactive object!");
 685         return;
 686     }
 687     _rtiObjectInstance->updateAttributeValues(tag);
 688 }
 689
 690 void
 691 HLAObjectInstance::sendAttributeValues(const SGTimeStamp& timeStamp, const RTIData& tag)
 692 {
 693     if (!_rtiObjectInstance.valid()) {
 694         SG_LOG(SG_IO, SG_INFO, "Not updating inactive object!");
 695         return;
 696     }
 697     _rtiObjectInstance->updateAttributeValues(timeStamp, tag);
 698 }
 699
 700 void
 701 HLAObjectInstance::reflectAttributeValues(const HLAIndexList& indexList, const RTIData& tag)
 702 {
 703     for (HLAIndexList::const_iterator i = indexList.begin(); i != indexList.end(); ++i)
 704         reflectAttributeValue(*i, tag);
 705 }
 706
 707 void
 708 HLAObjectInstance::reflectAttributeValues(const HLAIndexList& indexList,
 709                                           const SGTimeStamp& timeStamp, const RTIData& tag)
 710 {
 711     for (HLAIndexList::const_iterator i = indexList.begin(); i != indexList.end(); ++i)
 712         reflectAttributeValue(*i, timeStamp, tag);
 713 }
 714
 715 void
 716 HLAObjectInstance::reflectAttributeValue(unsigned index, const RTIData& tag)
 717 {
 718     HLADataElement* dataElement = getAttributeDataElement(index);
 719     if (!dataElement)
 720         return;
 721     dataElement->setTimeStampValid(false);
 722     _rtiObjectInstance->decodeAttributeData(index, *dataElement);
 723 }
 724
 725 void
 726 HLAObjectInstance::reflectAttributeValue(unsigned index, const SGTimeStamp& timeStamp, const RTIData& tag)
 727 {
 728     HLADataElement* dataElement = getAttributeDataElement(index);
 729     if (!dataElement)
 730         return;
 731     dataElement->setTimeStamp(timeStamp);
 732     dataElement->setTimeStampValid(true);
 733     _rtiObjectInstance->decodeAttributeData(index, *dataElement);
 734 }
 735
 736 void
 737 HLAObjectInstance::_setRTIObjectInstance(RTIObjectInstance* rtiObjectInstance)
 738 {
 739     if (!_objectClass.valid())
 740         return;
 741
 742     _rtiObjectInstance = rtiObjectInstance;
 743     _rtiObjectInstance->setObjectInstance(this);
 744     _name = _rtiObjectInstance->getName();
 745
 746     unsigned numAttributes = getNumAttributes();
 747     _attributeVector.resize(numAttributes);
 748     for (unsigned i = 0; i < numAttributes; ++i) {
 749         HLAUpdateType updateType = _objectClass->getAttributeUpdateType(i);
 750         if (getAttributeOwned(i) && updateType != HLAUndefinedUpdate) {
 751             _attributeVector[i]._enabledUpdate = true;
 752             _attributeVector[i]._unconditionalUpdate = (updateType == HLAPeriodicUpdate);
 753             // In case of an owned attribute, now encode its value
 754             encodeAttributeValue(i);
 755         } else {
 756             _attributeVector[i]._enabledUpdate = false;
 757             _attributeVector[i]._unconditionalUpdate = false;
 758         }
 759     }
 760
 761     // This makes sense with any new object. Even if we registered one, there might be unpublished attributes.
 762     HLAIndexList indexList;
 763     for (unsigned i = 0; i < numAttributes; ++i) {
 764         HLAUpdateType updateType = _objectClass->getAttributeUpdateType(i);
 765         if (getAttributeOwned(i))
 766             continue;
 767         if (updateType == HLAUndefinedUpdate)
 768             continue;
 769         if (updateType == HLAPeriodicUpdate)
 770             continue;
 771         indexList.push_back(i);
 772     }
 773     _rtiObjectInstance->requestObjectAttributeValueUpdate(indexList);
 774 }
 775
 776 void
 777 HLAObjectInstance::_clearRTIObjectInstance()
 778 {
 779     if (!_rtiObjectInstance.valid())
 780         return;
 781
 782     for (unsigned i = 0; i < _attributeVector.size(); ++i) {
 783         _attributeVector[i]._enabledUpdate = false;
 784         _attributeVector[i]._unconditionalUpdate = false;
 785     }
 786
 787     _rtiObjectInstance->setObjectInstance(0);
 788     _rtiObjectInstance = 0;
 789 }
 790
 791 void
 792 HLAObjectInstance::_removeInstance(const RTIData& tag)
 793 {
 794     if (!_objectClass.valid())
 795         return;
 796     _objectClass->_removeInstance(*this, tag);
 797 }
 798
 799 void
 800 HLAObjectInstance::_reflectAttributeValues(const HLAIndexList& indexList, const RTIData& tag)
 801 {
 802     if (_reflectCallback.valid()) {
 803         _reflectCallback->reflectAttributeValues(*this, indexList, tag);
 804     } else {
 805         reflectAttributeValues(indexList, tag);
 806     }
 807 }
 808
 809 void
 810 HLAObjectInstance::_reflectAttributeValues(const HLAIndexList& indexList, const SGTimeStamp& timeStamp, const RTIData& tag)
 811 {
 812     if (_reflectCallback.valid()) {
 813         _reflectCallback->reflectAttributeValues(*this, indexList, timeStamp, tag);
 814     } else {
 815         reflectAttributeValues(indexList, timeStamp, tag);
 816     }
 817 }
 818
 819 } // namespace simgear