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::registerFederationSynchronizationPoint(const std::string& label, const RTIData& tag)
 706 {
 707     try {
 708         _ambassador->registerFederationSynchronizationPoint(label, tag);
 709         SG_LOG(SG_NETWORK, SG_INFO, "RTI: registerFederationSynchronizationPoint(" << label << ", tag )");
 710         return true;
 711     } catch (RTI::FederateNotExecutionMember& e) {
 712         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not register federation synchronization point: " << e._name << " " << e._reason);
 713         return false;
 714     } catch (RTI::ConcurrentAccessAttempted& e) {
 715         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not register federation synchronization point: " << e._name << " " << e._reason);
 716         return false;
 717     } catch (RTI::SaveInProgress& 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::RestoreInProgress& 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::RTIinternalError& e) {
 724         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not register federation synchronization point: " << e._name << " " << e._reason);
 725         return false;
 726     }
 727 }
 728
 729 bool
 730 RTI13Federate::getFederationSynchronizationPointAnnounced(const std::string& label)
 731 {
 732     return _federateAmbassador->getFederationSynchronizationPointAnnounced(label);
 733 }
 734
 735 bool
 736 RTI13Federate::synchronizationPointAchieved(const std::string& label)
 737 {
 738     try {
 739         _ambassador->synchronizationPointAchieved(label);
 740         SG_LOG(SG_NETWORK, SG_INFO, "RTI: synchronizationPointAchieved(" << label << ")");
 741         return true;
 742     } catch (RTI::SynchronizationPointLabelWasNotAnnounced& e) {
 743         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
 744         return false;
 745     } catch (RTI::FederateNotExecutionMember& e) {
 746         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
 747         return false;
 748     } catch (RTI::ConcurrentAccessAttempted& e) {
 749         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
 750         return false;
 751     } catch (RTI::SaveInProgress& e) {
 752         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
 753         return false;
 754     } catch (RTI::RestoreInProgress& e) {
 755         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
 756         return false;
 757     } catch (RTI::RTIinternalError& e) {
 758         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
 759         return false;
 760     }
 761 }
 762
 763 bool
 764 RTI13Federate::getFederationSynchronized(const std::string& label)
 765 {
 766     return _federateAmbassador->getFederationSynchronized(label);
 767 }
 768
 769 bool
 770 RTI13Federate::enableTimeConstrained()
 771 {
 772     if (!_ambassador.valid()) {
 773         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time constrained at unconnected federate.");
 774         return false;
 775     }
 776
 777     if (_federateAmbassador->_timeConstrainedEnabled) {
 778         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Time constrained is already enabled.");
 779         return false;
 780     }
 781
 782     try {
 783         _ambassador->enableTimeConstrained();
 784     } catch (RTI::TimeConstrainedAlreadyEnabled& e) {
 785         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 786         return false;
 787     } catch (RTI::EnableTimeConstrainedPending& e) {
 788         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 789         return false;
 790     } catch (RTI::TimeAdvanceAlreadyInProgress& e) {
 791         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 792         return false;
 793     } catch (RTI::ConcurrentAccessAttempted& e) {
 794         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 795         return false;
 796     } catch (RTI::FederateNotExecutionMember& e) {
 797         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 798         return false;
 799     } catch (RTI::SaveInProgress& e) {
 800         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 801         return false;
 802     } catch (RTI::RestoreInProgress& e) {
 803         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 804         return false;
 805     } catch (RTI::RTIinternalError& e) {
 806         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 807         return false;
 808     }
 809
 810     return true;
 811 }
 812
 813 bool
 814 RTI13Federate::disableTimeConstrained()
 815 {
 816     if (!_ambassador.valid()) {
 817         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time constrained at unconnected federate.");
 818         return false;
 819     }
 820
 821     if (!_federateAmbassador->_timeConstrainedEnabled) {
 822         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Time constrained is not enabled.");
 823         return false;
 824     }
 825
 826     try {
 827         _ambassador->disableTimeConstrained();
 828         _federateAmbassador->_timeConstrainedEnabled = false;
 829     } catch (RTI::TimeConstrainedWasNotEnabled& e) {
 830         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 831         return false;
 832     } catch (RTI::FederateNotExecutionMember& e) {
 833         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 834         return false;
 835     } catch (RTI::ConcurrentAccessAttempted& e) {
 836         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 837         return false;
 838     } catch (RTI::SaveInProgress& e) {
 839         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 840         return false;
 841     } catch (RTI::RestoreInProgress& e) {
 842         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 843         return false;
 844     } catch (RTI::RTIinternalError& e) {
 845         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 846         return false;
 847     }
 848
 849     return true;
 850 }
 851
 852 bool
 853 RTI13Federate::getTimeConstrainedEnabled()
 854 {
 855     return _federateAmbassador->_timeConstrainedEnabled;
 856 }
 857
 858 bool
 859 RTI13Federate::enableTimeRegulation(const SGTimeStamp& lookahead)
 860 {
 861     if (!_ambassador.valid()) {
 862         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time regulation at unconnected federate.");
 863         return false;
 864     }
 865
 866     if (_federateAmbassador->_timeRegulationEnabled) {
 867         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Time regulation already enabled.");
 868         return false;
 869     }
 870
 871     try {
 872         _ambassador->enableTimeRegulation(lookahead);
 873     } catch (RTI::TimeRegulationAlreadyEnabled& e) {
 874         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 875         return false;
 876     } catch (RTI::EnableTimeRegulationPending& e) {
 877         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 878         return false;
 879     } catch (RTI::TimeAdvanceAlreadyInProgress& e) {
 880         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 881         return false;
 882     } catch (RTI::InvalidFederationTime& e) {
 883         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 884         return false;
 885     } catch (RTI::InvalidLookahead& e) {
 886         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 887         return false;
 888     } catch (RTI::ConcurrentAccessAttempted& e) {
 889         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 890         return false;
 891     } catch (RTI::FederateNotExecutionMember& e) {
 892         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 893         return false;
 894     } catch (RTI::SaveInProgress& e) {
 895         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 896         return false;
 897     } catch (RTI::RestoreInProgress& e) {
 898         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 899         return false;
 900     } catch (RTI::RTIinternalError& e) {
 901         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 902         return false;
 903     }
 904
 905     return true;
 906 }
 907
 908 bool
 909 RTI13Federate::disableTimeRegulation()
 910 {
 911     if (!_ambassador.valid()) {
 912         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time regulation at unconnected federate.");
 913         return false;
 914     }
 915
 916     if (!_federateAmbassador->_timeRegulationEnabled) {
 917         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Time regulation is not enabled.");
 918         return false;
 919     }
 920
 921     try {
 922         _ambassador->disableTimeRegulation();
 923         _federateAmbassador->_timeRegulationEnabled = false;
 924     } catch (RTI::TimeRegulationWasNotEnabled& e) {
 925         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 926         return false;
 927     } catch (RTI::ConcurrentAccessAttempted& e) {
 928         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 929         return false;
 930     } catch (RTI::FederateNotExecutionMember& e) {
 931         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 932         return false;
 933     } catch (RTI::SaveInProgress& e) {
 934         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 935         return false;
 936     } catch (RTI::RestoreInProgress& e) {
 937         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 938         return false;
 939     } catch (RTI::RTIinternalError& e) {
 940         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 941         return false;
 942     }
 943
 944     return true;
 945 }
 946
 947 bool
 948 RTI13Federate::modifyLookahead(const SGTimeStamp& timeStamp)
 949 {
 950     if (!_ambassador.valid()) {
 951         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead.");
 952         return false;
 953     }
 954     try {
 955         _ambassador->modifyLookahead(timeStamp);
 956     } catch (RTI::InvalidLookahead& e) {
 957         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
 958         return false;
 959     } catch (RTI::FederateNotExecutionMember& e) {
 960         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
 961         return false;
 962     } catch (RTI::ConcurrentAccessAttempted& e) {
 963         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
 964         return false;
 965     } catch (RTI::SaveInProgress& e) {
 966         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
 967         return false;
 968     } catch (RTI::RestoreInProgress& e) {
 969         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
 970         return false;
 971     } catch (RTI::RTIinternalError& e) {
 972         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
 973         return false;
 974     }
 975     return true;
 976 }
 977
 978 bool
 979 RTI13Federate::getTimeRegulationEnabled()
 980 {
 981     return _federateAmbassador->_timeRegulationEnabled;
 982 }
 983
 984 bool
 985 RTI13Federate::timeAdvanceRequest(const SGTimeStamp& timeStamp)
 986 {
 987     if (!_ambassador.valid()) {
 988         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time regulation at unconnected federate.");
 989         return false;
 990     }
 991
 992     try {
 993         _ambassador->timeAdvanceRequest(timeStamp);
 994         _federateAmbassador->_timeAdvancePending = true;
 995     } catch (RTI::InvalidFederationTime& e) {
 996         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 997         return false;
 998     } catch (RTI::FederationTimeAlreadyPassed& e) {
 999         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1000         return false;
1001     } catch (RTI::TimeAdvanceAlreadyInProgress& e) {
1002         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1003         return false;
1004     } catch (RTI::EnableTimeRegulationPending& e) {
1005         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1006         return false;
1007     } catch (RTI::EnableTimeConstrainedPending& e) {
1008         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1009         return false;
1010     } catch (RTI::FederateNotExecutionMember& e) {
1011         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1012         return false;
1013     } catch (RTI::ConcurrentAccessAttempted& e) {
1014         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1015         return false;
1016     } catch (RTI::SaveInProgress& e) {
1017         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1018         return false;
1019     } catch (RTI::RestoreInProgress& e) {
1020         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1021         return false;
1022     } catch (RTI::RTIinternalError& e) {
1023         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1024         return false;
1025     }
1026
1027     return true;
1028 }
1029
1030 bool
1031 RTI13Federate::timeAdvanceRequestAvailable(const SGTimeStamp& timeStamp)
1032 {
1033     if (!_ambassador.valid()) {
1034         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time regulation at unconnected federate.");
1035         return false;
1036     }
1037
1038     try {
1039         _ambassador->timeAdvanceRequestAvailable(timeStamp);
1040         _federateAmbassador->_timeAdvancePending = true;
1041     } catch (RTI::InvalidFederationTime& e) {
1042         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1043         return false;
1044     } catch (RTI::FederationTimeAlreadyPassed& e) {
1045         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1046         return false;
1047     } catch (RTI::TimeAdvanceAlreadyInProgress& e) {
1048         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1049         return false;
1050     } catch (RTI::EnableTimeRegulationPending& e) {
1051         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1052         return false;
1053     } catch (RTI::EnableTimeConstrainedPending& e) {
1054         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1055         return false;
1056     } catch (RTI::FederateNotExecutionMember& e) {
1057         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1058         return false;
1059     } catch (RTI::ConcurrentAccessAttempted& e) {
1060         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1061         return false;
1062     } catch (RTI::SaveInProgress& e) {
1063         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1064         return false;
1065     } catch (RTI::RestoreInProgress& e) {
1066         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1067         return false;
1068     } catch (RTI::RTIinternalError& e) {
1069         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1070         return false;
1071     }
1072
1073     return true;
1074 }
1075
1076 bool
1077 RTI13Federate::getTimeAdvancePending()
1078 {
1079     return _federateAmbassador->_timeAdvancePending;
1080 }
1081
1082 bool
1083 RTI13Federate::queryFederateTime(SGTimeStamp& timeStamp)
1084 {
1085     if (!_ambassador.valid()) {
1086         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time.");
1087         return false;
1088     }
1089
1090     try {
1091         _ambassador->queryFederateTime(timeStamp);
1092     } catch (RTI::FederateNotExecutionMember& e) {
1093         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time: " << e._name << " " << e._reason);
1094         return false;
1095     } catch (RTI::ConcurrentAccessAttempted& e) {
1096         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time: " << e._name << " " << e._reason);
1097         return false;
1098     } catch (RTI::SaveInProgress& e) {
1099         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time: " << e._name << " " << e._reason);
1100         return false;
1101     } catch (RTI::RestoreInProgress& e) {
1102         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time: " << e._name << " " << e._reason);
1103         return false;
1104     } catch (RTI::RTIinternalError& e) {
1105         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time: " << e._name << " " << e._reason);
1106         return false;
1107     }
1108     return true;
1109 }
1110
1111 bool
1112 RTI13Federate::queryLookahead(SGTimeStamp& timeStamp)
1113 {
1114     if (!_ambassador.valid()) {
1115         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead.");
1116         return false;
1117     }
1118
1119     try {
1120         _ambassador->queryLookahead(timeStamp);
1121     } catch (RTI::FederateNotExecutionMember& e) {
1122         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead: " << e._name << " " << e._reason);
1123         return false;
1124     } catch (RTI::ConcurrentAccessAttempted& e) {
1125         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead: " << e._name << " " << e._reason);
1126         return false;
1127     } catch (RTI::SaveInProgress& e) {
1128         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead: " << e._name << " " << e._reason);
1129         return false;
1130     } catch (RTI::RestoreInProgress& e) {
1131         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead: " << e._name << " " << e._reason);
1132         return false;
1133     } catch (RTI::RTIinternalError& e) {
1134         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead: " << e._name << " " << e._reason);
1135         return false;
1136     }
1137     return true;
1138 }
1139
1140 bool
1141 RTI13Federate::queryGALT(SGTimeStamp& timeStamp)
1142 {
1143     if (!_ambassador.valid()) {
1144         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT.");
1145         return false;
1146     }
1147
1148     try {
1149         return _ambassador->queryGALT(timeStamp);
1150     } catch (RTI::FederateNotExecutionMember& e) {
1151         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT: " << e._name << " " << e._reason);
1152         return false;
1153     } catch (RTI::ConcurrentAccessAttempted& e) {
1154         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT: " << e._name << " " << e._reason);
1155         return false;
1156     } catch (RTI::SaveInProgress& e) {
1157         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT: " << e._name << " " << e._reason);
1158         return false;
1159     } catch (RTI::RestoreInProgress& e) {
1160         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT: " << e._name << " " << e._reason);
1161         return false;
1162     } catch (RTI::RTIinternalError& e) {
1163         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT: " << e._name << " " << e._reason);
1164         return false;
1165     }
1166     return true;
1167 }
1168
1169 bool
1170 RTI13Federate::queryLITS(SGTimeStamp& timeStamp)
1171 {
1172     if (!_ambassador.valid()) {
1173         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS.");
1174         return false;
1175     }
1176
1177     try {
1178         return _ambassador->queryLITS(timeStamp);
1179     } catch (RTI::FederateNotExecutionMember& e) {
1180         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS: " << e._name << " " << e._reason);
1181         return false;
1182     } catch (RTI::ConcurrentAccessAttempted& e) {
1183         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS: " << e._name << " " << e._reason);
1184         return false;
1185     } catch (RTI::SaveInProgress& e) {
1186         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS: " << e._name << " " << e._reason);
1187         return false;
1188     } catch (RTI::RestoreInProgress& e) {
1189         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS: " << e._name << " " << e._reason);
1190         return false;
1191     } catch (RTI::RTIinternalError& e) {
1192         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS: " << e._name << " " << e._reason);
1193         return false;
1194     }
1195     return true;
1196 }
1197
1198 bool
1199 RTI13Federate::processMessage()
1200 {
1201     bool result = _ambassador->tick();
1202     _federateAmbassador->processQueues();
1203     return result;
1204 }
1205
1206 bool
1207 RTI13Federate::processMessages(const double& minimum, const double& maximum)
1208 {
1209     bool result = _ambassador->tick(minimum, 0);
1210     _federateAmbassador->processQueues();
1211     if (!result)
1212         return false;
1213     SGTimeStamp timeStamp = SGTimeStamp::now() + SGTimeStamp::fromSec(maximum);
1214     do {
1215         result = _ambassador->tick(0, 0);
1216         _federateAmbassador->processQueues();
1217     } while (result && SGTimeStamp::now() <= timeStamp);
1218     return result;
1219 }
1220
1221 RTI13ObjectClass*
1222 RTI13Federate::createObjectClass(const std::string& objectClassName, HLAObjectClass* hlaObjectClass)
1223 {
1224     try {
1225         RTI::ObjectClassHandle objectClassHandle;
1226         objectClassHandle = _ambassador->getObjectClassHandle(objectClassName);
1227         if (_federateAmbassador->_objectClassMap.find(objectClassHandle) != _federateAmbassador->_objectClassMap.end()) {
1228             SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create object class, object class already exists!");
1229             return 0;
1230         }
1231         RTI13ObjectClass* rtiObjectClass;
1232         rtiObjectClass = new RTI13ObjectClass(hlaObjectClass, objectClassHandle, _ambassador.get());
1233         _federateAmbassador->_objectClassMap[objectClassHandle] = rtiObjectClass;
1234         return rtiObjectClass;
1235     } catch (RTI::NameNotFound& e) {
1236         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1237         return 0;
1238     } catch (RTI::FederateNotExecutionMember& e) {
1239         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1240         return 0;
1241     } catch (RTI::ConcurrentAccessAttempted& e) {
1242         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1243         return 0;
1244     } catch (RTI::RTIinternalError& e) {
1245         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1246         return 0;
1247     }
1248 }
1249
1250 RTI13ObjectInstance*
1251 RTI13Federate::getObjectInstance(const std::string& objectInstanceName)
1252 {
1253     try {
1254         RTI::ObjectHandle objectHandle;
1255         objectHandle = _ambassador->getObjectInstanceHandle(objectInstanceName);
1256         FederateAmbassador::ObjectInstanceMap::iterator i = _federateAmbassador->_objectInstanceMap.find(objectHandle);
1257         if (i == _federateAmbassador->_objectInstanceMap.end()) {
1258             SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: ObjectInstance not found.");
1259             return 0;
1260         }
1261         return i->second;
1262     } catch (RTI::ObjectNotKnown& e) {
1263         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1264         return 0;
1265     } catch (RTI::FederateNotExecutionMember& e) {
1266         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1267         return 0;
1268     } catch (RTI::ConcurrentAccessAttempted& e) {
1269         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1270         return 0;
1271     } catch (RTI::RTIinternalError& e) {
1272         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1273         return 0;
1274     }
1275 }
1276
1277 void
1278 RTI13Federate::insertObjectInstance(RTI13ObjectInstance* objectInstance)
1279 {
1280     _federateAmbassador->_objectInstanceMap[objectInstance->getHandle()] = objectInstance;
1281 }
1282
1283 }