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     _tickTimeout(10),
 583     _ambassador(new RTI13Ambassador),
 584     _federateAmbassador(new FederateAmbassador)
 585 {
 586     _ambassador->_federate = this;
 587     _federateAmbassador->_rtiAmbassador = _ambassador;
 588     if (stringList.empty()) {
 589         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Ignoring non empty connect arguments while connecting to an RTI13 federation!");
 590     }
 591 }
 592
 593 RTI13Federate::~RTI13Federate()
 594 {
 595     if (_joined)
 596         _ambassador->resignFederationExecution();
 597     delete _federateAmbassador;
 598 }
 599
 600 bool
 601 RTI13Federate::createFederationExecution(const std::string& federationName, const std::string& objectModel)
 602 {
 603     try {
 604         _ambassador->createFederationExecution(federationName, objectModel);
 605         return true;
 606     } catch (RTI::FederationExecutionAlreadyExists& e) {
 607         return true;
 608     } catch (RTI::CouldNotOpenFED& e) {
 609         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create federation execution: " << e._name << " " << e._reason);
 610         return false;
 611     } catch (RTI::ErrorReadingFED& e) {
 612         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create federation execution: " << e._name << " " << e._reason);
 613         return false;
 614     } catch (RTI::ConcurrentAccessAttempted& e) {
 615         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create federation execution: " << e._name << " " << e._reason);
 616         return false;
 617     } catch (RTI::RTIinternalError& e) {
 618         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create federation execution: " << e._name << " " << e._reason);
 619         return false;
 620     }
 621 }
 622
 623 bool
 624 RTI13Federate::destroyFederationExecution(const std::string& federation)
 625 {
 626     try {
 627         _ambassador->destroyFederationExecution(federation);
 628         return true;
 629     } catch (RTI::FederatesCurrentlyJoined& e) {
 630         return true;
 631     } catch (RTI::FederationExecutionDoesNotExist& e) {
 632         return true;
 633     } catch (RTI::ConcurrentAccessAttempted& e) {
 634         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not destroy federation execution: " << e._name << " " << e._reason);
 635         return false;
 636     } catch (RTI::RTIinternalError& e) {
 637         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not destroy federation execution: " << e._name << " " << e._reason);
 638         return false;
 639     }
 640 }
 641
 642 bool
 643 RTI13Federate::join(const std::string& federateType, const std::string& federationName)
 644 {
 645     try {
 646         _federateHandle = _ambassador->joinFederationExecution(federateType, federationName, _federateAmbassador);
 647         SG_LOG(SG_NETWORK, SG_INFO, "RTI: Joined federation \""
 648                << federationName << "\" as \"" << federateType << "\"");
 649         setFederateType(federateType);
 650         setFederationName(federationName);
 651         _joined = true;
 652         return true;
 653     } catch (RTI::FederateAlreadyExecutionMember& e) {
 654         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
 655         return false;
 656     } catch (RTI::FederationExecutionDoesNotExist& e) {
 657         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
 658         return false;
 659     } catch (RTI::CouldNotOpenFED& e) {
 660         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
 661         return false;
 662     } catch (RTI::ErrorReadingFED& e) {
 663         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
 664         return false;
 665     } catch (RTI::ConcurrentAccessAttempted& e) {
 666         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
 667         return false;
 668     } catch (RTI::SaveInProgress& e) {
 669         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
 670         return false;
 671     } catch (RTI::RestoreInProgress& e) {
 672         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
 673         return false;
 674     } catch (RTI::RTIinternalError& e) {
 675         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
 676         return false;
 677     }
 678 }
 679
 680 bool
 681 RTI13Federate::resign()
 682 {
 683     try {
 684         _ambassador->resignFederationExecution();
 685         SG_LOG(SG_NETWORK, SG_INFO, "RTI: Resigned from federation.");
 686         _joined = false;
 687         _federateHandle = -1;
 688         return true;
 689     } catch (RTI::FederateOwnsAttributes& e) {
 690         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 691         return false;
 692     } catch (RTI::FederateNotExecutionMember& e) {
 693         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 694         return false;
 695     } catch (RTI::InvalidResignAction& e) {
 696         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 697         return false;
 698     } catch (RTI::ConcurrentAccessAttempted& e) {
 699         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 700         return false;
 701     } catch (RTI::RTIinternalError& e) {
 702         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 703         return false;
 704     }
 705 }
 706
 707 bool
 708 RTI13Federate::registerFederationSynchronizationPoint(const std::string& label, const RTIData& tag)
 709 {
 710     try {
 711         _ambassador->registerFederationSynchronizationPoint(label, tag);
 712         SG_LOG(SG_NETWORK, SG_INFO, "RTI: registerFederationSynchronizationPoint(" << label << ", tag )");
 713         return true;
 714     } catch (RTI::FederateNotExecutionMember& 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::ConcurrentAccessAttempted& 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::SaveInProgress& 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::RestoreInProgress& 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::RTIinternalError& e) {
 727         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not register federation synchronization point: " << e._name << " " << e._reason);
 728         return false;
 729     }
 730 }
 731
 732 bool
 733 RTI13Federate::waitForFederationSynchronizationPointAnnounced(const std::string& label)
 734 {
 735     while (!_federateAmbassador->getFederationSynchronizationPointAnnounced(label)) {
 736         _ambassador->tick(_tickTimeout, 0);
 737         _federateAmbassador->processQueues();
 738     }
 739     return true;
 740 }
 741
 742 bool
 743 RTI13Federate::synchronizationPointAchieved(const std::string& label)
 744 {
 745     try {
 746         _ambassador->synchronizationPointAchieved(label);
 747         SG_LOG(SG_NETWORK, SG_INFO, "RTI: synchronizationPointAchieved(" << label << ")");
 748         return true;
 749     } catch (RTI::SynchronizationPointLabelWasNotAnnounced& e) {
 750         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
 751         return false;
 752     } catch (RTI::FederateNotExecutionMember& e) {
 753         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
 754         return false;
 755     } catch (RTI::ConcurrentAccessAttempted& e) {
 756         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
 757         return false;
 758     } catch (RTI::SaveInProgress& e) {
 759         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
 760         return false;
 761     } catch (RTI::RestoreInProgress& e) {
 762         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
 763         return false;
 764     } catch (RTI::RTIinternalError& e) {
 765         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
 766         return false;
 767     }
 768 }
 769
 770 bool
 771 RTI13Federate::waitForFederationSynchronized(const std::string& label)
 772 {
 773     while (!_federateAmbassador->getFederationSynchronized(label)) {
 774         _ambassador->tick(_tickTimeout, 0);
 775         _federateAmbassador->processQueues();
 776     }
 777     return true;
 778 }
 779
 780 bool
 781 RTI13Federate::enableTimeConstrained()
 782 {
 783     if (!_ambassador.valid()) {
 784         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time constrained at unconnected federate.");
 785         return false;
 786     }
 787
 788     if (_federateAmbassador->_timeConstrainedEnabled) {
 789         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Time constrained is already enabled.");
 790         return false;
 791     }
 792
 793     try {
 794         _ambassador->enableTimeConstrained();
 795     } catch (RTI::TimeConstrainedAlreadyEnabled& e) {
 796         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 797         return false;
 798     } catch (RTI::EnableTimeConstrainedPending& e) {
 799         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 800         return false;
 801     } catch (RTI::TimeAdvanceAlreadyInProgress& e) {
 802         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 803         return false;
 804     } catch (RTI::ConcurrentAccessAttempted& e) {
 805         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 806         return false;
 807     } catch (RTI::FederateNotExecutionMember& e) {
 808         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 809         return false;
 810     } catch (RTI::SaveInProgress& e) {
 811         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 812         return false;
 813     } catch (RTI::RestoreInProgress& e) {
 814         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 815         return false;
 816     } catch (RTI::RTIinternalError& e) {
 817         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 818         return false;
 819     }
 820
 821     while (!_federateAmbassador->_timeConstrainedEnabled) {
 822         _ambassador->tick(_tickTimeout, 0);
 823         _federateAmbassador->processQueues();
 824     }
 825
 826     return true;
 827 }
 828
 829 bool
 830 RTI13Federate::disableTimeConstrained()
 831 {
 832     if (!_ambassador.valid()) {
 833         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time constrained at unconnected federate.");
 834         return false;
 835     }
 836
 837     if (!_federateAmbassador->_timeConstrainedEnabled) {
 838         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Time constrained is not enabled.");
 839         return false;
 840     }
 841
 842     try {
 843         _ambassador->disableTimeConstrained();
 844         _federateAmbassador->_timeConstrainedEnabled = false;
 845     } catch (RTI::TimeConstrainedWasNotEnabled& e) {
 846         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 847         return false;
 848     } catch (RTI::FederateNotExecutionMember& e) {
 849         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 850         return false;
 851     } catch (RTI::ConcurrentAccessAttempted& e) {
 852         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 853         return false;
 854     } catch (RTI::SaveInProgress& e) {
 855         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 856         return false;
 857     } catch (RTI::RestoreInProgress& e) {
 858         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 859         return false;
 860     } catch (RTI::RTIinternalError& e) {
 861         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 862         return false;
 863     }
 864
 865     return true;
 866 }
 867
 868 bool
 869 RTI13Federate::enableTimeRegulation(const SGTimeStamp& lookahead)
 870 {
 871     if (!_ambassador.valid()) {
 872         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time regulation at unconnected federate.");
 873         return false;
 874     }
 875
 876     if (_federateAmbassador->_timeRegulationEnabled) {
 877         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Time regulation already enabled.");
 878         return false;
 879     }
 880
 881     try {
 882         _ambassador->enableTimeRegulation(SGTimeStamp(), lookahead);
 883     } catch (RTI::TimeRegulationAlreadyEnabled& e) {
 884         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 885         return false;
 886     } catch (RTI::EnableTimeRegulationPending& e) {
 887         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 888         return false;
 889     } catch (RTI::TimeAdvanceAlreadyInProgress& e) {
 890         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 891         return false;
 892     } catch (RTI::InvalidFederationTime& e) {
 893         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 894         return false;
 895     } catch (RTI::InvalidLookahead& e) {
 896         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 897         return false;
 898     } catch (RTI::ConcurrentAccessAttempted& e) {
 899         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 900         return false;
 901     } catch (RTI::FederateNotExecutionMember& e) {
 902         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 903         return false;
 904     } catch (RTI::SaveInProgress& e) {
 905         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 906         return false;
 907     } catch (RTI::RestoreInProgress& e) {
 908         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 909         return false;
 910     } catch (RTI::RTIinternalError& e) {
 911         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 912         return false;
 913     }
 914
 915     while (!_federateAmbassador->_timeRegulationEnabled) {
 916         _ambassador->tick(_tickTimeout, 0);
 917         _federateAmbassador->processQueues();
 918     }
 919
 920     return true;
 921 }
 922
 923 bool
 924 RTI13Federate::disableTimeRegulation()
 925 {
 926     if (!_ambassador.valid()) {
 927         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time regulation at unconnected federate.");
 928         return false;
 929     }
 930
 931     if (!_federateAmbassador->_timeRegulationEnabled) {
 932         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Time regulation is not enabled.");
 933         return false;
 934     }
 935
 936     try {
 937         _ambassador->disableTimeRegulation();
 938         _federateAmbassador->_timeRegulationEnabled = false;
 939     } catch (RTI::TimeRegulationWasNotEnabled& e) {
 940         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 941         return false;
 942     } catch (RTI::ConcurrentAccessAttempted& e) {
 943         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 944         return false;
 945     } catch (RTI::FederateNotExecutionMember& e) {
 946         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 947         return false;
 948     } catch (RTI::SaveInProgress& e) {
 949         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 950         return false;
 951     } catch (RTI::RestoreInProgress& e) {
 952         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 953         return false;
 954     } catch (RTI::RTIinternalError& e) {
 955         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 956         return false;
 957     }
 958
 959     return true;
 960 }
 961
 962 bool
 963 RTI13Federate::timeAdvanceRequestBy(const SGTimeStamp& dt)
 964 {
 965     if (!_ambassador.valid()) {
 966         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time regulation at unconnected federate.");
 967         return false;
 968     }
 969
 970     SGTimeStamp fedTime = _federateAmbassador->_federateTime + dt;
 971     return timeAdvanceRequest(fedTime);
 972 }
 973
 974 bool
 975 RTI13Federate::timeAdvanceRequest(const SGTimeStamp& fedTime)
 976 {
 977     if (!_ambassador.valid()) {
 978         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time regulation at unconnected federate.");
 979         return false;
 980     }
 981
 982     try {
 983         _ambassador->timeAdvanceRequest(fedTime);
 984         _federateAmbassador->_timeAdvancePending = true;
 985     } catch (RTI::InvalidFederationTime& e) {
 986         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 987         return false;
 988     } catch (RTI::FederationTimeAlreadyPassed& e) {
 989         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 990         return false;
 991     } catch (RTI::TimeAdvanceAlreadyInProgress& e) {
 992         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 993         return false;
 994     } catch (RTI::EnableTimeRegulationPending& e) {
 995         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 996         return false;
 997     } catch (RTI::EnableTimeConstrainedPending& e) {
 998         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 999         return false;
1000     } catch (RTI::FederateNotExecutionMember& e) {
1001         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1002         return false;
1003     } catch (RTI::ConcurrentAccessAttempted& e) {
1004         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1005         return false;
1006     } catch (RTI::SaveInProgress& e) {
1007         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1008         return false;
1009     } catch (RTI::RestoreInProgress& e) {
1010         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1011         return false;
1012     } catch (RTI::RTIinternalError& e) {
1013         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1014         return false;
1015     }
1016
1017     while (_federateAmbassador->_timeAdvancePending) {
1018         _ambassador->tick(_tickTimeout, 0);
1019         _federateAmbassador->processQueues();
1020     }
1021
1022     return true;
1023 }
1024
1025 bool
1026 RTI13Federate::queryFederateTime(SGTimeStamp& timeStamp)
1027 {
1028     if (!_ambassador.valid()) {
1029         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time.");
1030         return false;
1031     }
1032
1033     try {
1034         _ambassador->queryFederateTime(timeStamp);
1035     } catch (RTI::FederateNotExecutionMember& e) {
1036         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time: " << e._name << " " << e._reason);
1037         return false;
1038     } catch (RTI::ConcurrentAccessAttempted& e) {
1039         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time: " << e._name << " " << e._reason);
1040         return false;
1041     } catch (RTI::SaveInProgress& e) {
1042         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time: " << e._name << " " << e._reason);
1043         return false;
1044     } catch (RTI::RestoreInProgress& e) {
1045         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time: " << e._name << " " << e._reason);
1046         return false;
1047     } catch (RTI::RTIinternalError& e) {
1048         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time: " << e._name << " " << e._reason);
1049         return false;
1050     }
1051     return true;
1052 }
1053
1054 bool
1055 RTI13Federate::modifyLookahead(const SGTimeStamp& timeStamp)
1056 {
1057     if (!_ambassador.valid()) {
1058         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead.");
1059         return false;
1060     }
1061     try {
1062         _ambassador->modifyLookahead(timeStamp);
1063     } catch (RTI::InvalidLookahead& e) {
1064         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
1065         return false;
1066     } catch (RTI::FederateNotExecutionMember& e) {
1067         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
1068         return false;
1069     } catch (RTI::ConcurrentAccessAttempted& e) {
1070         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
1071         return false;
1072     } catch (RTI::SaveInProgress& e) {
1073         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
1074         return false;
1075     } catch (RTI::RestoreInProgress& e) {
1076         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
1077         return false;
1078     } catch (RTI::RTIinternalError& e) {
1079         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
1080         return false;
1081     }
1082     return true;
1083 }
1084
1085 bool
1086 RTI13Federate::queryLookahead(SGTimeStamp& timeStamp)
1087 {
1088     if (!_ambassador.valid()) {
1089         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead.");
1090         return false;
1091     }
1092
1093     try {
1094         _ambassador->queryLookahead(timeStamp);
1095     } catch (RTI::FederateNotExecutionMember& e) {
1096         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead: " << e._name << " " << e._reason);
1097         return false;
1098     } catch (RTI::ConcurrentAccessAttempted& e) {
1099         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead: " << e._name << " " << e._reason);
1100         return false;
1101     } catch (RTI::SaveInProgress& e) {
1102         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead: " << e._name << " " << e._reason);
1103         return false;
1104     } catch (RTI::RestoreInProgress& e) {
1105         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead: " << e._name << " " << e._reason);
1106         return false;
1107     } catch (RTI::RTIinternalError& e) {
1108         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead: " << e._name << " " << e._reason);
1109         return false;
1110     }
1111     return true;
1112 }
1113
1114 bool
1115 RTI13Federate::tick()
1116 {
1117     bool result = _ambassador->tick();
1118     _federateAmbassador->processQueues();
1119     return result;
1120 }
1121
1122 bool
1123 RTI13Federate::tick(const double& minimum, const double& maximum)
1124 {
1125     bool result = _ambassador->tick(minimum, maximum);
1126     _federateAmbassador->processQueues();
1127     return result;
1128 }
1129
1130 RTI13ObjectClass*
1131 RTI13Federate::createObjectClass(const std::string& objectClassName, HLAObjectClass* hlaObjectClass)
1132 {
1133     try {
1134         RTI::ObjectClassHandle objectClassHandle;
1135         objectClassHandle = _ambassador->getObjectClassHandle(objectClassName);
1136         if (_federateAmbassador->_objectClassMap.find(objectClassHandle) != _federateAmbassador->_objectClassMap.end()) {
1137             SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create object class, object class already exists!");
1138             return 0;
1139         }
1140         RTI13ObjectClass* rtiObjectClass;
1141         rtiObjectClass = new RTI13ObjectClass(hlaObjectClass, objectClassHandle, _ambassador.get());
1142         _federateAmbassador->_objectClassMap[objectClassHandle] = rtiObjectClass;
1143         return rtiObjectClass;
1144     } catch (RTI::NameNotFound& e) {
1145         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1146         return 0;
1147     } catch (RTI::FederateNotExecutionMember& e) {
1148         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1149         return 0;
1150     } catch (RTI::ConcurrentAccessAttempted& e) {
1151         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1152         return 0;
1153     } catch (RTI::RTIinternalError& e) {
1154         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1155         return 0;
1156     }
1157 }
1158
1159 RTI13ObjectInstance*
1160 RTI13Federate::getObjectInstance(const std::string& objectInstanceName)
1161 {
1162     try {
1163         RTI::ObjectHandle objectHandle;
1164         objectHandle = _ambassador->getObjectInstanceHandle(objectInstanceName);
1165         FederateAmbassador::ObjectInstanceMap::iterator i = _federateAmbassador->_objectInstanceMap.find(objectHandle);
1166         if (i == _federateAmbassador->_objectInstanceMap.end()) {
1167             SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: ObjectInstance not found.");
1168             return 0;
1169         }
1170         return i->second;
1171     } catch (RTI::ObjectNotKnown& e) {
1172         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1173         return 0;
1174     } catch (RTI::FederateNotExecutionMember& e) {
1175         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1176         return 0;
1177     } catch (RTI::ConcurrentAccessAttempted& e) {
1178         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1179         return 0;
1180     } catch (RTI::RTIinternalError& e) {
1181         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1182         return 0;
1183     }
1184 }
1185
1186 void
1187 RTI13Federate::insertObjectInstance(RTI13ObjectInstance* objectInstance)
1188 {
1189     _federateAmbassador->_objectInstanceMap[objectInstance->getHandle()] = objectInstance;
1190 }
1191
1192 }