simgear/hla/RTI13Federate.cxx

   1 // Copyright (C) 2009 - 2011  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 "RTI13Federate.hxx"
  19
  20 #include "RTI13Ambassador.hxx"
  21
  22 namespace simgear {
  23
  24 static std::string toStdString(const char* n)
  25 {
  26     if (!n)
  27         return std::string();
  28     return std::string(n);
  29 }
  30
  31 /// Just the interface class doing the callbacks into the parent class
  32 struct RTI13Federate::FederateAmbassador : public RTI::FederateAmbassador {
  33     FederateAmbassador() :
  34         _timeRegulationEnabled(false),
  35         _timeConstrainedEnabled(false),
  36         _timeAdvancePending(false)
  37     {
  38     }
  39     virtual ~FederateAmbassador()
  40         throw (RTI::FederateInternalError)
  41     {
  42     }
  43
  44     /// RTI federate ambassador callback functions.
  45     virtual void synchronizationPointRegistrationSucceeded(const char* label)
  46         throw (RTI::FederateInternalError)
  47     {
  48     }
  49
  50     virtual void synchronizationPointRegistrationFailed(const char* label)
  51         throw (RTI::FederateInternalError)
  52     {
  53     }
  54
  55     virtual void announceSynchronizationPoint(const char* label, const char* tag)
  56         throw (RTI::FederateInternalError)
  57     {
  58         _pendingSyncLabels.insert(toStdString(label));
  59     }
  60
  61     virtual void federationSynchronized(const char* label)
  62         throw (RTI::FederateInternalError)
  63     {
  64         std::string s = toStdString(label);
  65         _pendingSyncLabels.erase(s);
  66         _syncronizedSyncLabels.insert(s);
  67     }
  68
  69     virtual void initiateFederateSave(const char* label)
  70         throw (RTI::UnableToPerformSave,
  71                RTI::FederateInternalError)
  72     {
  73     }
  74
  75     virtual void federationSaved()
  76         throw (RTI::FederateInternalError)
  77     {
  78     }
  79
  80     virtual void federationNotSaved()
  81         throw (RTI::FederateInternalError)
  82     {
  83     }
  84
  85     virtual void requestFederationRestoreSucceeded(const char* label)
  86         throw (RTI::FederateInternalError)
  87     {
  88     }
  89
  90     virtual void requestFederationRestoreFailed(const char* label, const char* reason)
  91         throw (RTI::FederateInternalError)
  92     {
  93     }
  94
  95     virtual void federationRestoreBegun()
  96         throw (RTI::FederateInternalError)
  97     {
  98     }
  99
 100     virtual void initiateFederateRestore(const char* label, RTI::FederateHandle federateHandle)
 101         throw (RTI::SpecifiedSaveLabelDoesNotExist,
 102                RTI::CouldNotRestore,
 103                RTI::FederateInternalError)
 104     {
 105     }
 106
 107     virtual void federationRestored()
 108         throw (RTI::FederateInternalError)
 109     {
 110     }
 111
 112     virtual void federationNotRestored()
 113         throw (RTI::FederateInternalError)
 114     {
 115     }
 116
 117     // Declaration Management
 118     virtual void startRegistrationForObjectClass(RTI::ObjectClassHandle objectClassHandle)
 119         throw (RTI::ObjectClassNotPublished,
 120                RTI::FederateInternalError)
 121     {
 122         ObjectClassMap::iterator i = _objectClassMap.find(objectClassHandle);
 123         if (i == _objectClassMap.end())
 124             return;
 125         if (!i->second.valid())
 126             return;
 127         i->second->startRegistration();
 128     }
 129
 130     virtual void stopRegistrationForObjectClass(RTI::ObjectClassHandle objectClassHandle)
 131         throw (RTI::ObjectClassNotPublished,
 132                RTI::FederateInternalError)
 133     {
 134         ObjectClassMap::iterator i = _objectClassMap.find(objectClassHandle);
 135         if (i == _objectClassMap.end())
 136             return;
 137         if (!i->second.valid())
 138             return;
 139         i->second->stopRegistration();
 140     }
 141
 142     virtual void turnInteractionsOn(RTI::InteractionClassHandle interactionClassHandle)
 143         throw (RTI::InteractionClassNotPublished,
 144                RTI::FederateInternalError)
 145     {
 146     }
 147
 148     virtual void turnInteractionsOff(RTI::InteractionClassHandle interactionClassHandle)
 149         throw (RTI::InteractionClassNotPublished,
 150                RTI::FederateInternalError)
 151     {
 152     }
 153
 154
 155     // Object Management
 156     virtual void discoverObjectInstance(RTI::ObjectHandle objectHandle, RTI::ObjectClassHandle objectClassHandle, const char* tag)
 157         throw (RTI::CouldNotDiscover,
 158                RTI::ObjectClassNotKnown,
 159                RTI::FederateInternalError)
 160     {
 161         ObjectClassMap::iterator i = _objectClassMap.find(objectClassHandle);
 162         if (i == _objectClassMap.end())
 163             throw RTI::ObjectClassNotKnown("Federate: discoverObjectInstance()!");
 164         if (!i->second.valid())
 165             return;
 166         SGSharedPtr<RTI13ObjectInstance> objectInstance = new RTI13ObjectInstance(objectHandle, 0, i->second, _rtiAmbassador.get(), false);
 167         _objectInstanceMap[objectHandle] = objectInstance;
 168         _queueCallbackList.push_back(new DiscoverObjectCallback(i->second, objectInstance, tagToData(tag)));
 169     }
 170
 171     virtual void reflectAttributeValues(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleValuePairSet& attributeValuePairSet,
 172                                         const RTI::FedTime& fedTime, const char* tag, RTI::EventRetractionHandle eventRetractionHandle)
 173         throw (RTI::ObjectNotKnown,
 174                RTI::AttributeNotKnown,
 175                RTI::FederateOwnsAttributes,
 176                RTI::InvalidFederationTime,
 177                RTI::FederateInternalError)
 178     {
 179         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 180         if (i == _objectInstanceMap.end())
 181             throw RTI::ObjectNotKnown("Reflect attributes for unknown object!");
 182         if (!i->second.valid())
 183             return;
 184         i->second->reflectAttributeValues(attributeValuePairSet, RTI13Ambassador::toTimeStamp(fedTime), tagToData(tag));
 185     }
 186
 187     virtual void reflectAttributeValues(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleValuePairSet& attributeValuePairSet,
 188                                         const char* tag)
 189         throw (RTI::ObjectNotKnown,
 190                RTI::AttributeNotKnown,
 191                RTI::FederateOwnsAttributes,
 192                RTI::FederateInternalError)
 193     {
 194         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 195         if (i == _objectInstanceMap.end())
 196             throw RTI::ObjectNotKnown("Reflect attributes for unknown object!");
 197         if (!i->second.valid())
 198             return;
 199         i->second->reflectAttributeValues(attributeValuePairSet, tagToData(tag));
 200     }
 201
 202     virtual void receiveInteraction(RTI::InteractionClassHandle interactionClassHandle, const RTI::ParameterHandleValuePairSet& parameters,
 203                                     const RTI::FedTime& fedTime, const char* tag, RTI::EventRetractionHandle eventRetractionHandle)
 204         throw (RTI::InteractionClassNotKnown,
 205                RTI::InteractionParameterNotKnown,
 206                RTI::InvalidFederationTime,
 207                RTI::FederateInternalError)
 208     {
 209     }
 210
 211     virtual void receiveInteraction(RTI::InteractionClassHandle interactionClassHandle,
 212                                     const RTI::ParameterHandleValuePairSet& parameters, const char* tag)
 213         throw (RTI::InteractionClassNotKnown,
 214                RTI::InteractionParameterNotKnown,
 215                RTI::FederateInternalError)
 216     {
 217     }
 218
 219     virtual void removeObjectInstance(RTI::ObjectHandle objectHandle, const RTI::FedTime& fedTime,
 220                                       const char* tag, RTI::EventRetractionHandle eventRetractionHandle)
 221         throw (RTI::ObjectNotKnown,
 222                RTI::InvalidFederationTime,
 223                RTI::FederateInternalError)
 224     {
 225         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 226         if (i == _objectInstanceMap.end())
 227             throw RTI::ObjectNotKnown("Federate: removeObjectInstance()!");
 228         if (i->second.valid())
 229             _queueCallbackList.push_back(new RemoveObjectCallback(i->second, tagToData(tag)));
 230         _objectInstanceMap.erase(i);
 231     }
 232
 233     virtual void removeObjectInstance(RTI::ObjectHandle objectHandle, const char* tag)
 234         throw (RTI::ObjectNotKnown,
 235                RTI::FederateInternalError)
 236     {
 237         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 238         if (i == _objectInstanceMap.end())
 239             throw RTI::ObjectNotKnown("Federate: removeObjectInstance()!");
 240         if (i->second.valid())
 241             _queueCallbackList.push_back(new RemoveObjectCallback(i->second, tagToData(tag)));
 242         _objectInstanceMap.erase(i);
 243     }
 244
 245     virtual void attributesInScope(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 246         throw (RTI::ObjectNotKnown,
 247                RTI::AttributeNotKnown,
 248                RTI::FederateInternalError)
 249     {
 250         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 251         if (i == _objectInstanceMap.end())
 252             throw RTI::ObjectNotKnown("Attributes in scope for unknown object!");
 253         if (!i->second.valid())
 254             return;
 255         i->second->attributesInScope(attributes);
 256     }
 257
 258     virtual void attributesOutOfScope(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 259         throw (RTI::ObjectNotKnown,
 260                RTI::AttributeNotKnown,
 261                RTI::FederateInternalError)
 262     {
 263         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 264         if (i == _objectInstanceMap.end())
 265             throw RTI::ObjectNotKnown("Attributes in scope for unknown object!");
 266         if (!i->second.valid())
 267             return;
 268         i->second->attributesOutOfScope(attributes);
 269     }
 270
 271     virtual void provideAttributeValueUpdate(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 272         throw (RTI::ObjectNotKnown,
 273                RTI::AttributeNotKnown,
 274                RTI::AttributeNotOwned,
 275                RTI::FederateInternalError)
 276     {
 277         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 278         if (i == _objectInstanceMap.end())
 279             throw RTI::ObjectNotKnown("Reflect attributes for unknown object!");
 280         if (!i->second.valid())
 281             return;
 282         i->second->provideAttributeValueUpdate(attributes);
 283     }
 284
 285     virtual void turnUpdatesOnForObjectInstance(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 286         throw (RTI::ObjectNotKnown,
 287                RTI::AttributeNotOwned,
 288                RTI::FederateInternalError)
 289     {
 290         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 291         if (i == _objectInstanceMap.end())
 292             throw RTI::ObjectNotKnown("Turn on attributes for unknown object!");
 293         if (!i->second.valid())
 294             return;
 295         i->second->turnUpdatesOnForObjectInstance(attributes);
 296     }
 297
 298     virtual void turnUpdatesOffForObjectInstance(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 299         throw (RTI::ObjectNotKnown,
 300                RTI::AttributeNotOwned,
 301                RTI::FederateInternalError)
 302     {
 303         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 304         if (i == _objectInstanceMap.end())
 305             throw RTI::ObjectNotKnown("Turn off attributes for unknown object!");
 306         if (!i->second.valid())
 307             return;
 308         i->second->turnUpdatesOffForObjectInstance(attributes);
 309     }
 310
 311     // Ownership Management
 312     virtual void requestAttributeOwnershipAssumption(RTI::ObjectHandle objectHandle,
 313                                                      const RTI::AttributeHandleSet& attributes, const char* tag)
 314         throw (RTI::ObjectNotKnown,
 315                RTI::AttributeNotKnown,
 316                RTI::AttributeAlreadyOwned,
 317                RTI::AttributeNotPublished,
 318                RTI::FederateInternalError)
 319     {
 320         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 321         if (i == _objectInstanceMap.end())
 322             throw RTI::ObjectNotKnown("requestAttributeOwnershipAssumption for unknown object!");
 323         if (!i->second.valid())
 324             return;
 325         i->second->requestAttributeOwnershipAssumption(attributes, tagToData(tag));
 326     }
 327
 328     virtual void attributeOwnershipDivestitureNotification(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 329         throw (RTI::ObjectNotKnown,
 330                RTI::AttributeNotKnown,
 331                RTI::AttributeNotOwned,
 332                RTI::AttributeDivestitureWasNotRequested,
 333                RTI::FederateInternalError)
 334     {
 335         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 336         if (i == _objectInstanceMap.end())
 337             throw RTI::ObjectNotKnown("attributeOwnershipDivestitureNotification for unknown object!");
 338         if (!i->second.valid())
 339             return;
 340         i->second->attributeOwnershipDivestitureNotification(attributes);
 341     }
 342
 343     virtual void attributeOwnershipAcquisitionNotification(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 344         throw (RTI::ObjectNotKnown,
 345                RTI::AttributeNotKnown,
 346                RTI::AttributeAcquisitionWasNotRequested,
 347                RTI::AttributeAlreadyOwned,
 348                RTI::AttributeNotPublished,
 349                RTI::FederateInternalError)
 350     {
 351         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 352         if (i == _objectInstanceMap.end())
 353             throw RTI::ObjectNotKnown("attributeOwnershipAcquisitionNotification for unknown object!");
 354         if (!i->second.valid())
 355             return;
 356         i->second->attributeOwnershipAcquisitionNotification(attributes);
 357     }
 358
 359     virtual void attributeOwnershipUnavailable(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 360         throw (RTI::ObjectNotKnown,
 361                RTI::AttributeNotKnown,
 362                RTI::AttributeAlreadyOwned,
 363                RTI::AttributeAcquisitionWasNotRequested,
 364                RTI::FederateInternalError)
 365     {
 366         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 367         if (i == _objectInstanceMap.end())
 368             throw RTI::ObjectNotKnown("attributeOwnershipUnavailable for unknown object!");
 369         if (!i->second.valid())
 370             return;
 371         i->second->attributeOwnershipUnavailable(attributes);
 372     }
 373
 374     virtual void requestAttributeOwnershipRelease(RTI::ObjectHandle objectHandle,
 375                                                   const RTI::AttributeHandleSet& attributes, const char* tag)
 376         throw (RTI::ObjectNotKnown,
 377                RTI::AttributeNotKnown,
 378                RTI::AttributeNotOwned,
 379                RTI::FederateInternalError)
 380     {
 381         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 382         if (i == _objectInstanceMap.end())
 383             throw RTI::ObjectNotKnown("requestAttributeOwnershipRelease for unknown object!");
 384         if (!i->second.valid())
 385             return;
 386         i->second->requestAttributeOwnershipRelease(attributes, tagToData(tag));
 387     }
 388
 389     virtual void confirmAttributeOwnershipAcquisitionCancellation(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 390         throw (RTI::ObjectNotKnown,
 391                RTI::AttributeNotKnown,
 392                RTI::AttributeAlreadyOwned,
 393                RTI::AttributeAcquisitionWasNotCanceled,
 394                RTI::FederateInternalError)
 395     {
 396         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 397         if (i == _objectInstanceMap.end())
 398             throw RTI::ObjectNotKnown("confirmAttributeOwnershipAcquisitionCancellation for unknown object!");
 399         if (!i->second.valid())
 400             return;
 401         i->second->confirmAttributeOwnershipAcquisitionCancellation(attributes);
 402     }
 403
 404     virtual void informAttributeOwnership(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle,
 405                                           RTI::FederateHandle federateHandle)
 406         throw (RTI::ObjectNotKnown,
 407                RTI::AttributeNotKnown,
 408                RTI::FederateInternalError)
 409     {
 410         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 411         if (i == _objectInstanceMap.end())
 412             throw RTI::ObjectNotKnown("informAttributeOwnership for unknown object!");
 413         if (!i->second.valid())
 414             return;
 415         i->second->informAttributeOwnership(attributeHandle, federateHandle);
 416     }
 417
 418     virtual void attributeIsNotOwned(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle)
 419         throw (RTI::ObjectNotKnown,
 420                RTI::AttributeNotKnown,
 421                RTI::FederateInternalError)
 422     {
 423         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 424         if (i == _objectInstanceMap.end())
 425             throw RTI::ObjectNotKnown("attributeIsNotOwned for unknown object!");
 426         if (!i->second.valid())
 427             return;
 428         i->second->attributeIsNotOwned(attributeHandle);
 429     }
 430
 431     virtual void attributeOwnedByRTI(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle)
 432         throw (RTI::ObjectNotKnown,
 433                RTI::AttributeNotKnown,
 434                RTI::FederateInternalError)
 435     {
 436         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 437         if (i == _objectInstanceMap.end())
 438             throw RTI::ObjectNotKnown("attributeOwnedByRTI for unknown object!");
 439         if (!i->second.valid())
 440             return;
 441         i->second->attributeOwnedByRTI(attributeHandle);
 442     }
 443
 444     // Time Management
 445     virtual void timeRegulationEnabled(const RTI::FedTime& fedTime)
 446         throw (RTI::InvalidFederationTime,
 447                RTI::EnableTimeRegulationWasNotPending,
 448                RTI::FederateInternalError)
 449     {
 450         _timeRegulationEnabled = true;
 451         _federateTime = RTI13Ambassador::toTimeStamp(fedTime);
 452         SG_LOG(SG_NETWORK, SG_INFO, "RTI: timeRegulationEnabled: " << _federateTime);
 453     }
 454
 455     virtual void timeConstrainedEnabled(const RTI::FedTime& fedTime)
 456         throw (RTI::InvalidFederationTime,
 457                RTI::EnableTimeConstrainedWasNotPending,
 458                RTI::FederateInternalError)
 459     {
 460         _timeConstrainedEnabled = true;
 461         _federateTime = RTI13Ambassador::toTimeStamp(fedTime);
 462         SG_LOG(SG_NETWORK, SG_INFO, "RTI: timeConstrainedEnabled: " << _federateTime);
 463     }
 464
 465     virtual void timeAdvanceGrant(const RTI::FedTime& fedTime)
 466         throw (RTI::InvalidFederationTime,
 467                RTI::TimeAdvanceWasNotInProgress,
 468                RTI::FederateInternalError)
 469     {
 470         _federateTime = RTI13Ambassador::toTimeStamp(fedTime);
 471         _timeAdvancePending = false;
 472         SG_LOG(SG_NETWORK, SG_INFO, "RTI: timeAdvanceGrant: " << _federateTime);
 473     }
 474
 475     virtual void requestRetraction(RTI::EventRetractionHandle eventRetractionHandle)
 476         throw (RTI::EventNotKnown,
 477                RTI::FederateInternalError)
 478     {
 479         // No retraction concept yet
 480     }
 481
 482     // processes the queues that filled up during the past
 483     void processQueues()
 484     {
 485         while (!_queueCallbackList.empty()) {
 486             (*_queueCallbackList.front())();
 487             _queueCallbackList.pop_front();
 488         }
 489     }
 490
 491     bool getFederationSynchronizationPointAnnounced(const std::string& label)
 492     { return _pendingSyncLabels.find(label) != _pendingSyncLabels.end(); }
 493     bool getFederationSynchronized(const std::string& label)
 494     {
 495         std::set<std::string>::iterator i = _syncronizedSyncLabels.find(label);
 496         if (i == _syncronizedSyncLabels.end())
 497             return false;
 498         _syncronizedSyncLabels.erase(i);
 499         return true;
 500     }
 501
 502     /// Generic callback to execute some notification on objects in a way that they are not prone to
 503     /// ConcurrentAccess exceptions.
 504     class QueueCallback : public SGReferenced {
 505     public:
 506         virtual ~QueueCallback() {}
 507         virtual void operator()() = 0;
 508     };
 509
 510     class DiscoverObjectCallback : public QueueCallback {
 511     public:
 512         DiscoverObjectCallback(SGSharedPtr<RTIObjectClass> objectClass, SGSharedPtr<RTIObjectInstance> objectInstance, const RTIData& tag) :
 513             _objectClass(objectClass),
 514             _objectInstance(objectInstance),
 515             _tag(tag)
 516         { }
 517         virtual void operator()()
 518         {
 519             _objectClass->discoverInstance(_objectInstance.get(), _tag);
 520             _objectInstance->requestObjectAttributeValueUpdate();
 521         }
 522     private:
 523         SGSharedPtr<RTIObjectClass> _objectClass;
 524         SGSharedPtr<RTIObjectInstance> _objectInstance;
 525         RTIData _tag;
 526     };
 527     class RemoveObjectCallback : public QueueCallback {
 528     public:
 529         RemoveObjectCallback(SGSharedPtr<RTIObjectInstance> objectInstance, const RTIData& tag) :
 530             _objectInstance(objectInstance),
 531             _tag(tag)
 532         { }
 533         virtual void operator()()
 534         {
 535             _objectInstance->removeInstance(_tag);
 536         }
 537     private:
 538         SGSharedPtr<RTIObjectInstance> _objectInstance;
 539         RTIData _tag;
 540     };
 541
 542     // The rtiambassador to issue requests
 543     SGSharedPtr<RTI13Ambassador> _rtiAmbassador;
 544
 545     // All the sync labels we got an announcement for
 546     std::set<std::string> _pendingSyncLabels;
 547     std::set<std::string> _syncronizedSyncLabels;
 548
 549     // All that calls back into user code is just queued.
 550     // That is to make sure we do not call recursively into the RTI
 551     typedef std::list<SGSharedPtr<QueueCallback> > QueueCallbackList;
 552     QueueCallbackList _queueCallbackList;
 553
 554     // Top level information for dispatching federate object attribute updates
 555     typedef std::map<RTI::ObjectHandle, SGSharedPtr<RTI13ObjectInstance> > ObjectInstanceMap;
 556     // Map of all available objects
 557     ObjectInstanceMap _objectInstanceMap;
 558
 559     // Top level information for dispatching creation of federate objects
 560     typedef std::map<RTI::ObjectClassHandle, SGSharedPtr<RTI13ObjectClass> > ObjectClassMap;
 561     ObjectClassMap _objectClassMap;
 562
 563     bool _timeRegulationEnabled;
 564     bool _timeConstrainedEnabled;
 565     bool _timeAdvancePending;
 566     SGTimeStamp _federateTime;
 567
 568 private:
 569     const RTIData& tagToData(const char* tag)
 570     {
 571         if (tag)
 572             _cachedTag.setData(tag, std::strlen(tag) + 1);
 573         else
 574             _cachedTag.setData("", 1);
 575         return _cachedTag;
 576     }
 577     RTIData _cachedTag;
 578 };
 579
 580 RTI13Federate::RTI13Federate(const std::list<std::string>& stringList) :
 581     _joined(false),
 582     _ambassador(new RTI13Ambassador),
 583     _federateAmbassador(new FederateAmbassador)
 584 {
 585     _ambassador->_federate = this;
 586     _federateAmbassador->_rtiAmbassador = _ambassador;
 587     if (stringList.empty()) {
 588         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Ignoring non empty connect arguments while connecting to an RTI13 federation!");
 589     }
 590 }
 591
 592 RTI13Federate::~RTI13Federate()
 593 {
 594     if (_joined)
 595         _ambassador->resignFederationExecution();
 596     delete _federateAmbassador;
 597 }
 598
 599 RTI13Federate::FederationManagementResult
 600 RTI13Federate::createFederationExecution(const std::string& federationName, const std::string& objectModel)
 601 {
 602     try {
 603         _ambassador->createFederationExecution(federationName, objectModel);
 604         return FederationManagementSuccess;
 605     } catch (RTI::FederationExecutionAlreadyExists& e) {
 606         return FederationManagementFail;
 607     } catch (RTI::CouldNotOpenFED& e) {
 608         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create federation execution: " << e._name << " " << e._reason);
 609         return FederationManagementFatal;
 610     } catch (RTI::ErrorReadingFED& e) {
 611         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create federation execution: " << e._name << " " << e._reason);
 612         return FederationManagementFatal;
 613     } catch (RTI::ConcurrentAccessAttempted& e) {
 614         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create federation execution: " << e._name << " " << e._reason);
 615         return FederationManagementFatal;
 616     } catch (RTI::RTIinternalError& e) {
 617         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create federation execution: " << e._name << " " << e._reason);
 618         return FederationManagementFatal;
 619     }
 620 }
 621
 622 RTI13Federate::FederationManagementResult
 623 RTI13Federate::destroyFederationExecution(const std::string& federation)
 624 {
 625     try {
 626         _ambassador->destroyFederationExecution(federation);
 627         return FederationManagementSuccess;
 628     } catch (RTI::FederatesCurrentlyJoined& e) {
 629         return FederationManagementFail;
 630     } catch (RTI::FederationExecutionDoesNotExist& e) {
 631         return FederationManagementFail;
 632     } catch (RTI::ConcurrentAccessAttempted& e) {
 633         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not destroy federation execution: " << e._name << " " << e._reason);
 634         return FederationManagementFatal;
 635     } catch (RTI::RTIinternalError& e) {
 636         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not destroy federation execution: " << e._name << " " << e._reason);
 637         return FederationManagementFatal;
 638     }
 639 }
 640
 641 RTI13Federate::FederationManagementResult
 642 RTI13Federate::join(const std::string& federateType, const std::string& federationName)
 643 {
 644     try {
 645         _federateHandle = _ambassador->joinFederationExecution(federateType, federationName, _federateAmbassador);
 646         SG_LOG(SG_NETWORK, SG_INFO, "RTI: Joined federation \""
 647                << federationName << "\" as \"" << federateType << "\"");
 648         _joined = true;
 649         return FederationManagementSuccess;
 650     } catch (RTI::FederateAlreadyExecutionMember& e) {
 651         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
 652         return FederationManagementFatal;
 653     } catch (RTI::FederationExecutionDoesNotExist& e) {
 654         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
 655         return FederationManagementFail;
 656     } catch (RTI::CouldNotOpenFED& e) {
 657         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
 658         return FederationManagementFatal;
 659     } catch (RTI::ErrorReadingFED& e) {
 660         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
 661         return FederationManagementFatal;
 662     } catch (RTI::ConcurrentAccessAttempted& e) {
 663         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
 664         return FederationManagementFatal;
 665     } catch (RTI::SaveInProgress& e) {
 666         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
 667         return FederationManagementFatal;
 668     } catch (RTI::RestoreInProgress& e) {
 669         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
 670         return FederationManagementFatal;
 671     } catch (RTI::RTIinternalError& e) {
 672         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
 673         return FederationManagementFatal;
 674     }
 675 }
 676
 677 bool
 678 RTI13Federate::resign()
 679 {
 680     try {
 681         _ambassador->resignFederationExecution();
 682         SG_LOG(SG_NETWORK, SG_INFO, "RTI: Resigned from federation.");
 683         _joined = false;
 684         _federateHandle = -1;
 685         return true;
 686     } catch (RTI::FederateOwnsAttributes& e) {
 687         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 688         return false;
 689     } catch (RTI::FederateNotExecutionMember& e) {
 690         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 691         return false;
 692     } catch (RTI::InvalidResignAction& e) {
 693         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 694         return false;
 695     } catch (RTI::ConcurrentAccessAttempted& e) {
 696         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 697         return false;
 698     } catch (RTI::RTIinternalError& e) {
 699         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 700         return false;
 701     }
 702 }
 703
 704 bool
 705 RTI13Federate::getJoined() const
 706 {
 707     return _joined;
 708 }
 709
 710 bool
 711 RTI13Federate::registerFederationSynchronizationPoint(const std::string& label, const RTIData& tag)
 712 {
 713     try {
 714         _ambassador->registerFederationSynchronizationPoint(label, tag);
 715         SG_LOG(SG_NETWORK, SG_INFO, "RTI: registerFederationSynchronizationPoint(" << label << ", tag )");
 716         return true;
 717     } catch (RTI::FederateNotExecutionMember& e) {
 718         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not register federation synchronization point: " << e._name << " " << e._reason);
 719         return false;
 720     } catch (RTI::ConcurrentAccessAttempted& e) {
 721         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not register federation synchronization point: " << e._name << " " << e._reason);
 722         return false;
 723     } catch (RTI::SaveInProgress& e) {
 724         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not register federation synchronization point: " << e._name << " " << e._reason);
 725         return false;
 726     } catch (RTI::RestoreInProgress& e) {
 727         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not register federation synchronization point: " << e._name << " " << e._reason);
 728         return false;
 729     } catch (RTI::RTIinternalError& e) {
 730         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not register federation synchronization point: " << e._name << " " << e._reason);
 731         return false;
 732     }
 733 }
 734
 735 bool
 736 RTI13Federate::getFederationSynchronizationPointAnnounced(const std::string& label)
 737 {
 738     return _federateAmbassador->getFederationSynchronizationPointAnnounced(label);
 739 }
 740
 741 bool
 742 RTI13Federate::synchronizationPointAchieved(const std::string& label)
 743 {
 744     try {
 745         _ambassador->synchronizationPointAchieved(label);
 746         SG_LOG(SG_NETWORK, SG_INFO, "RTI: synchronizationPointAchieved(" << label << ")");
 747         return true;
 748     } catch (RTI::SynchronizationPointLabelWasNotAnnounced& e) {
 749         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
 750         return false;
 751     } catch (RTI::FederateNotExecutionMember& e) {
 752         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
 753         return false;
 754     } catch (RTI::ConcurrentAccessAttempted& e) {
 755         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
 756         return false;
 757     } catch (RTI::SaveInProgress& e) {
 758         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
 759         return false;
 760     } catch (RTI::RestoreInProgress& e) {
 761         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
 762         return false;
 763     } catch (RTI::RTIinternalError& e) {
 764         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
 765         return false;
 766     }
 767 }
 768
 769 bool
 770 RTI13Federate::getFederationSynchronized(const std::string& label)
 771 {
 772     return _federateAmbassador->getFederationSynchronized(label);
 773 }
 774
 775 bool
 776 RTI13Federate::enableTimeConstrained()
 777 {
 778     if (!_ambassador.valid()) {
 779         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time constrained at unconnected federate.");
 780         return false;
 781     }
 782
 783     if (_federateAmbassador->_timeConstrainedEnabled) {
 784         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Time constrained is already enabled.");
 785         return false;
 786     }
 787
 788     try {
 789         _ambassador->enableTimeConstrained();
 790     } catch (RTI::TimeConstrainedAlreadyEnabled& e) {
 791         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 792         return false;
 793     } catch (RTI::EnableTimeConstrainedPending& e) {
 794         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 795         return false;
 796     } catch (RTI::TimeAdvanceAlreadyInProgress& e) {
 797         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 798         return false;
 799     } catch (RTI::ConcurrentAccessAttempted& e) {
 800         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 801         return false;
 802     } catch (RTI::FederateNotExecutionMember& e) {
 803         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 804         return false;
 805     } catch (RTI::SaveInProgress& e) {
 806         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 807         return false;
 808     } catch (RTI::RestoreInProgress& e) {
 809         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 810         return false;
 811     } catch (RTI::RTIinternalError& e) {
 812         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 813         return false;
 814     }
 815
 816     return true;
 817 }
 818
 819 bool
 820 RTI13Federate::disableTimeConstrained()
 821 {
 822     if (!_ambassador.valid()) {
 823         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time constrained at unconnected federate.");
 824         return false;
 825     }
 826
 827     if (!_federateAmbassador->_timeConstrainedEnabled) {
 828         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Time constrained is not enabled.");
 829         return false;
 830     }
 831
 832     try {
 833         _ambassador->disableTimeConstrained();
 834         _federateAmbassador->_timeConstrainedEnabled = false;
 835     } catch (RTI::TimeConstrainedWasNotEnabled& e) {
 836         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 837         return false;
 838     } catch (RTI::FederateNotExecutionMember& e) {
 839         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 840         return false;
 841     } catch (RTI::ConcurrentAccessAttempted& e) {
 842         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 843         return false;
 844     } catch (RTI::SaveInProgress& e) {
 845         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 846         return false;
 847     } catch (RTI::RestoreInProgress& e) {
 848         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 849         return false;
 850     } catch (RTI::RTIinternalError& e) {
 851         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 852         return false;
 853     }
 854
 855     return true;
 856 }
 857
 858 bool
 859 RTI13Federate::getTimeConstrainedEnabled()
 860 {
 861     return _federateAmbassador->_timeConstrainedEnabled;
 862 }
 863
 864 bool
 865 RTI13Federate::enableTimeRegulation(const SGTimeStamp& lookahead)
 866 {
 867     if (!_ambassador.valid()) {
 868         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time regulation at unconnected federate.");
 869         return false;
 870     }
 871
 872     if (_federateAmbassador->_timeRegulationEnabled) {
 873         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Time regulation already enabled.");
 874         return false;
 875     }
 876
 877     try {
 878         _ambassador->enableTimeRegulation(lookahead);
 879     } catch (RTI::TimeRegulationAlreadyEnabled& e) {
 880         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 881         return false;
 882     } catch (RTI::EnableTimeRegulationPending& e) {
 883         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 884         return false;
 885     } catch (RTI::TimeAdvanceAlreadyInProgress& e) {
 886         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 887         return false;
 888     } catch (RTI::InvalidFederationTime& e) {
 889         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 890         return false;
 891     } catch (RTI::InvalidLookahead& e) {
 892         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 893         return false;
 894     } catch (RTI::ConcurrentAccessAttempted& e) {
 895         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 896         return false;
 897     } catch (RTI::FederateNotExecutionMember& e) {
 898         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 899         return false;
 900     } catch (RTI::SaveInProgress& e) {
 901         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 902         return false;
 903     } catch (RTI::RestoreInProgress& e) {
 904         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 905         return false;
 906     } catch (RTI::RTIinternalError& e) {
 907         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 908         return false;
 909     }
 910
 911     return true;
 912 }
 913
 914 bool
 915 RTI13Federate::disableTimeRegulation()
 916 {
 917     if (!_ambassador.valid()) {
 918         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time regulation at unconnected federate.");
 919         return false;
 920     }
 921
 922     if (!_federateAmbassador->_timeRegulationEnabled) {
 923         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Time regulation is not enabled.");
 924         return false;
 925     }
 926
 927     try {
 928         _ambassador->disableTimeRegulation();
 929         _federateAmbassador->_timeRegulationEnabled = false;
 930     } catch (RTI::TimeRegulationWasNotEnabled& e) {
 931         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 932         return false;
 933     } catch (RTI::ConcurrentAccessAttempted& e) {
 934         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 935         return false;
 936     } catch (RTI::FederateNotExecutionMember& e) {
 937         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 938         return false;
 939     } catch (RTI::SaveInProgress& e) {
 940         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 941         return false;
 942     } catch (RTI::RestoreInProgress& e) {
 943         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 944         return false;
 945     } catch (RTI::RTIinternalError& e) {
 946         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 947         return false;
 948     }
 949
 950     return true;
 951 }
 952
 953 bool
 954 RTI13Federate::modifyLookahead(const SGTimeStamp& timeStamp)
 955 {
 956     if (!_ambassador.valid()) {
 957         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead.");
 958         return false;
 959     }
 960     try {
 961         _ambassador->modifyLookahead(timeStamp);
 962     } catch (RTI::InvalidLookahead& e) {
 963         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
 964         return false;
 965     } catch (RTI::FederateNotExecutionMember& e) {
 966         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
 967         return false;
 968     } catch (RTI::ConcurrentAccessAttempted& e) {
 969         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
 970         return false;
 971     } catch (RTI::SaveInProgress& e) {
 972         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
 973         return false;
 974     } catch (RTI::RestoreInProgress& e) {
 975         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
 976         return false;
 977     } catch (RTI::RTIinternalError& e) {
 978         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
 979         return false;
 980     }
 981     return true;
 982 }
 983
 984 bool
 985 RTI13Federate::getTimeRegulationEnabled()
 986 {
 987     return _federateAmbassador->_timeRegulationEnabled;
 988 }
 989
 990 bool
 991 RTI13Federate::timeAdvanceRequest(const SGTimeStamp& timeStamp)
 992 {
 993     if (!_ambassador.valid()) {
 994         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time regulation at unconnected federate.");
 995         return false;
 996     }
 997
 998     try {
 999         _ambassador->timeAdvanceRequest(timeStamp);
1000         _federateAmbassador->_timeAdvancePending = true;
1001     } catch (RTI::InvalidFederationTime& e) {
1002         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1003         return false;
1004     } catch (RTI::FederationTimeAlreadyPassed& e) {
1005         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1006         return false;
1007     } catch (RTI::TimeAdvanceAlreadyInProgress& e) {
1008         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1009         return false;
1010     } catch (RTI::EnableTimeRegulationPending& e) {
1011         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1012         return false;
1013     } catch (RTI::EnableTimeConstrainedPending& e) {
1014         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1015         return false;
1016     } catch (RTI::FederateNotExecutionMember& e) {
1017         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1018         return false;
1019     } catch (RTI::ConcurrentAccessAttempted& e) {
1020         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1021         return false;
1022     } catch (RTI::SaveInProgress& e) {
1023         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1024         return false;
1025     } catch (RTI::RestoreInProgress& e) {
1026         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1027         return false;
1028     } catch (RTI::RTIinternalError& e) {
1029         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1030         return false;
1031     }
1032
1033     return true;
1034 }
1035
1036 bool
1037 RTI13Federate::timeAdvanceRequestAvailable(const SGTimeStamp& timeStamp)
1038 {
1039     if (!_ambassador.valid()) {
1040         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time regulation at unconnected federate.");
1041         return false;
1042     }
1043
1044     try {
1045         _ambassador->timeAdvanceRequestAvailable(timeStamp);
1046         _federateAmbassador->_timeAdvancePending = true;
1047     } catch (RTI::InvalidFederationTime& e) {
1048         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1049         return false;
1050     } catch (RTI::FederationTimeAlreadyPassed& e) {
1051         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1052         return false;
1053     } catch (RTI::TimeAdvanceAlreadyInProgress& e) {
1054         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1055         return false;
1056     } catch (RTI::EnableTimeRegulationPending& e) {
1057         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1058         return false;
1059     } catch (RTI::EnableTimeConstrainedPending& e) {
1060         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1061         return false;
1062     } catch (RTI::FederateNotExecutionMember& e) {
1063         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1064         return false;
1065     } catch (RTI::ConcurrentAccessAttempted& e) {
1066         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1067         return false;
1068     } catch (RTI::SaveInProgress& e) {
1069         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1070         return false;
1071     } catch (RTI::RestoreInProgress& e) {
1072         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1073         return false;
1074     } catch (RTI::RTIinternalError& e) {
1075         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1076         return false;
1077     }
1078
1079     return true;
1080 }
1081
1082 bool
1083 RTI13Federate::getTimeAdvancePending()
1084 {
1085     return _federateAmbassador->_timeAdvancePending;
1086 }
1087
1088 bool
1089 RTI13Federate::queryFederateTime(SGTimeStamp& timeStamp)
1090 {
1091     if (!_ambassador.valid()) {
1092         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time.");
1093         return false;
1094     }
1095
1096     try {
1097         _ambassador->queryFederateTime(timeStamp);
1098     } catch (RTI::FederateNotExecutionMember& e) {
1099         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time: " << e._name << " " << e._reason);
1100         return false;
1101     } catch (RTI::ConcurrentAccessAttempted& e) {
1102         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time: " << e._name << " " << e._reason);
1103         return false;
1104     } catch (RTI::SaveInProgress& e) {
1105         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time: " << e._name << " " << e._reason);
1106         return false;
1107     } catch (RTI::RestoreInProgress& e) {
1108         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time: " << e._name << " " << e._reason);
1109         return false;
1110     } catch (RTI::RTIinternalError& e) {
1111         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time: " << e._name << " " << e._reason);
1112         return false;
1113     }
1114     return true;
1115 }
1116
1117 bool
1118 RTI13Federate::queryLookahead(SGTimeStamp& timeStamp)
1119 {
1120     if (!_ambassador.valid()) {
1121         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead.");
1122         return false;
1123     }
1124
1125     try {
1126         _ambassador->queryLookahead(timeStamp);
1127     } catch (RTI::FederateNotExecutionMember& e) {
1128         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead: " << e._name << " " << e._reason);
1129         return false;
1130     } catch (RTI::ConcurrentAccessAttempted& e) {
1131         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead: " << e._name << " " << e._reason);
1132         return false;
1133     } catch (RTI::SaveInProgress& e) {
1134         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead: " << e._name << " " << e._reason);
1135         return false;
1136     } catch (RTI::RestoreInProgress& e) {
1137         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead: " << e._name << " " << e._reason);
1138         return false;
1139     } catch (RTI::RTIinternalError& e) {
1140         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead: " << e._name << " " << e._reason);
1141         return false;
1142     }
1143     return true;
1144 }
1145
1146 bool
1147 RTI13Federate::queryGALT(SGTimeStamp& timeStamp)
1148 {
1149     if (!_ambassador.valid()) {
1150         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT.");
1151         return false;
1152     }
1153
1154     try {
1155         return _ambassador->queryGALT(timeStamp);
1156     } catch (RTI::FederateNotExecutionMember& e) {
1157         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT: " << e._name << " " << e._reason);
1158         return false;
1159     } catch (RTI::ConcurrentAccessAttempted& e) {
1160         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT: " << e._name << " " << e._reason);
1161         return false;
1162     } catch (RTI::SaveInProgress& e) {
1163         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT: " << e._name << " " << e._reason);
1164         return false;
1165     } catch (RTI::RestoreInProgress& e) {
1166         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT: " << e._name << " " << e._reason);
1167         return false;
1168     } catch (RTI::RTIinternalError& e) {
1169         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT: " << e._name << " " << e._reason);
1170         return false;
1171     }
1172     return true;
1173 }
1174
1175 bool
1176 RTI13Federate::queryLITS(SGTimeStamp& timeStamp)
1177 {
1178     if (!_ambassador.valid()) {
1179         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS.");
1180         return false;
1181     }
1182
1183     try {
1184         return _ambassador->queryLITS(timeStamp);
1185     } catch (RTI::FederateNotExecutionMember& e) {
1186         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS: " << e._name << " " << e._reason);
1187         return false;
1188     } catch (RTI::ConcurrentAccessAttempted& e) {
1189         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS: " << e._name << " " << e._reason);
1190         return false;
1191     } catch (RTI::SaveInProgress& e) {
1192         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS: " << e._name << " " << e._reason);
1193         return false;
1194     } catch (RTI::RestoreInProgress& e) {
1195         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS: " << e._name << " " << e._reason);
1196         return false;
1197     } catch (RTI::RTIinternalError& e) {
1198         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS: " << e._name << " " << e._reason);
1199         return false;
1200     }
1201     return true;
1202 }
1203
1204 bool
1205 RTI13Federate::processMessage()
1206 {
1207     bool result = _ambassador->tick();
1208     _federateAmbassador->processQueues();
1209     return result;
1210 }
1211
1212 bool
1213 RTI13Federate::processMessages(const double& minimum, const double& maximum)
1214 {
1215     bool result = _ambassador->tick(minimum, 0);
1216     _federateAmbassador->processQueues();
1217     if (!result)
1218         return false;
1219     SGTimeStamp timeStamp = SGTimeStamp::now() + SGTimeStamp::fromSec(maximum);
1220     do {
1221         result = _ambassador->tick(0, 0);
1222         _federateAmbassador->processQueues();
1223     } while (result && SGTimeStamp::now() <= timeStamp);
1224     return result;
1225 }
1226
1227 RTI13ObjectClass*
1228 RTI13Federate::createObjectClass(const std::string& objectClassName, HLAObjectClass* hlaObjectClass)
1229 {
1230     try {
1231         RTI::ObjectClassHandle objectClassHandle;
1232         objectClassHandle = _ambassador->getObjectClassHandle(objectClassName);
1233         if (_federateAmbassador->_objectClassMap.find(objectClassHandle) != _federateAmbassador->_objectClassMap.end()) {
1234             SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create object class, object class already exists!");
1235             return 0;
1236         }
1237         RTI13ObjectClass* rtiObjectClass;
1238         rtiObjectClass = new RTI13ObjectClass(hlaObjectClass, objectClassHandle, _ambassador.get());
1239         _federateAmbassador->_objectClassMap[objectClassHandle] = rtiObjectClass;
1240         return rtiObjectClass;
1241     } catch (RTI::NameNotFound& e) {
1242         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1243         return 0;
1244     } catch (RTI::FederateNotExecutionMember& e) {
1245         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1246         return 0;
1247     } catch (RTI::ConcurrentAccessAttempted& e) {
1248         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1249         return 0;
1250     } catch (RTI::RTIinternalError& e) {
1251         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1252         return 0;
1253     }
1254 }
1255
1256 RTI13ObjectInstance*
1257 RTI13Federate::getObjectInstance(const std::string& objectInstanceName)
1258 {
1259     try {
1260         RTI::ObjectHandle objectHandle;
1261         objectHandle = _ambassador->getObjectInstanceHandle(objectInstanceName);
1262         FederateAmbassador::ObjectInstanceMap::iterator i = _federateAmbassador->_objectInstanceMap.find(objectHandle);
1263         if (i == _federateAmbassador->_objectInstanceMap.end()) {
1264             SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: ObjectInstance not found.");
1265             return 0;
1266         }
1267         return i->second;
1268     } catch (RTI::ObjectNotKnown& e) {
1269         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1270         return 0;
1271     } catch (RTI::FederateNotExecutionMember& e) {
1272         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1273         return 0;
1274     } catch (RTI::ConcurrentAccessAttempted& e) {
1275         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1276         return 0;
1277     } catch (RTI::RTIinternalError& e) {
1278         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1279         return 0;
1280     }
1281 }
1282
1283 void
1284 RTI13Federate::insertObjectInstance(RTI13ObjectInstance* objectInstance)
1285 {
1286     _federateAmbassador->_objectInstanceMap[objectInstance->getHandle()] = objectInstance;
1287 }
1288
1289 }