simgear/hla/HLAObjectClass.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 "HLAObjectClass.hxx"
  25
  26 #include "simgear/debug/logstream.hxx"
  27 #include "RTIFederate.hxx"
  28 #include "RTIObjectClass.hxx"
  29 #include "RTIObjectInstance.hxx"
  30 #include "HLADataType.hxx"
  31 #include "HLADataTypeVisitor.hxx"
  32 #include "HLAFederate.hxx"
  33 #include "HLAObjectInstance.hxx"
  34
  35 namespace simgear {
  36
  37 HLAObjectClass::InstanceCallback::~InstanceCallback()
  38 {
  39 }
  40
  41 void
  42 HLAObjectClass::InstanceCallback::discoverInstance(const HLAObjectClass&, HLAObjectInstance& objectInstance, const RTIData& tag)
  43 {
  44 }
  45
  46 void
  47 HLAObjectClass::InstanceCallback::removeInstance(const HLAObjectClass&, HLAObjectInstance& objectInstance, const RTIData& tag)
  48 {
  49 }
  50
  51 void
  52 HLAObjectClass::InstanceCallback::registerInstance(const HLAObjectClass&, HLAObjectInstance& objectInstance)
  53 {
  54 }
  55
  56 void
  57 HLAObjectClass::InstanceCallback::deleteInstance(const HLAObjectClass&, HLAObjectInstance& objectInstance)
  58 {
  59 }
  60
  61 HLAObjectClass::RegistrationCallback::~RegistrationCallback()
  62 {
  63 }
  64
  65 HLAObjectClass::HLAObjectClass(const std::string& name, HLAFederate* federate) :
  66     _federate(federate),
  67     _name(name)
  68 {
  69     if (!federate) {
  70         SG_LOG(SG_NETWORK, SG_ALERT, "HLAObjectClass::HLAObjectClass(): "
  71                "No parent federate given for object class \"" << getName() << "\"!");
  72         return;
  73     }
  74     federate->_insertObjectClass(this);
  75 }
  76
  77 HLAObjectClass::~HLAObjectClass()
  78 {
  79     // HLAObjectClass objects only get deleted when the parent federate
  80     // dies. So we do not need to deregister there.
  81
  82     _clearRTIObjectClass();
  83 }
  84
  85 const std::string&
  86 HLAObjectClass::getName() const
  87 {
  88     return _name;
  89 }
  90
  91 const SGWeakPtr<HLAFederate>&
  92 HLAObjectClass::getFederate() const
  93 {
  94     return _federate;
  95 }
  96
  97 unsigned
  98 HLAObjectClass::getNumAttributes() const
  99 {
 100     return _attributeVector.size();
 101 }
 102
 103 unsigned
 104 HLAObjectClass::addAttribute(const std::string& name)
 105 {
 106     unsigned index = _attributeVector.size();
 107     _nameIndexMap[name] = index;
 108     _attributeVector.push_back(Attribute(name));
 109     _resolveAttributeIndex(name, index);
 110     return index;
 111 }
 112
 113 unsigned
 114 HLAObjectClass::getAttributeIndex(const std::string& name) const
 115 {
 116     NameIndexMap::const_iterator i = _nameIndexMap.find(name);
 117     if (i == _nameIndexMap.end())
 118         return ~0u;
 119     return i->second;
 120 }
 121
 122 std::string
 123 HLAObjectClass::getAttributeName(unsigned index) const
 124 {
 125     if (_attributeVector.size() <= index)
 126         return std::string();
 127     return _attributeVector[index]._name;
 128 }
 129
 130 const HLADataType*
 131 HLAObjectClass::getAttributeDataType(unsigned index) const
 132 {
 133     if (_attributeVector.size() <= index)
 134         return 0;
 135     return _attributeVector[index]._dataType.get();
 136 }
 137
 138 void
 139 HLAObjectClass::setAttributeDataType(unsigned index, const HLADataType* dataType)
 140 {
 141     if (_attributeVector.size() <= index)
 142         return;
 143     _attributeVector[index]._dataType = dataType;
 144 }
 145
 146 HLAUpdateType
 147 HLAObjectClass::getAttributeUpdateType(unsigned index) const
 148 {
 149     if (_attributeVector.size() <= index)
 150         return HLAUndefinedUpdate;
 151     return _attributeVector[index]._updateType;
 152 }
 153
 154 void
 155 HLAObjectClass::setAttributeUpdateType(unsigned index, HLAUpdateType updateType)
 156 {
 157     if (_attributeVector.size() <= index)
 158         return;
 159     _attributeVector[index]._updateType = updateType;
 160 }
 161
 162 HLASubscriptionType
 163 HLAObjectClass::getAttributeSubscriptionType(unsigned index) const
 164 {
 165     if (_attributeVector.size() <= index)
 166         return HLAUnsubscribed;
 167     return _attributeVector[index]._subscriptionType;
 168 }
 169
 170 void
 171 HLAObjectClass::setAttributeSubscriptionType(unsigned index, HLASubscriptionType subscriptionType)
 172 {
 173     if (_attributeVector.size() <= index)
 174         return;
 175     _attributeVector[index]._subscriptionType = subscriptionType;
 176 }
 177
 178 HLAPublicationType
 179 HLAObjectClass::getAttributePublicationType(unsigned index) const
 180 {
 181     if (_attributeVector.size() <= index)
 182         return HLAUnpublished;
 183     return _attributeVector[index]._publicationType;
 184 }
 185
 186 void
 187 HLAObjectClass::setAttributePublicationType(unsigned index, HLAPublicationType publicationType)
 188 {
 189     if (_attributeVector.size() <= index)
 190         return;
 191     _attributeVector[index]._publicationType = publicationType;
 192 }
 193
 194 HLADataElement::IndexPathPair
 195 HLAObjectClass::getIndexPathPair(const HLADataElement::StringPathPair& stringPathPair) const
 196 {
 197     unsigned index = getAttributeIndex(stringPathPair.first);
 198     if (getNumAttributes() <= index) {
 199         SG_LOG(SG_NETWORK, SG_ALERT, "HLAObjectClass::getIndexPathPair(\""
 200                << HLADataElement::toString(stringPathPair)
 201                << "\"): Could not resolve attribute \"" << stringPathPair.first
 202                << "\" for object class \"" << getName() << "\"!");
 203     }
 204     return HLADataElement::IndexPathPair(index, stringPathPair.second);
 205 }
 206
 207 HLADataElement::IndexPathPair
 208 HLAObjectClass::getIndexPathPair(const std::string& path) const
 209 {
 210     return getIndexPathPair(HLADataElement::toStringPathPair(path));
 211 }
 212
 213 bool
 214 HLAObjectClass::getAttributeIndex(HLADataElementIndex& dataElementIndex, const std::string& path) const
 215 {
 216     if (path.empty()) {
 217         SG_LOG(SG_NETWORK, SG_ALERT, "HLAObjectClass: failed to parse empty element path!");
 218         return false;
 219     }
 220     size_t len = path.find_first_of("[.");
 221     unsigned index = 0;
 222     while (index < getNumAttributes()) {
 223         if (path.compare(0, len, getAttributeName(index)) == 0)
 224             break;
 225         ++index;
 226     }
 227     if (getNumAttributes() <= index) {
 228         SG_LOG(SG_NETWORK, SG_ALERT, "HLAObjectClass: faild to parse data element index \"" << path << "\":\n"
 229                << "Attribute \"" << path.substr(0, len) << "\" not found in object class \""
 230                << getName() << "\"!");
 231         return false;
 232     }
 233     if (!getAttributeDataType(index)) {
 234         SG_LOG(SG_NETWORK, SG_ALERT, "HLAObjectClass: faild to parse data element index \"" << path << "\":\n"
 235                << "Undefined attribute data type in variant record data type \""
 236                << getAttributeName(index) << "\"!");
 237         return false;
 238     }
 239     dataElementIndex.push_back(index);
 240     return getAttributeDataType(index)->getDataElementIndex(dataElementIndex, path, len);
 241 }
 242
 243 bool
 244 HLAObjectClass::subscribe()
 245 {
 246     if (!_rtiObjectClass.valid()) {
 247         SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::subscribe(): "
 248                "No RTIObject class for object class \"" << getName() << "\"!");
 249         return false;
 250     }
 251
 252     HLAIndexList indexList;
 253     for (unsigned i = 1; i < getNumAttributes(); ++i) {
 254         if (_attributeVector[i]._subscriptionType != HLASubscribedActive)
 255             continue;
 256         indexList.push_back(i);
 257     }
 258     if (!indexList.empty()) {
 259         if (!_rtiObjectClass->subscribe(indexList, true))
 260             return false;
 261     }
 262
 263     indexList.clear();
 264     for (unsigned i = 1; i < getNumAttributes(); ++i) {
 265         if (_attributeVector[i]._subscriptionType != HLASubscribedPassive)
 266             continue;
 267         indexList.push_back(i);
 268     }
 269     if (!indexList.empty()) {
 270         if (!_rtiObjectClass->subscribe(indexList, false))
 271             return false;
 272     }
 273     return true;
 274 }
 275
 276 bool
 277 HLAObjectClass::unsubscribe()
 278 {
 279     if (!_rtiObjectClass.valid()) {
 280         SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::unsubscribe(): "
 281                "No RTIObject class for object class \"" << getName() << "\"!");
 282         return false;
 283     }
 284     return _rtiObjectClass->unsubscribe();
 285 }
 286
 287 bool
 288 HLAObjectClass::publish()
 289 {
 290     if (!_rtiObjectClass.valid()) {
 291         SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::publish(): "
 292                "No RTIObject class for object class \"" << getName() << "\"!");
 293         return false;
 294     }
 295
 296     HLAIndexList indexList;
 297     for (unsigned i = 1; i < getNumAttributes(); ++i) {
 298         if (_attributeVector[i]._publicationType == HLAUnpublished)
 299             continue;
 300         indexList.push_back(i);
 301     }
 302     if (indexList.empty())
 303         return true;
 304     if (!_rtiObjectClass->publish(indexList))
 305         return false;
 306     return true;
 307 }
 308
 309 bool
 310 HLAObjectClass::unpublish()
 311 {
 312     if (!_rtiObjectClass.valid()) {
 313         SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::unpublish(): "
 314                "No RTIObject class for object class \"" << getName() << "\"!");
 315         return false;
 316     }
 317     return _rtiObjectClass->unpublish();
 318 }
 319
 320 void
 321 HLAObjectClass::discoverInstance(HLAObjectInstance& objectInstance, const RTIData& tag)
 322 {
 323     if (_instanceCallback.valid())
 324         _instanceCallback->discoverInstance(*this, objectInstance, tag);
 325 }
 326
 327 void
 328 HLAObjectClass::removeInstance(HLAObjectInstance& objectInstance, const RTIData& tag)
 329 {
 330     if (_instanceCallback.valid())
 331         _instanceCallback->removeInstance(*this, objectInstance, tag);
 332 }
 333
 334 void
 335 HLAObjectClass::registerInstance(HLAObjectInstance& objectInstance)
 336 {
 337     if (_instanceCallback.valid())
 338         _instanceCallback->registerInstance(*this, objectInstance);
 339 }
 340
 341 void
 342 HLAObjectClass::deleteInstance(HLAObjectInstance& objectInstance)
 343 {
 344     if (_instanceCallback.valid())
 345         _instanceCallback->deleteInstance(*this, objectInstance);
 346 }
 347
 348 void
 349 HLAObjectClass::startRegistration() const
 350 {
 351 }
 352
 353 void
 354 HLAObjectClass::stopRegistration() const
 355 {
 356 }
 357
 358 HLAObjectInstance*
 359 HLAObjectClass::createObjectInstance(const std::string& name)
 360 {
 361     SGSharedPtr<HLAFederate> federate = _federate.lock();
 362     if (!federate.valid())
 363         return 0;
 364     return federate->createObjectInstance(this, name);
 365 }
 366
 367 void
 368 HLAObjectClass::createAttributeDataElements(HLAObjectInstance& objectInstance)
 369 {
 370     unsigned numAttributes = getNumAttributes();
 371     for (unsigned i = 0; i < numAttributes; ++i)
 372         objectInstance.createAndSetAttributeDataElement(i);
 373 }
 374
 375 HLADataElement*
 376 HLAObjectClass::createAttributeDataElement(HLAObjectInstance& objectInstance, unsigned index)
 377 {
 378     // FIXME here we want to have a vector of factories and if this fails do the following
 379     const HLADataType* dataType = getAttributeDataType(index);
 380     if (!dataType)
 381         return 0;
 382     HLADataElementFactoryVisitor dataElementFactoryVisitor;
 383     dataType->accept(dataElementFactoryVisitor);
 384     return dataElementFactoryVisitor.getDataElement();
 385 }
 386
 387 void
 388 HLAObjectClass::_setRTIObjectClass(RTIObjectClass* objectClass)
 389 {
 390     if (_rtiObjectClass) {
 391         SG_LOG(SG_NETWORK, SG_ALERT, "HLAObjectClass: Setting RTIObjectClass twice for object class \"" << getName() << "\"!");
 392         return;
 393     }
 394     _rtiObjectClass = objectClass;
 395     if (_rtiObjectClass->_objectClass != this) {
 396         SG_LOG(SG_NETWORK, SG_ALERT, "HLAObjectClass: backward reference does not match!");
 397         return;
 398     }
 399     for (unsigned i = 0; i < _attributeVector.size(); ++i)
 400         _resolveAttributeIndex(_attributeVector[i]._name, i);
 401 }
 402
 403 void
 404 HLAObjectClass::_resolveAttributeIndex(const std::string& name, unsigned index)
 405 {
 406     if (!_rtiObjectClass)
 407         return;
 408     if (!_rtiObjectClass->resolveAttributeIndex(name, index))
 409         SG_LOG(SG_NETWORK, SG_ALERT, "HLAObjectClass: Could not resolve attribute \""
 410                << name << "\" for object class \"" << getName() << "\"!");
 411 }
 412
 413 void
 414 HLAObjectClass::_clearRTIObjectClass()
 415 {
 416     if (!_rtiObjectClass.valid())
 417         return;
 418     _rtiObjectClass->_objectClass = 0;
 419     _rtiObjectClass = 0;
 420 }
 421
 422 void
 423 HLAObjectClass::_discoverInstance(RTIObjectInstance* rtiObjectInstance, const RTIData& tag)
 424 {
 425     SGSharedPtr<HLAFederate> federate = _federate.lock();
 426     if (!federate.valid()) {
 427         SG_LOG(SG_NETWORK, SG_ALERT, "RTI: could not find parent federate while discovering object instance");
 428         return;
 429     }
 430
 431     SGSharedPtr<HLAObjectInstance> objectInstance = createObjectInstance(rtiObjectInstance->getName());
 432     if (!objectInstance.valid()) {
 433         SG_LOG(SG_NETWORK, SG_INFO, "RTI: could not create new object instance for discovered \""
 434                << rtiObjectInstance->getName() << "\" object");
 435         return;
 436     }
 437     SG_LOG(SG_NETWORK, SG_INFO, "RTI: create new object instance for discovered \""
 438            << rtiObjectInstance->getName() << "\" object");
 439     objectInstance->_setRTIObjectInstance(rtiObjectInstance);
 440     if (!federate->_insertObjectInstance(objectInstance)) {
 441         SG_LOG(SG_NETWORK, SG_ALERT, "RTI: could not insert new object instance for discovered \""
 442                << rtiObjectInstance->getName() << "\" object");
 443         return;
 444     }
 445     objectInstance->discoverInstance(tag);
 446     objectInstance->createAttributeDataElements();
 447 }
 448
 449 void
 450 HLAObjectClass::_removeInstance(HLAObjectInstance& objectInstance, const RTIData& tag)
 451 {
 452     SGSharedPtr<HLAFederate> federate = _federate.lock();
 453     if (!federate.valid()) {
 454         SG_LOG(SG_NETWORK, SG_ALERT, "RTI: could not find parent federate while removing object instance");
 455         return;
 456     }
 457     SG_LOG(SG_NETWORK, SG_INFO, "RTI: remove object instance \"" << objectInstance.getName() << "\"");
 458     objectInstance.removeInstance(tag);
 459     federate->_eraseObjectInstance(objectInstance.getName());
 460 }
 461
 462 void
 463 HLAObjectClass::_registerInstance(HLAObjectInstance* objectInstance)
 464 {
 465     SGSharedPtr<HLAFederate> federate = _federate.lock();
 466     if (!federate.valid()) {
 467         SG_LOG(SG_NETWORK, SG_ALERT, "RTI: could not find parent federate while registering object instance");
 468         return;
 469     }
 470     if (!objectInstance)
 471         return;
 472     // We can only register object instances with a valid name at the rti.
 473     // So, we cannot do that at HLAObjectInstance creation time.
 474     if (!federate->_insertObjectInstance(objectInstance)) {
 475         SG_LOG(SG_NETWORK, SG_ALERT, "RTI: could not insert new object instance \""
 476                << objectInstance->getName() << "\" object");
 477         return;
 478     }
 479     registerInstance(*objectInstance);
 480     objectInstance->createAttributeDataElements();
 481 }
 482
 483 void
 484 HLAObjectClass::_deleteInstance(HLAObjectInstance& objectInstance)
 485 {
 486     SGSharedPtr<HLAFederate> federate = _federate.lock();
 487     if (!federate.valid()) {
 488         SG_LOG(SG_NETWORK, SG_ALERT, "RTI: could not find parent federate while deleting object instance");
 489         return;
 490     }
 491     deleteInstance(objectInstance);
 492     federate->_eraseObjectInstance(objectInstance.getName());
 493 }
 494
 495 void
 496 HLAObjectClass::_startRegistration()
 497 {
 498     if (_registrationCallback.valid())
 499         _registrationCallback->startRegistration(*this);
 500     else
 501         startRegistration();
 502 }
 503
 504 void
 505 HLAObjectClass::_stopRegistration()
 506 {
 507     if (_registrationCallback.valid())
 508         _registrationCallback->stopRegistration(*this);
 509     else
 510         stopRegistration();
 511 }
 512
 513 } // namespace simgear