simgear/hla/HLAObjectInstance.cxx

   1 // Copyright (C) 2009 - 2010  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 #include "HLAObjectInstance.hxx"
  19
  20 #include <algorithm>
  21 #include "HLAArrayDataElement.hxx"
  22 #include "HLABasicDataElement.hxx"
  23 #include "HLADataElement.hxx"
  24 #include "HLAEnumeratedDataElement.hxx"
  25 #include "HLAFixedRecordDataElement.hxx"
  26 #include "HLAObjectClass.hxx"
  27 #include "HLAVariantDataElement.hxx"
  28 #include "RTIObjectClass.hxx"
  29 #include "RTIObjectInstance.hxx"
  30
  31 namespace simgear {
  32
  33 HLAObjectInstance::HLAObjectInstance(HLAObjectClass* objectClass) :
  34     _objectClass(objectClass)
  35 {
  36 }
  37
  38 HLAObjectInstance::HLAObjectInstance(HLAObjectClass* objectClass, RTIObjectInstance* rtiObjectInstance) :
  39     _objectClass(objectClass),
  40     _rtiObjectInstance(rtiObjectInstance)
  41 {
  42     _rtiObjectInstance->_hlaObjectInstance = this;
  43     _name = _rtiObjectInstance->getName();
  44 }
  45
  46 HLAObjectInstance::~HLAObjectInstance()
  47 {
  48 }
  49
  50 SGSharedPtr<HLAObjectClass>
  51 HLAObjectInstance::getObjectClass() const
  52 {
  53     return _objectClass.lock();
  54 }
  55
  56 unsigned
  57 HLAObjectInstance::getNumAttributes() const
  58 {
  59     if (!_rtiObjectInstance.valid()) {
  60         SG_LOG(SG_IO, SG_ALERT, "Trying to get number of attributes for inactive object!");
  61         return 0;
  62     }
  63     return _rtiObjectInstance->getNumAttributes();
  64 }
  65
  66 unsigned
  67 HLAObjectInstance::getAttributeIndex(const std::string& name) const
  68 {
  69     if (!_rtiObjectInstance.valid()) {
  70         SG_LOG(SG_IO, SG_ALERT, "Trying to get attribute index for inactive object!");
  71         return 0;
  72     }
  73     return _rtiObjectInstance->getAttributeIndex(name);
  74 }
  75
  76 std::string
  77 HLAObjectInstance::getAttributeName(unsigned index) const
  78 {
  79     if (!_rtiObjectInstance.valid()) {
  80         SG_LOG(SG_IO, SG_ALERT, "Trying to get attribute name for inactive object!");
  81         return std::string();
  82     }
  83     return _rtiObjectInstance->getAttributeName(index);
  84 }
  85
  86 const HLADataType*
  87 HLAObjectInstance::getAttributeDataType(unsigned index) const
  88 {
  89     if (!_rtiObjectInstance.valid()) {
  90         SG_LOG(SG_IO, SG_ALERT, "Trying to get attribute index for inactive object!");
  91         return 0;
  92     }
  93     return _rtiObjectInstance->getAttributeDataType(index);
  94 }
  95
  96 void
  97 HLAObjectInstance::setAttributeDataElement(unsigned index, SGSharedPtr<HLADataElement> dataElement)
  98 {
  99     if (!_rtiObjectInstance.valid()) {
 100         SG_LOG(SG_IO, SG_ALERT, "Trying to set data element for inactive object!");
 101         return;
 102     }
 103     _rtiObjectInstance->setDataElement(index, dataElement);
 104 }
 105
 106 HLADataElement*
 107 HLAObjectInstance::getAttributeDataElement(unsigned index)
 108 {
 109     if (!_rtiObjectInstance.valid()) {
 110         SG_LOG(SG_IO, SG_ALERT, "Trying to set data element for inactive object!");
 111         return 0;
 112     }
 113     return _rtiObjectInstance->getDataElement(index);
 114 }
 115
 116 const HLADataElement*
 117 HLAObjectInstance::getAttributeDataElement(unsigned index) const
 118 {
 119     if (!_rtiObjectInstance.valid()) {
 120         SG_LOG(SG_IO, SG_ALERT, "Trying to set data element for inactive object!");
 121         return 0;
 122     }
 123     return _rtiObjectInstance->getDataElement(index);
 124 }
 125
 126 class HLAObjectInstance::DataElementFactoryVisitor : public HLADataElementFactoryVisitor {
 127 public:
 128     DataElementFactoryVisitor(const HLAPathElementMap& pathElementMap) :
 129         _pathElementMap(pathElementMap)
 130     { }
 131     DataElementFactoryVisitor(const HLADataElement::Path& path, const HLAPathElementMap& pathElementMap) :
 132         _pathElementMap(pathElementMap),
 133         _path(path)
 134     { }
 135     virtual ~DataElementFactoryVisitor() {}
 136
 137     virtual void apply(const HLADataType& dataType)
 138     {
 139         _dataElement = createDataElement(_path, dataType);
 140         if (_dataElement.valid())
 141             return;
 142
 143         SG_LOG(SG_NETWORK, SG_ALERT, "HLA: Can not find a suitable data element for data type \""
 144                << dataType.getName() << "\"");
 145     }
 146
 147     virtual void apply(const HLAInt8DataType& dataType)
 148     {
 149         _dataElement = createDataElement(_path, dataType);
 150         if (_dataElement.valid())
 151             return;
 152
 153         HLADataElementFactoryVisitor::apply(dataType);
 154     }
 155     virtual void apply(const HLAUInt8DataType& dataType)
 156     {
 157         _dataElement = createDataElement(_path, dataType);
 158         if (_dataElement.valid())
 159             return;
 160
 161         HLADataElementFactoryVisitor::apply(dataType);
 162     }
 163     virtual void apply(const HLAInt16DataType& dataType)
 164     {
 165         _dataElement = createDataElement(_path, dataType);
 166         if (_dataElement.valid())
 167             return;
 168
 169         HLADataElementFactoryVisitor::apply(dataType);
 170     }
 171     virtual void apply(const HLAUInt16DataType& dataType)
 172     {
 173         _dataElement = createDataElement(_path, dataType);
 174         if (_dataElement.valid())
 175             return;
 176
 177         HLADataElementFactoryVisitor::apply(dataType);
 178     }
 179     virtual void apply(const HLAInt32DataType& dataType)
 180     {
 181         _dataElement = createDataElement(_path, dataType);
 182         if (_dataElement.valid())
 183             return;
 184
 185         HLADataElementFactoryVisitor::apply(dataType);
 186     }
 187     virtual void apply(const HLAUInt32DataType& dataType)
 188     {
 189         _dataElement = createDataElement(_path, dataType);
 190         if (_dataElement.valid())
 191             return;
 192
 193         HLADataElementFactoryVisitor::apply(dataType);
 194     }
 195     virtual void apply(const HLAInt64DataType& dataType)
 196     {
 197         _dataElement = createDataElement(_path, dataType);
 198         if (_dataElement.valid())
 199             return;
 200
 201         HLADataElementFactoryVisitor::apply(dataType);
 202     }
 203     virtual void apply(const HLAUInt64DataType& dataType)
 204     {
 205         _dataElement = createDataElement(_path, dataType);
 206         if (_dataElement.valid())
 207             return;
 208
 209         HLADataElementFactoryVisitor::apply(dataType);
 210     }
 211     virtual void apply(const HLAFloat32DataType& dataType)
 212     {
 213         _dataElement = createDataElement(_path, dataType);
 214         if (_dataElement.valid())
 215             return;
 216
 217         HLADataElementFactoryVisitor::apply(dataType);
 218     }
 219     virtual void apply(const HLAFloat64DataType& dataType)
 220     {
 221         _dataElement = createDataElement(_path, dataType);
 222         if (_dataElement.valid())
 223             return;
 224
 225         HLADataElementFactoryVisitor::apply(dataType);
 226     }
 227
 228     class ArrayDataElementFactory : public HLAArrayDataElement::DataElementFactory {
 229     public:
 230         ArrayDataElementFactory(const HLADataElement::Path& path, const HLAPathElementMap& pathElementMap) :
 231             _path(path)
 232         {
 233             for (HLAPathElementMap::const_iterator i = pathElementMap.lower_bound(path);
 234                  i != pathElementMap.end(); ++i) {
 235                 if (i->first.begin() != std::search(i->first.begin(), i->first.end(),
 236                                                     path.begin(), path.end()))
 237                     break;
 238                 _pathElementMap.insert(*i);
 239             }
 240         }
 241         virtual HLADataElement* createElement(const HLAArrayDataElement& element, unsigned index)
 242         {
 243             const HLADataType* dataType = element.getElementDataType();
 244             if (!dataType)
 245                 return 0;
 246             HLADataElement::Path path = _path;
 247             path.push_back(HLADataElement::PathElement(index));
 248             DataElementFactoryVisitor visitor(path, _pathElementMap);
 249             dataType->accept(visitor);
 250             return visitor._dataElement.release();
 251         }
 252     private:
 253         HLADataElement::Path _path;
 254         HLAPathElementMap _pathElementMap;
 255     };
 256
 257     virtual void apply(const HLAFixedArrayDataType& dataType)
 258     {
 259         _dataElement = createDataElement(_path, dataType);
 260         if (_dataElement.valid())
 261             return;
 262
 263         SGSharedPtr<HLAArrayDataElement> arrayDataElement;
 264         arrayDataElement = new HLAArrayDataElement(&dataType);
 265         arrayDataElement->setDataElementFactory(new ArrayDataElementFactory(_path, _pathElementMap));
 266         arrayDataElement->setNumElements(dataType.getNumElements());
 267
 268         _dataElement = arrayDataElement;
 269     }
 270
 271     virtual void apply(const HLAVariableArrayDataType& dataType)
 272     {
 273         _dataElement = createDataElement(_path, dataType);
 274         if (_dataElement.valid())
 275             return;
 276
 277         SGSharedPtr<HLAArrayDataElement> arrayDataElement;
 278         arrayDataElement = new HLAArrayDataElement(&dataType);
 279         arrayDataElement->setDataElementFactory(new ArrayDataElementFactory(_path, _pathElementMap));
 280
 281         _dataElement = arrayDataElement;
 282     }
 283
 284     virtual void apply(const HLAEnumeratedDataType& dataType)
 285     {
 286         _dataElement = createDataElement(_path, dataType);
 287         if (_dataElement.valid())
 288             return;
 289
 290         HLADataElementFactoryVisitor::apply(dataType);
 291     }
 292
 293     virtual void apply(const HLAFixedRecordDataType& dataType)
 294     {
 295         _dataElement = createDataElement(_path, dataType);
 296         if (_dataElement.valid())
 297             return;
 298
 299         SGSharedPtr<HLAFixedRecordDataElement> recordDataElement;
 300         recordDataElement = new HLAFixedRecordDataElement(&dataType);
 301
 302         unsigned numFields = dataType.getNumFields();
 303         for (unsigned i = 0; i < numFields; ++i) {
 304
 305             _path.push_back(HLADataElement::PathElement(dataType.getFieldName(i)));
 306
 307             dataType.getFieldDataType(i)->accept(*this);
 308             recordDataElement->setField(i, _dataElement.release());
 309
 310             _path.pop_back();
 311         }
 312         _dataElement = recordDataElement;
 313     }
 314
 315     class VariantDataElementFactory : public HLAVariantDataElement::DataElementFactory {
 316     public:
 317         VariantDataElementFactory(const HLADataElement::Path& path, const HLAPathElementMap& pathElementMap) :
 318             _path(path)
 319         {
 320             for (HLAPathElementMap::const_iterator i = pathElementMap.lower_bound(path);
 321                  i != pathElementMap.end(); ++i) {
 322                 if (i->first.begin() != std::search(i->first.begin(), i->first.end(),
 323                                                     path.begin(), path.end()))
 324                     break;
 325                 _pathElementMap.insert(*i);
 326             }
 327         }
 328         virtual HLADataElement* createElement(const HLAVariantDataElement& element, unsigned index)
 329         {
 330             const HLAVariantDataType* dataType = element.getDataType();
 331             if (!dataType)
 332                 return 0;
 333             const HLADataType* alternativeDataType = element.getAlternativeDataType();
 334             if (!alternativeDataType)
 335                 return 0;
 336             HLADataElement::Path path = _path;
 337             path.push_back(HLADataElement::PathElement(dataType->getAlternativeName(index)));
 338             DataElementFactoryVisitor visitor(path, _pathElementMap);
 339             alternativeDataType->accept(visitor);
 340             return visitor._dataElement.release();
 341         }
 342     private:
 343         HLADataElement::Path _path;
 344         HLAPathElementMap _pathElementMap;
 345     };
 346
 347     virtual void apply(const HLAVariantDataType& dataType)
 348     {
 349         _dataElement = createDataElement(_path, dataType);
 350         if (_dataElement.valid())
 351             return;
 352
 353         SGSharedPtr<HLAVariantDataElement> variantDataElement;
 354         variantDataElement = new HLAVariantDataElement(&dataType);
 355         variantDataElement->setDataElementFactory(new VariantDataElementFactory(_path, _pathElementMap));
 356
 357         _dataElement = variantDataElement;
 358     }
 359
 360 private:
 361     SGSharedPtr<HLADataElement> createDataElement(const HLADataElement::Path& path, const HLADataType& dataType)
 362     {
 363         HLAPathElementMap::const_iterator i = _pathElementMap.find(path);
 364         if (i == _pathElementMap.end()) {
 365             SG_LOG(SG_IO, SG_WARN, "No dataElement provided for \""
 366                    << HLADataElement::toString(path) << "\".");
 367
 368             return 0;
 369         }
 370         SGSharedPtr<HLADataElement> dataElement = i->second.getDataElement(path);
 371         if (!dataElement->setDataType(&dataType)) {
 372             SG_LOG(SG_IO, SG_ALERT, "Cannot set data type for data element at \""
 373                    << HLADataElement::toString(path) <<  "\"!");
 374             return 0;
 375         }
 376         SG_LOG(SG_IO, SG_DEBUG, "Using provided dataElement for \""
 377                << HLADataElement::toString(path) << "\".");
 378         return dataElement;
 379     }
 380
 381     const HLAPathElementMap& _pathElementMap;
 382     HLADataElement::Path _path;
 383 };
 384
 385 void
 386 HLAObjectInstance::setAttribute(unsigned index, const HLAPathElementMap& pathElementMap)
 387 {
 388     const HLADataType* dataType = getAttributeDataType(index);
 389     if (!dataType) {
 390         SG_LOG(SG_IO, SG_ALERT, "Cannot get attribute data type for setting attribute at index "
 391                << index << "!");
 392         return;
 393     }
 394
 395     SG_LOG(SG_IO, SG_DEBUG, "Setting DataElement for attribute \""
 396            << getAttributeName(index) << "\".");
 397
 398     DataElementFactoryVisitor visitor(pathElementMap);
 399     dataType->accept(visitor);
 400     setAttributeDataElement(index, visitor.getDataElement());
 401 }
 402
 403 void
 404 HLAObjectInstance::setAttributes(const HLAAttributePathElementMap& attributePathElementMap)
 405 {
 406     for (HLAAttributePathElementMap::const_iterator i = attributePathElementMap.begin();
 407          i != attributePathElementMap.end(); ++i) {
 408         setAttribute(i->first, i->second);
 409     }
 410 }
 411
 412 void
 413 HLAObjectInstance::registerInstance()
 414 {
 415     if (_rtiObjectInstance.valid()) {
 416         SG_LOG(SG_IO, SG_ALERT, "Trying to register object " << getName() << " already known to the RTI!");
 417         return;
 418     }
 419     SGSharedPtr<HLAObjectClass> objectClass = _objectClass.lock();
 420     if (!objectClass.valid()) {
 421         SG_LOG(SG_IO, SG_ALERT, "Could not register object with unknown object class!");
 422         return;
 423     }
 424     // This error must have been flagged before
 425     if (!objectClass->_rtiObjectClass.valid())
 426         return;
 427     _rtiObjectInstance = objectClass->_rtiObjectClass->registerObjectInstance(this);
 428     if (!_rtiObjectInstance.valid()) {
 429         SG_LOG(SG_IO, SG_ALERT, "Could not register object at the RTI!");
 430         return;
 431     }
 432     _name = _rtiObjectInstance->getName();
 433     objectClass->registerInstance(*this);
 434 }
 435
 436 void
 437 HLAObjectInstance::deleteInstance(const RTIData& tag)
 438 {
 439     if (!_rtiObjectInstance.valid()) {
 440         SG_LOG(SG_IO, SG_ALERT, "Trying to delete inactive object!");
 441         return;
 442     }
 443     SGSharedPtr<HLAObjectClass> objectClass = _objectClass.lock();
 444     if (!objectClass.valid())
 445         return;
 446     objectClass->deleteInstance(*this);
 447     _rtiObjectInstance->deleteObjectInstance(tag);
 448 }
 449
 450 void
 451 HLAObjectInstance::updateAttributeValues(const RTIData& tag)
 452 {
 453     if (!_rtiObjectInstance.valid()) {
 454         SG_LOG(SG_IO, SG_INFO, "Not updating inactive object!");
 455         return;
 456     }
 457     if (_attributeCallback.valid())
 458         _attributeCallback->updateAttributeValues(*this, tag);
 459     _rtiObjectInstance->updateAttributeValues(tag);
 460 }
 461
 462 void
 463 HLAObjectInstance::updateAttributeValues(const SGTimeStamp& timeStamp, const RTIData& tag)
 464 {
 465     if (!_rtiObjectInstance.valid()) {
 466         SG_LOG(SG_IO, SG_INFO, "Not updating inactive object!");
 467         return;
 468     }
 469     if (_attributeCallback.valid())
 470         _attributeCallback->updateAttributeValues(*this, tag);
 471     _rtiObjectInstance->updateAttributeValues(timeStamp, tag);
 472 }
 473
 474 void
 475 HLAObjectInstance::removeInstance(const RTIData& tag)
 476 {
 477     SGSharedPtr<HLAObjectClass> objectClass = _objectClass.lock();
 478     if (!objectClass.valid())
 479         return;
 480     objectClass->removeInstanceCallback(*this, tag);
 481 }
 482
 483 void
 484 HLAObjectInstance::reflectAttributeValues(const RTIIndexDataPairList& dataPairList, const RTIData& tag)
 485 {
 486     if (!_attributeCallback.valid())
 487         return;
 488     _attributeCallback->reflectAttributeValues(*this, dataPairList, tag);
 489 }
 490
 491 void
 492 HLAObjectInstance::reflectAttributeValues(const RTIIndexDataPairList& dataPairList,
 493                                           const SGTimeStamp& timeStamp, const RTIData& tag)
 494 {
 495     if (!_attributeCallback.valid())
 496         return;
 497     _attributeCallback->reflectAttributeValues(*this, dataPairList, timeStamp, tag);
 498 }
 499
 500 } // namespace simgear