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::subscribe()
 215 {
 216     if (!_rtiObjectClass.valid()) {
 217         SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::subscribe(): "
 218                "No RTIObject class for object class \"" << getName() << "\"!");
 219         return false;
 220     }
 221
 222     HLAIndexList indexList;
 223     for (unsigned i = 1; i < getNumAttributes(); ++i) {
 224         if (_attributeVector[i]._subscriptionType != HLASubscribedActive)
 225             continue;
 226         indexList.push_back(i);
 227     }
 228     if (!indexList.empty()) {
 229         if (!_rtiObjectClass->subscribe(indexList, true))
 230             return false;
 231     }
 232
 233     indexList.clear();
 234     for (unsigned i = 1; i < getNumAttributes(); ++i) {
 235         if (_attributeVector[i]._subscriptionType != HLASubscribedPassive)
 236             continue;
 237         indexList.push_back(i);
 238     }
 239     if (!indexList.empty()) {
 240         if (!_rtiObjectClass->subscribe(indexList, false))
 241             return false;
 242     }
 243     return true;
 244 }
 245
 246 bool
 247 HLAObjectClass::unsubscribe()
 248 {
 249     if (!_rtiObjectClass.valid()) {
 250         SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::unsubscribe(): "
 251                "No RTIObject class for object class \"" << getName() << "\"!");
 252         return false;
 253     }
 254     return _rtiObjectClass->unsubscribe();
 255 }
 256
 257 bool
 258 HLAObjectClass::publish()
 259 {
 260     if (!_rtiObjectClass.valid()) {
 261         SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::publish(): "
 262                "No RTIObject class for object class \"" << getName() << "\"!");
 263         return false;
 264     }
 265
 266     HLAIndexList indexList;
 267     for (unsigned i = 1; i < getNumAttributes(); ++i) {
 268         if (_attributeVector[i]._publicationType == HLAUnpublished)
 269             continue;
 270         indexList.push_back(i);
 271     }
 272     if (indexList.empty())
 273         return true;
 274     if (!_rtiObjectClass->publish(indexList))
 275         return false;
 276     return true;
 277 }
 278
 279 bool
 280 HLAObjectClass::unpublish()
 281 {
 282     if (!_rtiObjectClass.valid()) {
 283         SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::unpublish(): "
 284                "No RTIObject class for object class \"" << getName() << "\"!");
 285         return false;
 286     }
 287     return _rtiObjectClass->unpublish();
 288 }
 289
 290 void
 291 HLAObjectClass::discoverInstance(HLAObjectInstance& objectInstance, const RTIData& tag)
 292 {
 293     if (_instanceCallback.valid())
 294         _instanceCallback->discoverInstance(*this, objectInstance, tag);
 295 }
 296
 297 void
 298 HLAObjectClass::removeInstance(HLAObjectInstance& objectInstance, const RTIData& tag)
 299 {
 300     if (_instanceCallback.valid())
 301         _instanceCallback->removeInstance(*this, objectInstance, tag);
 302 }
 303
 304 void
 305 HLAObjectClass::registerInstance(HLAObjectInstance& objectInstance)
 306 {
 307     if (_instanceCallback.valid())
 308         _instanceCallback->registerInstance(*this, objectInstance);
 309 }
 310
 311 void
 312 HLAObjectClass::deleteInstance(HLAObjectInstance& objectInstance)
 313 {
 314     if (_instanceCallback.valid())
 315         _instanceCallback->deleteInstance(*this, objectInstance);
 316 }
 317
 318 void
 319 HLAObjectClass::startRegistration() const
 320 {
 321 }
 322
 323 void
 324 HLAObjectClass::stopRegistration() const
 325 {
 326 }
 327
 328 HLAObjectInstance*
 329 HLAObjectClass::createObjectInstance(const std::string& name)
 330 {
 331     SGSharedPtr<HLAFederate> federate = _federate.lock();
 332     if (!federate.valid())
 333         return 0;
 334     return federate->createObjectInstance(this, name);
 335 }
 336
 337 void
 338 HLAObjectClass::createAttributeDataElements(HLAObjectInstance& objectInstance)
 339 {
 340     unsigned numAttributes = getNumAttributes();
 341     for (unsigned i = 0; i < numAttributes; ++i)
 342         objectInstance.createAndSetAttributeDataElement(i);
 343 }
 344
 345 HLADataElement*
 346 HLAObjectClass::createAttributeDataElement(HLAObjectInstance& objectInstance, unsigned index)
 347 {
 348     // FIXME here we want to have a vector of factories and if this fails do the following
 349     const HLADataType* dataType = getAttributeDataType(index);
 350     if (!dataType)
 351         return 0;
 352     HLADataElementFactoryVisitor dataElementFactoryVisitor;
 353     dataType->accept(dataElementFactoryVisitor);
 354     return dataElementFactoryVisitor.getDataElement();
 355 }
 356
 357 void
 358 HLAObjectClass::_setRTIObjectClass(RTIObjectClass* objectClass)
 359 {
 360     if (_rtiObjectClass) {
 361         SG_LOG(SG_NETWORK, SG_ALERT, "HLAObjectClass: Setting RTIObjectClass twice for object class \"" << getName() << "\"!");
 362         return;
 363     }
 364     _rtiObjectClass = objectClass;
 365     if (_rtiObjectClass->_objectClass != this) {
 366         SG_LOG(SG_NETWORK, SG_ALERT, "HLAObjectClass: backward reference does not match!");
 367         return;
 368     }
 369     for (unsigned i = 0; i < _attributeVector.size(); ++i)
 370         _resolveAttributeIndex(_attributeVector[i]._name, i);
 371 }
 372
 373 void
 374 HLAObjectClass::_resolveAttributeIndex(const std::string& name, unsigned index)
 375 {
 376     if (!_rtiObjectClass)
 377         return;
 378     if (!_rtiObjectClass->resolveAttributeIndex(name, index))
 379         SG_LOG(SG_NETWORK, SG_ALERT, "HLAObjectClass: Could not resolve attribute \""
 380                << name << "\" for object class \"" << getName() << "\"!");
 381 }
 382
 383 void
 384 HLAObjectClass::_clearRTIObjectClass()
 385 {
 386     if (!_rtiObjectClass.valid())
 387         return;
 388     _rtiObjectClass->_objectClass = 0;
 389     _rtiObjectClass = 0;
 390 }
 391
 392 void
 393 HLAObjectClass::_discoverInstance(RTIObjectInstance* rtiObjectInstance, const RTIData& tag)
 394 {
 395     SGSharedPtr<HLAFederate> federate = _federate.lock();
 396     if (!federate.valid()) {
 397         SG_LOG(SG_NETWORK, SG_ALERT, "RTI: could not find parent federate while discovering object instance");
 398         return;
 399     }
 400
 401     SGSharedPtr<HLAObjectInstance> objectInstance = createObjectInstance(rtiObjectInstance->getName());
 402     if (!objectInstance.valid()) {
 403         SG_LOG(SG_NETWORK, SG_INFO, "RTI: could not create new object instance for discovered \""
 404                << rtiObjectInstance->getName() << "\" object");
 405         return;
 406     }
 407     SG_LOG(SG_NETWORK, SG_INFO, "RTI: create new object instance for discovered \""
 408            << rtiObjectInstance->getName() << "\" object");
 409     objectInstance->_setRTIObjectInstance(rtiObjectInstance);
 410     if (!federate->_insertObjectInstance(objectInstance)) {
 411         SG_LOG(SG_NETWORK, SG_ALERT, "RTI: could not insert new object instance for discovered \""
 412                << rtiObjectInstance->getName() << "\" object");
 413         return;
 414     }
 415     objectInstance->discoverInstance(tag);
 416     objectInstance->createAttributeDataElements();
 417 }
 418
 419 void
 420 HLAObjectClass::_removeInstance(HLAObjectInstance& objectInstance, const RTIData& tag)
 421 {
 422     SGSharedPtr<HLAFederate> federate = _federate.lock();
 423     if (!federate.valid()) {
 424         SG_LOG(SG_NETWORK, SG_ALERT, "RTI: could not find parent federate while removing object instance");
 425         return;
 426     }
 427     SG_LOG(SG_NETWORK, SG_INFO, "RTI: remove object instance \"" << objectInstance.getName() << "\"");
 428     objectInstance.removeInstance(tag);
 429     federate->_eraseObjectInstance(objectInstance.getName());
 430 }
 431
 432 void
 433 HLAObjectClass::_registerInstance(HLAObjectInstance* objectInstance)
 434 {
 435     SGSharedPtr<HLAFederate> federate = _federate.lock();
 436     if (!federate.valid()) {
 437         SG_LOG(SG_NETWORK, SG_ALERT, "RTI: could not find parent federate while registering object instance");
 438         return;
 439     }
 440     if (!objectInstance)
 441         return;
 442     // We can only register object instances with a valid name at the rti.
 443     // So, we cannot do that at HLAObjectInstance creation time.
 444     if (!federate->_insertObjectInstance(objectInstance)) {
 445         SG_LOG(SG_NETWORK, SG_ALERT, "RTI: could not insert new object instance \""
 446                << objectInstance->getName() << "\" object");
 447         return;
 448     }
 449     registerInstance(*objectInstance);
 450     objectInstance->createAttributeDataElements();
 451 }
 452
 453 void
 454 HLAObjectClass::_deleteInstance(HLAObjectInstance& objectInstance)
 455 {
 456     SGSharedPtr<HLAFederate> federate = _federate.lock();
 457     if (!federate.valid()) {
 458         SG_LOG(SG_NETWORK, SG_ALERT, "RTI: could not find parent federate while deleting object instance");
 459         return;
 460     }
 461     deleteInstance(objectInstance);
 462     federate->_eraseObjectInstance(objectInstance.getName());
 463 }
 464
 465 void
 466 HLAObjectClass::_startRegistration()
 467 {
 468     if (_registrationCallback.valid())
 469         _registrationCallback->startRegistration(*this);
 470     else
 471         startRegistration();
 472 }
 473
 474 void
 475 HLAObjectClass::_stopRegistration()
 476 {
 477     if (_registrationCallback.valid())
 478         _registrationCallback->stopRegistration(*this);
 479     else
 480         stopRegistration();
 481 }
 482
 483 } // namespace simgear