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     /// Generic callback to execute some notification on objects in a way that they are not prone to
  45     /// ConcurrentAccess exceptions.
  46     class QueueCallback : public SGReferenced {
  47     public:
  48         virtual ~QueueCallback() {}
  49         virtual void operator()(FederateAmbassador& self) = 0;
  50     };
  51     class TagQueueCallback : public QueueCallback {
  52     public:
  53         TagQueueCallback(const char* tag)
  54         {
  55             if (tag)
  56                 _tag.setData(tag, std::strlen(tag) + 1);
  57             else
  58                 _tag.setData("", 1);
  59         }
  60         virtual ~TagQueueCallback()
  61         { }
  62         RTIData _tag;
  63     };
  64
  65     /// RTI federate ambassador callback functions.
  66     virtual void synchronizationPointRegistrationSucceeded(const char* label)
  67         throw (RTI::FederateInternalError)
  68     {
  69     }
  70
  71     virtual void synchronizationPointRegistrationFailed(const char* label)
  72         throw (RTI::FederateInternalError)
  73     {
  74     }
  75
  76     virtual void announceSynchronizationPoint(const char* label, const char* tag)
  77         throw (RTI::FederateInternalError)
  78     {
  79         _pendingSyncLabels.insert(toStdString(label));
  80     }
  81
  82     virtual void federationSynchronized(const char* label)
  83         throw (RTI::FederateInternalError)
  84     {
  85         std::string s = toStdString(label);
  86         _pendingSyncLabels.erase(s);
  87         _syncronizedSyncLabels.insert(s);
  88     }
  89
  90     virtual void initiateFederateSave(const char* label)
  91         throw (RTI::UnableToPerformSave,
  92                RTI::FederateInternalError)
  93     {
  94     }
  95
  96     virtual void federationSaved()
  97         throw (RTI::FederateInternalError)
  98     {
  99     }
 100
 101     virtual void federationNotSaved()
 102         throw (RTI::FederateInternalError)
 103     {
 104     }
 105
 106     virtual void requestFederationRestoreSucceeded(const char* label)
 107         throw (RTI::FederateInternalError)
 108     {
 109     }
 110
 111     virtual void requestFederationRestoreFailed(const char* label, const char* reason)
 112         throw (RTI::FederateInternalError)
 113     {
 114     }
 115
 116     virtual void federationRestoreBegun()
 117         throw (RTI::FederateInternalError)
 118     {
 119     }
 120
 121     virtual void initiateFederateRestore(const char* label, RTI::FederateHandle federateHandle)
 122         throw (RTI::SpecifiedSaveLabelDoesNotExist,
 123                RTI::CouldNotRestore,
 124                RTI::FederateInternalError)
 125     {
 126     }
 127
 128     virtual void federationRestored()
 129         throw (RTI::FederateInternalError)
 130     {
 131     }
 132
 133     virtual void federationNotRestored()
 134         throw (RTI::FederateInternalError)
 135     {
 136     }
 137
 138     // Declaration Management
 139     class StartRegistrationForObjectClassCallback : public QueueCallback {
 140     public:
 141         StartRegistrationForObjectClassCallback(RTI::ObjectClassHandle objectClassHandle) :
 142             _objectClassHandle(objectClassHandle)
 143         { }
 144         virtual void operator()(FederateAmbassador& self)
 145         { self.startRegistrationForObjectClassCallback(_objectClassHandle); }
 146     private:
 147         RTI::ObjectClassHandle _objectClassHandle;
 148     };
 149     virtual void startRegistrationForObjectClass(RTI::ObjectClassHandle objectClassHandle)
 150         throw (RTI::ObjectClassNotPublished,
 151                RTI::FederateInternalError)
 152     { _queueCallbackList.push_back(new StartRegistrationForObjectClassCallback(objectClassHandle)); }
 153     void startRegistrationForObjectClassCallback(RTI::ObjectClassHandle objectClassHandle)
 154     {
 155         ObjectClassMap::iterator i = _objectClassMap.find(objectClassHandle);
 156         if (i == _objectClassMap.end())
 157             return;
 158         if (!i->second.valid())
 159             return;
 160         i->second->startRegistration();
 161     }
 162
 163     class StopRegistrationForObjectClassCallback : public QueueCallback {
 164     public:
 165         StopRegistrationForObjectClassCallback(RTI::ObjectClassHandle objectClassHandle) :
 166             _objectClassHandle(objectClassHandle)
 167         { }
 168         virtual void operator()(FederateAmbassador& self)
 169         { self.stopRegistrationForObjectClassCallback(_objectClassHandle); }
 170     private:
 171         RTI::ObjectClassHandle _objectClassHandle;
 172     };
 173     virtual void stopRegistrationForObjectClass(RTI::ObjectClassHandle objectClassHandle)
 174         throw (RTI::ObjectClassNotPublished,
 175                RTI::FederateInternalError)
 176     { _queueCallbackList.push_back(new StopRegistrationForObjectClassCallback(objectClassHandle)); }
 177     void stopRegistrationForObjectClassCallback(RTI::ObjectClassHandle objectClassHandle)
 178     {
 179         ObjectClassMap::iterator i = _objectClassMap.find(objectClassHandle);
 180         if (i == _objectClassMap.end())
 181             return;
 182         if (!i->second.valid())
 183             return;
 184         i->second->stopRegistration();
 185     }
 186
 187     virtual void turnInteractionsOn(RTI::InteractionClassHandle interactionClassHandle)
 188         throw (RTI::InteractionClassNotPublished,
 189                RTI::FederateInternalError)
 190     {
 191     }
 192
 193     virtual void turnInteractionsOff(RTI::InteractionClassHandle interactionClassHandle)
 194         throw (RTI::InteractionClassNotPublished,
 195                RTI::FederateInternalError)
 196     {
 197     }
 198
 199     // Object Management
 200     class DiscoverObjectCallback : public TagQueueCallback {
 201     public:
 202         DiscoverObjectCallback(RTI::ObjectHandle objectHandle, RTI::ObjectClassHandle objectClassHandle, const char *tag) :
 203             TagQueueCallback(tag),
 204             _objectHandle(objectHandle),
 205             _objectClassHandle(objectClassHandle)
 206         { }
 207         virtual void operator()(FederateAmbassador& self)
 208         { self.discoverObjectInstanceCallback(_objectHandle, _objectClassHandle, _tag); }
 209     private:
 210         RTI::ObjectHandle _objectHandle;
 211         RTI::ObjectClassHandle _objectClassHandle;
 212     };
 213     virtual void discoverObjectInstance(RTI::ObjectHandle objectHandle, RTI::ObjectClassHandle objectClassHandle, const char* tag)
 214         throw (RTI::CouldNotDiscover,
 215                RTI::ObjectClassNotKnown,
 216                RTI::FederateInternalError)
 217     { _queueCallbackList.push_back(new DiscoverObjectCallback(objectHandle, objectClassHandle, tag)); }
 218     void discoverObjectInstanceCallback(RTI::ObjectHandle objectHandle, RTI::ObjectClassHandle objectClassHandle, const RTIData& tag)
 219     {
 220         ObjectClassMap::iterator i = _objectClassMap.find(objectClassHandle);
 221         if (i == _objectClassMap.end())
 222             return;
 223         if (!i->second.valid())
 224             return;
 225         SGSharedPtr<RTI13ObjectInstance> objectInstance = new RTI13ObjectInstance(objectHandle, 0, i->second, _rtiAmbassador.get(), false);
 226         _objectInstanceMap[objectHandle] = objectInstance;
 227         i->second->discoverInstance(objectInstance.get(), tag);
 228     }
 229
 230     class ReflectAttributeValuesTimestampCallback : public TagQueueCallback {
 231     public:
 232         ReflectAttributeValuesTimestampCallback(RTI::ObjectHandle objectHandle,
 233                                                 RTI13AttributeHandleDataPairList& attributeHandleDataPairList,
 234                                                 const SGTimeStamp& timeStamp, const char *tag) :
 235             TagQueueCallback(tag),
 236             _objectHandle(objectHandle),
 237             _timeStamp(timeStamp)
 238         {
 239             _attributeHandleDataPairList.swap(attributeHandleDataPairList);
 240         }
 241         virtual void operator()(FederateAmbassador& self)
 242         {
 243             self.reflectAttributeValuesCallback(_objectHandle, _attributeHandleDataPairList, _timeStamp, _tag);
 244             self.freeAttributeHandleDataPairList(_attributeHandleDataPairList);
 245         }
 246     private:
 247         RTI::ObjectHandle _objectHandle;
 248         RTI13AttributeHandleDataPairList _attributeHandleDataPairList;
 249         SGTimeStamp _timeStamp;
 250     };
 251     virtual void reflectAttributeValues(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleValuePairSet& attributeValuePairSet,
 252                                         const RTI::FedTime& fedTime, const char* tag, RTI::EventRetractionHandle eventRetractionHandle)
 253         throw (RTI::ObjectNotKnown,
 254                RTI::AttributeNotKnown,
 255                RTI::FederateOwnsAttributes,
 256                RTI::InvalidFederationTime,
 257                RTI::FederateInternalError)
 258     {
 259         RTI13AttributeHandleDataPairList attributeHandleDataPairList;
 260
 261         RTI::ULong numAttribs = attributeValuePairSet.size();
 262         for (RTI::ULong i = 0; i < numAttribs; ++i) {
 263             appendAttributeHandleDataPair(attributeHandleDataPairList);
 264             attributeHandleDataPairList.back().first = attributeValuePairSet.getHandle(i);
 265             RTI::ULong length = attributeValuePairSet.getValueLength(i);
 266             attributeHandleDataPairList.back().second.resize(length);
 267             attributeValuePairSet.getValue(i, attributeHandleDataPairList.back().second.data(), length);
 268         }
 269
 270         _queueCallbackList.push_back(new ReflectAttributeValuesTimestampCallback(objectHandle, attributeHandleDataPairList,
 271                                                                                  RTI13Ambassador::toTimeStamp(fedTime), tag));
 272     }
 273     void reflectAttributeValuesCallback(RTI::ObjectHandle objectHandle, RTI13AttributeHandleDataPairList& attributeHandleDataPairList,
 274                                         const SGTimeStamp& timeStamp, const RTIData& tag)
 275     {
 276         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 277         if (i == _objectInstanceMap.end())
 278             return;
 279         if (!i->second.valid())
 280             return;
 281         i->second->reflectAttributeValues(attributeHandleDataPairList, timeStamp, tag);
 282     }
 283
 284     class ReflectAttributeValuesCallback : public TagQueueCallback {
 285     public:
 286         ReflectAttributeValuesCallback(RTI::ObjectHandle objectHandle, RTI13AttributeHandleDataPairList& attributeHandleDataPairList,
 287                                        const char *tag) :
 288             TagQueueCallback(tag),
 289             _objectHandle(objectHandle)
 290         {
 291             _attributeHandleDataPairList.swap(attributeHandleDataPairList);
 292         }
 293         virtual void operator()(FederateAmbassador& self)
 294         {
 295             self.reflectAttributeValuesCallback(_objectHandle, _attributeHandleDataPairList, _tag);
 296             self.freeAttributeHandleDataPairList(_attributeHandleDataPairList);
 297         }
 298     private:
 299         RTI::ObjectHandle _objectHandle;
 300         RTI13AttributeHandleDataPairList _attributeHandleDataPairList;
 301     };
 302     virtual void reflectAttributeValues(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleValuePairSet& attributeValuePairSet,
 303                                         const char* tag)
 304         throw (RTI::ObjectNotKnown,
 305                RTI::AttributeNotKnown,
 306                RTI::FederateOwnsAttributes,
 307                RTI::FederateInternalError)
 308     {
 309         RTI13AttributeHandleDataPairList attributeHandleDataPairList;
 310
 311         RTI::ULong numAttribs = attributeValuePairSet.size();
 312         for (RTI::ULong i = 0; i < numAttribs; ++i) {
 313             appendAttributeHandleDataPair(attributeHandleDataPairList);
 314             attributeHandleDataPairList.back().first = attributeValuePairSet.getHandle(i);
 315             RTI::ULong length = attributeValuePairSet.getValueLength(i);
 316             attributeHandleDataPairList.back().second.resize(length);
 317             attributeValuePairSet.getValue(i, attributeHandleDataPairList.back().second.data(), length);
 318         }
 319
 320         _queueCallbackList.push_back(new ReflectAttributeValuesCallback(objectHandle, attributeHandleDataPairList, tag));
 321     }
 322     void reflectAttributeValuesCallback(RTI::ObjectHandle objectHandle, RTI13AttributeHandleDataPairList& attributeHandleDataPairList,
 323                                         const RTIData& tag)
 324     {
 325         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 326         if (i == _objectInstanceMap.end())
 327             return;
 328         if (!i->second.valid())
 329             return;
 330         i->second->reflectAttributeValues(attributeHandleDataPairList, tag);
 331     }
 332
 333     virtual void receiveInteraction(RTI::InteractionClassHandle interactionClassHandle, const RTI::ParameterHandleValuePairSet& parameters,
 334                                     const RTI::FedTime& fedTime, const char* tag, RTI::EventRetractionHandle eventRetractionHandle)
 335         throw (RTI::InteractionClassNotKnown,
 336                RTI::InteractionParameterNotKnown,
 337                RTI::InvalidFederationTime,
 338                RTI::FederateInternalError)
 339     {
 340     }
 341
 342     virtual void receiveInteraction(RTI::InteractionClassHandle interactionClassHandle,
 343                                     const RTI::ParameterHandleValuePairSet& parameters, const char* tag)
 344         throw (RTI::InteractionClassNotKnown,
 345                RTI::InteractionParameterNotKnown,
 346                RTI::FederateInternalError)
 347     {
 348     }
 349
 350     class RemoveObjectTimestampCallback : public TagQueueCallback {
 351     public:
 352         RemoveObjectTimestampCallback(RTI::ObjectHandle objectHandle, const SGTimeStamp& timeStamp, const char* tag) :
 353             TagQueueCallback(tag),
 354             _objectHandle(objectHandle),
 355             _timeStamp(timeStamp)
 356         { }
 357         virtual void operator()(FederateAmbassador& self)
 358         { self.removeObjectInstanceCallback(_objectHandle, _timeStamp, _tag); }
 359     private:
 360         RTI::ObjectHandle _objectHandle;
 361         SGTimeStamp _timeStamp;
 362     };
 363     virtual void removeObjectInstance(RTI::ObjectHandle objectHandle, const RTI::FedTime& fedTime,
 364                                       const char* tag, RTI::EventRetractionHandle eventRetractionHandle)
 365         throw (RTI::ObjectNotKnown,
 366                RTI::InvalidFederationTime,
 367                RTI::FederateInternalError)
 368     { _queueCallbackList.push_back(new RemoveObjectTimestampCallback(objectHandle, RTI13Ambassador::toTimeStamp(fedTime), tag)); }
 369     void removeObjectInstanceCallback(RTI::ObjectHandle objectHandle, const SGTimeStamp& timeStamp, const RTIData& tag)
 370     {
 371         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 372         if (i == _objectInstanceMap.end())
 373             return;
 374         if (i->second.valid())
 375             i->second->removeInstance(tag);
 376         _objectInstanceMap.erase(i);
 377     }
 378
 379     class RemoveObjectCallback : public TagQueueCallback {
 380     public:
 381         RemoveObjectCallback(RTI::ObjectHandle objectHandle, const char* tag) :
 382             TagQueueCallback(tag),
 383             _objectHandle(objectHandle)
 384         { }
 385         virtual void operator()(FederateAmbassador& self)
 386         { self.removeObjectInstanceCallback(_objectHandle, _tag); }
 387     private:
 388         RTI::ObjectHandle _objectHandle;
 389     };
 390     virtual void removeObjectInstance(RTI::ObjectHandle objectHandle, const char* tag)
 391         throw (RTI::ObjectNotKnown,
 392                RTI::FederateInternalError)
 393     { _queueCallbackList.push_back(new RemoveObjectCallback(objectHandle, tag)); }
 394     void removeObjectInstanceCallback(RTI::ObjectHandle objectHandle, const RTIData& tag)
 395     {
 396         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 397         if (i == _objectInstanceMap.end())
 398             return;
 399         if (i->second.valid())
 400             i->second->removeInstance(tag);
 401         _objectInstanceMap.erase(i);
 402     }
 403
 404     class AttributeHandleSetCallback : public QueueCallback {
 405     public:
 406         AttributeHandleSetCallback(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributeHandleSet) :
 407             _objectHandle(objectHandle)
 408         {
 409             RTI::ULong numAttribs = attributeHandleSet.size();
 410             _attributes.reserve(numAttribs);
 411             for (RTI::ULong i = 0; i < numAttribs; ++i)
 412                 _attributes.push_back(attributeHandleSet.getHandle(i));
 413         }
 414     protected:
 415         RTI::ObjectHandle _objectHandle;
 416         std::vector<RTI::AttributeHandle> _attributes;
 417     };
 418     class AttributesInScopeCallback : public AttributeHandleSetCallback {
 419     public:
 420         AttributesInScopeCallback(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) :
 421             AttributeHandleSetCallback(objectHandle, attributes)
 422         { }
 423         virtual void operator()(FederateAmbassador& self)
 424         { self.attributesInScopeCallback(_objectHandle, _attributes); }
 425     };
 426     virtual void attributesInScope(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 427         throw (RTI::ObjectNotKnown,
 428                RTI::AttributeNotKnown,
 429                RTI::FederateInternalError)
 430     { _queueCallbackList.push_back(new AttributesInScopeCallback(objectHandle, attributes)); }
 431     void attributesInScopeCallback(RTI::ObjectHandle objectHandle, const std::vector<RTI::AttributeHandle>& attributes)
 432     {
 433         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 434         if (i == _objectInstanceMap.end())
 435             return;
 436         if (!i->second.valid())
 437             return;
 438         i->second->attributesInScope(attributes);
 439     }
 440
 441     class AttributesOutOfScopeCallback : public AttributeHandleSetCallback {
 442     public:
 443         AttributesOutOfScopeCallback(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) :
 444             AttributeHandleSetCallback(objectHandle, attributes)
 445         { }
 446         virtual void operator()(FederateAmbassador& self)
 447         { self.attributesOutOfScopeCallback(_objectHandle, _attributes); }
 448     };
 449     virtual void attributesOutOfScope(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 450         throw (RTI::ObjectNotKnown,
 451                RTI::AttributeNotKnown,
 452                RTI::FederateInternalError)
 453     { _queueCallbackList.push_back(new AttributesOutOfScopeCallback(objectHandle, attributes)); }
 454     void attributesOutOfScopeCallback(RTI::ObjectHandle objectHandle, const std::vector<RTI::AttributeHandle>& attributes)
 455     {
 456         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 457         if (i == _objectInstanceMap.end())
 458             return;
 459         if (!i->second.valid())
 460             return;
 461         i->second->attributesOutOfScope(attributes);
 462     }
 463
 464     class ProvideAttributeValueUpdateCallback : public AttributeHandleSetCallback {
 465     public:
 466         ProvideAttributeValueUpdateCallback(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) :
 467             AttributeHandleSetCallback(objectHandle, attributes)
 468         { }
 469         virtual void operator()(FederateAmbassador& self)
 470         { self.provideAttributeValueUpdateCallback(_objectHandle, _attributes); }
 471     };
 472     virtual void provideAttributeValueUpdate(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 473         throw (RTI::ObjectNotKnown,
 474                RTI::AttributeNotKnown,
 475                RTI::AttributeNotOwned,
 476                RTI::FederateInternalError)
 477     { _queueCallbackList.push_back(new ProvideAttributeValueUpdateCallback(objectHandle, attributes)); }
 478     void provideAttributeValueUpdateCallback(RTI::ObjectHandle objectHandle, const std::vector<RTI::AttributeHandle>& attributes)
 479     {
 480         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 481         if (i == _objectInstanceMap.end())
 482             return;
 483         if (!i->second.valid())
 484             return;
 485         i->second->provideAttributeValueUpdate(attributes);
 486     }
 487
 488     class TurnUpdatesOnForObjectInstanceCallback : public AttributeHandleSetCallback {
 489     public:
 490         TurnUpdatesOnForObjectInstanceCallback(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) :
 491             AttributeHandleSetCallback(objectHandle, attributes)
 492         { }
 493         virtual void operator()(FederateAmbassador& self)
 494         { self.turnUpdatesOnForObjectInstanceCallback(_objectHandle, _attributes); }
 495     };
 496     virtual void turnUpdatesOnForObjectInstance(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 497         throw (RTI::ObjectNotKnown,
 498                RTI::AttributeNotOwned,
 499                RTI::FederateInternalError)
 500     { _queueCallbackList.push_back(new TurnUpdatesOnForObjectInstanceCallback(objectHandle, attributes)); }
 501     void turnUpdatesOnForObjectInstanceCallback(RTI::ObjectHandle objectHandle, const std::vector<RTI::AttributeHandle>& attributes)
 502     {
 503         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 504         if (i == _objectInstanceMap.end())
 505             return;
 506         if (!i->second.valid())
 507             return;
 508         i->second->turnUpdatesOnForObjectInstance(attributes);
 509     }
 510
 511     class TurnUpdatesOffForObjectInstanceCallback : public AttributeHandleSetCallback {
 512     public:
 513         TurnUpdatesOffForObjectInstanceCallback(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) :
 514             AttributeHandleSetCallback(objectHandle, attributes)
 515         { }
 516         virtual void operator()(FederateAmbassador& self)
 517         { self.turnUpdatesOffForObjectInstanceCallback(_objectHandle, _attributes); }
 518     };
 519     virtual void turnUpdatesOffForObjectInstance(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 520         throw (RTI::ObjectNotKnown,
 521                RTI::AttributeNotOwned,
 522                RTI::FederateInternalError)
 523     { _queueCallbackList.push_back(new TurnUpdatesOffForObjectInstanceCallback(objectHandle, attributes)); }
 524     void turnUpdatesOffForObjectInstanceCallback(RTI::ObjectHandle objectHandle, const std::vector<RTI::AttributeHandle>& attributes)
 525     {
 526         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 527         if (i == _objectInstanceMap.end())
 528             return;
 529         if (!i->second.valid())
 530             return;
 531         i->second->turnUpdatesOffForObjectInstance(attributes);
 532     }
 533
 534     // Ownership Management
 535     class RequestAttributeOwnershipAssumptionCallback : public AttributeHandleSetCallback {
 536     public:
 537         RequestAttributeOwnershipAssumptionCallback(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes, const RTIData& tag) :
 538             AttributeHandleSetCallback(objectHandle, attributes),
 539             _tag(tag)
 540         { }
 541         virtual void operator()(FederateAmbassador& self)
 542         { self.requestAttributeOwnershipAssumptionCallback(_objectHandle, _attributes, _tag); }
 543     protected:
 544         RTIData _tag;
 545     };
 546     virtual void requestAttributeOwnershipAssumption(RTI::ObjectHandle objectHandle,
 547                                                      const RTI::AttributeHandleSet& attributes, const char* tag)
 548         throw (RTI::ObjectNotKnown,
 549                RTI::AttributeNotKnown,
 550                RTI::AttributeAlreadyOwned,
 551                RTI::AttributeNotPublished,
 552                RTI::FederateInternalError)
 553     { _queueCallbackList.push_back(new RequestAttributeOwnershipAssumptionCallback(objectHandle, attributes, tagToData(tag))); }
 554     void requestAttributeOwnershipAssumptionCallback(RTI::ObjectHandle objectHandle, std::vector<RTI::AttributeHandle>& attributes, const RTIData& tag)
 555     {
 556         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 557         if (i == _objectInstanceMap.end())
 558             return;
 559         if (!i->second.valid())
 560             return;
 561         i->second->requestAttributeOwnershipAssumption(attributes, tag);
 562     }
 563
 564     class AttributeOwnershipDivestitureNotificationCallback : public AttributeHandleSetCallback {
 565     public:
 566         AttributeOwnershipDivestitureNotificationCallback(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) :
 567             AttributeHandleSetCallback(objectHandle, attributes)
 568         { }
 569         virtual void operator()(FederateAmbassador& self)
 570         { self.attributeOwnershipDivestitureNotificationCallback(_objectHandle, _attributes); }
 571     };
 572     virtual void attributeOwnershipDivestitureNotification(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 573         throw (RTI::ObjectNotKnown,
 574                RTI::AttributeNotKnown,
 575                RTI::AttributeNotOwned,
 576                RTI::AttributeDivestitureWasNotRequested,
 577                RTI::FederateInternalError)
 578     { _queueCallbackList.push_back(new AttributeOwnershipDivestitureNotificationCallback(objectHandle, attributes)); }
 579     void attributeOwnershipDivestitureNotificationCallback(RTI::ObjectHandle objectHandle, const std::vector<RTI::AttributeHandle>& attributes)
 580     {
 581         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 582         if (i == _objectInstanceMap.end())
 583             return;
 584         if (!i->second.valid())
 585             return;
 586         i->second->attributeOwnershipDivestitureNotification(attributes);
 587     }
 588
 589     class AttributeOwnershipAcquisitionNotificationCallback : public AttributeHandleSetCallback {
 590     public:
 591         AttributeOwnershipAcquisitionNotificationCallback(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) :
 592             AttributeHandleSetCallback(objectHandle, attributes)
 593         { }
 594         virtual void operator()(FederateAmbassador& self)
 595         { self.attributeOwnershipAcquisitionNotificationCallback(_objectHandle, _attributes); }
 596     };
 597     virtual void attributeOwnershipAcquisitionNotification(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 598         throw (RTI::ObjectNotKnown,
 599                RTI::AttributeNotKnown,
 600                RTI::AttributeAcquisitionWasNotRequested,
 601                RTI::AttributeAlreadyOwned,
 602                RTI::AttributeNotPublished,
 603                RTI::FederateInternalError)
 604     { _queueCallbackList.push_back(new AttributeOwnershipAcquisitionNotificationCallback(objectHandle, attributes)); }
 605     void attributeOwnershipAcquisitionNotificationCallback(RTI::ObjectHandle objectHandle, const std::vector<RTI::AttributeHandle>& attributes)
 606     {
 607         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 608         if (i == _objectInstanceMap.end())
 609             return;
 610         if (!i->second.valid())
 611             return;
 612         i->second->attributeOwnershipAcquisitionNotification(attributes);
 613     }
 614
 615     class AttributeOwnershipUnavailableCallback : public AttributeHandleSetCallback {
 616     public:
 617         AttributeOwnershipUnavailableCallback(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) :
 618             AttributeHandleSetCallback(objectHandle, attributes)
 619         { }
 620         virtual void operator()(FederateAmbassador& self)
 621         { self.attributeOwnershipUnavailableCallback(_objectHandle, _attributes); }
 622     };
 623     virtual void attributeOwnershipUnavailable(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 624         throw (RTI::ObjectNotKnown,
 625                RTI::AttributeNotKnown,
 626                RTI::AttributeAlreadyOwned,
 627                RTI::AttributeAcquisitionWasNotRequested,
 628                RTI::FederateInternalError)
 629     { _queueCallbackList.push_back(new AttributeOwnershipUnavailableCallback(objectHandle, attributes)); }
 630     void attributeOwnershipUnavailableCallback(RTI::ObjectHandle objectHandle, const std::vector<RTI::AttributeHandle>& attributes)
 631     {
 632         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 633         if (i == _objectInstanceMap.end())
 634             return;
 635         if (!i->second.valid())
 636             return;
 637         i->second->attributeOwnershipUnavailable(attributes);
 638     }
 639
 640     class RequestAttributeOwnershipReleaseCallback : public AttributeHandleSetCallback {
 641     public:
 642         RequestAttributeOwnershipReleaseCallback(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes, const RTIData& tag) :
 643             AttributeHandleSetCallback(objectHandle, attributes),
 644             _tag(tag)
 645         { }
 646         virtual void operator()(FederateAmbassador& self)
 647         { self.requestAttributeOwnershipReleaseCallback(_objectHandle, _attributes, _tag); }
 648     protected:
 649         RTIData _tag;
 650     };
 651     virtual void requestAttributeOwnershipRelease(RTI::ObjectHandle objectHandle,
 652                                                   const RTI::AttributeHandleSet& attributes, const char* tag)
 653         throw (RTI::ObjectNotKnown,
 654                RTI::AttributeNotKnown,
 655                RTI::AttributeNotOwned,
 656                RTI::FederateInternalError)
 657     { _queueCallbackList.push_back(new RequestAttributeOwnershipReleaseCallback(objectHandle, attributes, tagToData(tag))); }
 658     void requestAttributeOwnershipReleaseCallback(RTI::ObjectHandle objectHandle, std::vector<RTI::AttributeHandle>& attributes, const RTIData& tag)
 659     {
 660         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 661         if (i == _objectInstanceMap.end())
 662             return;
 663         if (!i->second.valid())
 664             return;
 665         i->second->requestAttributeOwnershipRelease(attributes, tag);
 666     }
 667
 668     class ConfirmAttributeOwnershipAcquisitionCancellationCallback : public AttributeHandleSetCallback {
 669     public:
 670         ConfirmAttributeOwnershipAcquisitionCancellationCallback(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes) :
 671             AttributeHandleSetCallback(objectHandle, attributes)
 672         { }
 673         virtual void operator()(FederateAmbassador& self)
 674         { self.confirmAttributeOwnershipAcquisitionCancellationCallback(_objectHandle, _attributes); }
 675     };
 676     virtual void confirmAttributeOwnershipAcquisitionCancellation(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 677         throw (RTI::ObjectNotKnown,
 678                RTI::AttributeNotKnown,
 679                RTI::AttributeAlreadyOwned,
 680                RTI::AttributeAcquisitionWasNotCanceled,
 681                RTI::FederateInternalError)
 682     { _queueCallbackList.push_back(new ConfirmAttributeOwnershipAcquisitionCancellationCallback(objectHandle, attributes)); }
 683     void confirmAttributeOwnershipAcquisitionCancellationCallback(RTI::ObjectHandle objectHandle, const std::vector<RTI::AttributeHandle>& attributes)
 684     {
 685         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 686         if (i == _objectInstanceMap.end())
 687             return;
 688         if (!i->second.valid())
 689             return;
 690         i->second->confirmAttributeOwnershipAcquisitionCancellation(attributes);
 691     }
 692
 693     class InformAttributeOwnershipCallback : public QueueCallback {
 694     public:
 695         InformAttributeOwnershipCallback(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle, RTI::FederateHandle federateHandle) :
 696             _objectHandle(objectHandle),
 697             _attributeHandle(attributeHandle),
 698             _federateHandle(federateHandle)
 699         { }
 700         virtual void operator()(FederateAmbassador& self)
 701         { self.informAttributeOwnershipCallback(_objectHandle, _attributeHandle, _federateHandle); }
 702     private:
 703         RTI::ObjectHandle _objectHandle;
 704         RTI::AttributeHandle _attributeHandle;
 705         RTI::FederateHandle _federateHandle;
 706     };
 707     virtual void informAttributeOwnership(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle,
 708                                           RTI::FederateHandle federateHandle)
 709         throw (RTI::ObjectNotKnown,
 710                RTI::AttributeNotKnown,
 711                RTI::FederateInternalError)
 712     { _queueCallbackList.push_back(new InformAttributeOwnershipCallback(objectHandle, attributeHandle, federateHandle)); }
 713     void informAttributeOwnershipCallback(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle, RTI::FederateHandle federateHandle)
 714     {
 715         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 716         if (i == _objectInstanceMap.end())
 717             return;
 718         if (!i->second.valid())
 719             return;
 720         i->second->informAttributeOwnership(attributeHandle, federateHandle);
 721     }
 722
 723     class AttributeIsNotOwnedCallback : public QueueCallback {
 724     public:
 725         AttributeIsNotOwnedCallback(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle) :
 726             _objectHandle(objectHandle),
 727             _attributeHandle(attributeHandle)
 728         { }
 729         virtual void operator()(FederateAmbassador& self)
 730         { self.attributeIsNotOwnedCallback(_objectHandle, _attributeHandle); }
 731     private:
 732         RTI::ObjectHandle _objectHandle;
 733         RTI::AttributeHandle _attributeHandle;
 734     };
 735     virtual void attributeIsNotOwned(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle)
 736         throw (RTI::ObjectNotKnown,
 737                RTI::AttributeNotKnown,
 738                RTI::FederateInternalError)
 739     { _queueCallbackList.push_back(new AttributeIsNotOwnedCallback(objectHandle, attributeHandle)); }
 740     void attributeIsNotOwnedCallback(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle)
 741     {
 742         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 743         if (i == _objectInstanceMap.end())
 744             return;
 745         if (!i->second.valid())
 746             return;
 747         i->second->attributeIsNotOwned(attributeHandle);
 748     }
 749
 750     class AttributeOwnedByRTICallback : public QueueCallback {
 751     public:
 752         AttributeOwnedByRTICallback(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle) :
 753             _objectHandle(objectHandle),
 754             _attributeHandle(attributeHandle)
 755         { }
 756         virtual void operator()(FederateAmbassador& self)
 757         { self.attributeOwnedByRTICallback(_objectHandle, _attributeHandle); }
 758     private:
 759         RTI::ObjectHandle _objectHandle;
 760         RTI::AttributeHandle _attributeHandle;
 761     };
 762     virtual void attributeOwnedByRTI(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle)
 763         throw (RTI::ObjectNotKnown,
 764                RTI::AttributeNotKnown,
 765                RTI::FederateInternalError)
 766     { _queueCallbackList.push_back(new AttributeOwnedByRTICallback(objectHandle, attributeHandle)); }
 767     void attributeOwnedByRTICallback(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle)
 768     {
 769         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 770         if (i == _objectInstanceMap.end())
 771             return;
 772         if (!i->second.valid())
 773             return;
 774         i->second->attributeOwnedByRTI(attributeHandle);
 775     }
 776
 777     // Time Management
 778     virtual void timeRegulationEnabled(const RTI::FedTime& fedTime)
 779         throw (RTI::InvalidFederationTime,
 780                RTI::EnableTimeRegulationWasNotPending,
 781                RTI::FederateInternalError)
 782     {
 783         _timeRegulationEnabled = true;
 784         SG_LOG(SG_NETWORK, SG_INFO, "RTI: timeRegulationEnabled: " << RTI13Ambassador::toTimeStamp(fedTime));
 785     }
 786
 787     virtual void timeConstrainedEnabled(const RTI::FedTime& fedTime)
 788         throw (RTI::InvalidFederationTime,
 789                RTI::EnableTimeConstrainedWasNotPending,
 790                RTI::FederateInternalError)
 791     {
 792         _timeConstrainedEnabled = true;
 793         SG_LOG(SG_NETWORK, SG_INFO, "RTI: timeConstrainedEnabled: " << RTI13Ambassador::toTimeStamp(fedTime));
 794     }
 795
 796     virtual void timeAdvanceGrant(const RTI::FedTime& fedTime)
 797         throw (RTI::InvalidFederationTime,
 798                RTI::TimeAdvanceWasNotInProgress,
 799                RTI::FederateInternalError)
 800     {
 801         _timeAdvancePending = false;
 802         // SG_LOG(SG_NETWORK, SG_INFO, "RTI: timeAdvanceGrant: " << RTI13Ambassador::toTimeStamp(fedTime));
 803     }
 804
 805     virtual void requestRetraction(RTI::EventRetractionHandle eventRetractionHandle)
 806         throw (RTI::EventNotKnown,
 807                RTI::FederateInternalError)
 808     {
 809         // No retraction concept yet
 810     }
 811
 812     // processes the queues that filled up during the past
 813     void processQueues()
 814     {
 815         while (!_queueCallbackList.empty()) {
 816             (*_queueCallbackList.front())(*this);
 817             // _queueCallbackListPool.splice();
 818             _queueCallbackList.pop_front();
 819         }
 820     }
 821
 822     bool getFederationSynchronizationPointAnnounced(const std::string& label)
 823     { return _pendingSyncLabels.find(label) != _pendingSyncLabels.end(); }
 824     bool getFederationSynchronized(const std::string& label)
 825     {
 826         std::set<std::string>::iterator i = _syncronizedSyncLabels.find(label);
 827         if (i == _syncronizedSyncLabels.end())
 828             return false;
 829         _syncronizedSyncLabels.erase(i);
 830         return true;
 831     }
 832
 833     // The rtiambassador to issue requests
 834     SGSharedPtr<RTI13Ambassador> _rtiAmbassador;
 835
 836     // All the sync labels we got an announcement for
 837     std::set<std::string> _pendingSyncLabels;
 838     std::set<std::string> _syncronizedSyncLabels;
 839
 840     // All that calls back into user code is just queued.
 841     // That is to make sure we do not call recursively into the RTI
 842     typedef std::list<SGSharedPtr<QueueCallback> > QueueCallbackList;
 843     QueueCallbackList _queueCallbackList;
 844     // QueueCallbackList _queueCallbackListPool;
 845
 846     RTI13AttributeHandleDataPairList _attributeHandleDataPairPool;
 847     void appendAttributeHandleDataPair(RTI13AttributeHandleDataPairList& attributeHandleDataPairList)
 848     {
 849         if (_attributeHandleDataPairPool.empty())
 850             attributeHandleDataPairList.push_back(RTI13AttributeHandleDataPair());
 851         else
 852             attributeHandleDataPairList.splice(attributeHandleDataPairList.end(),
 853                                                _attributeHandleDataPairPool, _attributeHandleDataPairPool.begin());
 854     }
 855     void freeAttributeHandleDataPairList(RTI13AttributeHandleDataPairList& attributeHandleDataPairList)
 856     { _attributeHandleDataPairPool.splice(_attributeHandleDataPairPool.end(), attributeHandleDataPairList); }
 857
 858     // Top level information for dispatching federate object attribute updates
 859     typedef std::map<RTI::ObjectHandle, SGSharedPtr<RTI13ObjectInstance> > ObjectInstanceMap;
 860     // Map of all available objects
 861     ObjectInstanceMap _objectInstanceMap;
 862
 863     // Top level information for dispatching creation of federate objects
 864     typedef std::map<RTI::ObjectClassHandle, SGSharedPtr<RTI13ObjectClass> > ObjectClassMap;
 865     ObjectClassMap _objectClassMap;
 866
 867     bool _timeRegulationEnabled;
 868     bool _timeConstrainedEnabled;
 869     bool _timeAdvancePending;
 870
 871 private:
 872     const RTIData& tagToData(const char* tag)
 873     {
 874         if (tag)
 875             _cachedTag.setData(tag, std::strlen(tag) + 1);
 876         else
 877             _cachedTag.setData("", 1);
 878         return _cachedTag;
 879     }
 880     RTIData _cachedTag;
 881 };
 882
 883 RTI13Federate::RTI13Federate(const std::list<std::string>& stringList) :
 884     _joined(false),
 885     _ambassador(new RTI13Ambassador),
 886     _federateAmbassador(new FederateAmbassador)
 887 {
 888     _ambassador->_federate = this;
 889     _federateAmbassador->_rtiAmbassador = _ambassador;
 890     if (stringList.empty()) {
 891         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Ignoring non empty connect arguments while connecting to an RTI13 federation!");
 892     }
 893 }
 894
 895 RTI13Federate::~RTI13Federate()
 896 {
 897     if (_joined)
 898         _ambassador->resignFederationExecution();
 899     delete _federateAmbassador;
 900 }
 901
 902 RTI13Federate::FederationManagementResult
 903 RTI13Federate::createFederationExecution(const std::string& federationName, const std::string& objectModel)
 904 {
 905     try {
 906         _ambassador->createFederationExecution(federationName, objectModel);
 907         return FederationManagementSuccess;
 908     } catch (RTI::FederationExecutionAlreadyExists& e) {
 909         return FederationManagementFail;
 910     } catch (RTI::CouldNotOpenFED& e) {
 911         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create federation execution: " << e._name << " " << e._reason);
 912         return FederationManagementFatal;
 913     } catch (RTI::ErrorReadingFED& e) {
 914         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create federation execution: " << e._name << " " << e._reason);
 915         return FederationManagementFatal;
 916     } catch (RTI::ConcurrentAccessAttempted& e) {
 917         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create federation execution: " << e._name << " " << e._reason);
 918         return FederationManagementFatal;
 919     } catch (RTI::RTIinternalError& e) {
 920         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create federation execution: " << e._name << " " << e._reason);
 921         return FederationManagementFatal;
 922     }
 923 }
 924
 925 RTI13Federate::FederationManagementResult
 926 RTI13Federate::destroyFederationExecution(const std::string& federation)
 927 {
 928     try {
 929         _ambassador->destroyFederationExecution(federation);
 930         return FederationManagementSuccess;
 931     } catch (RTI::FederatesCurrentlyJoined& e) {
 932         return FederationManagementFail;
 933     } catch (RTI::FederationExecutionDoesNotExist& e) {
 934         return FederationManagementFail;
 935     } catch (RTI::ConcurrentAccessAttempted& e) {
 936         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not destroy federation execution: " << e._name << " " << e._reason);
 937         return FederationManagementFatal;
 938     } catch (RTI::RTIinternalError& e) {
 939         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not destroy federation execution: " << e._name << " " << e._reason);
 940         return FederationManagementFatal;
 941     }
 942 }
 943
 944 RTI13Federate::FederationManagementResult
 945 RTI13Federate::join(const std::string& federateType, const std::string& federationName)
 946 {
 947     try {
 948         _federateHandle = _ambassador->joinFederationExecution(federateType, federationName, _federateAmbassador);
 949         SG_LOG(SG_NETWORK, SG_INFO, "RTI: Joined federation \""
 950                << federationName << "\" as \"" << federateType << "\"");
 951         _joined = true;
 952         return FederationManagementSuccess;
 953     } catch (RTI::FederateAlreadyExecutionMember& e) {
 954         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
 955         return FederationManagementFatal;
 956     } catch (RTI::FederationExecutionDoesNotExist& e) {
 957         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
 958         return FederationManagementFail;
 959     } catch (RTI::CouldNotOpenFED& e) {
 960         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
 961         return FederationManagementFatal;
 962     } catch (RTI::ErrorReadingFED& e) {
 963         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
 964         return FederationManagementFatal;
 965     } catch (RTI::ConcurrentAccessAttempted& e) {
 966         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
 967         return FederationManagementFatal;
 968     } catch (RTI::SaveInProgress& e) {
 969         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
 970         return FederationManagementFatal;
 971     } catch (RTI::RestoreInProgress& e) {
 972         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
 973         return FederationManagementFatal;
 974     } catch (RTI::RTIinternalError& e) {
 975         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not join federation execution: " << e._name << " " << e._reason);
 976         return FederationManagementFatal;
 977     }
 978 }
 979
 980 bool
 981 RTI13Federate::resign()
 982 {
 983     try {
 984         _ambassador->resignFederationExecution();
 985         SG_LOG(SG_NETWORK, SG_INFO, "RTI: Resigned from federation.");
 986         _joined = false;
 987         _federateHandle = -1;
 988         return true;
 989     } catch (RTI::FederateOwnsAttributes& e) {
 990         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 991         return false;
 992     } catch (RTI::FederateNotExecutionMember& e) {
 993         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 994         return false;
 995     } catch (RTI::InvalidResignAction& e) {
 996         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
 997         return false;
 998     } catch (RTI::ConcurrentAccessAttempted& e) {
 999         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1000         return false;
1001     } catch (RTI::RTIinternalError& e) {
1002         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not resign federation execution: " << e._name << " " << e._reason);
1003         return false;
1004     }
1005 }
1006
1007 bool
1008 RTI13Federate::getJoined() const
1009 {
1010     return _joined;
1011 }
1012
1013 bool
1014 RTI13Federate::registerFederationSynchronizationPoint(const std::string& label, const RTIData& tag)
1015 {
1016     try {
1017         _ambassador->registerFederationSynchronizationPoint(label, tag);
1018         SG_LOG(SG_NETWORK, SG_INFO, "RTI: registerFederationSynchronizationPoint(" << label << ", tag )");
1019         return true;
1020     } catch (RTI::FederateNotExecutionMember& e) {
1021         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not register federation synchronization point: " << e._name << " " << e._reason);
1022         return false;
1023     } catch (RTI::ConcurrentAccessAttempted& e) {
1024         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not register federation synchronization point: " << e._name << " " << e._reason);
1025         return false;
1026     } catch (RTI::SaveInProgress& e) {
1027         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not register federation synchronization point: " << e._name << " " << e._reason);
1028         return false;
1029     } catch (RTI::RestoreInProgress& e) {
1030         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not register federation synchronization point: " << e._name << " " << e._reason);
1031         return false;
1032     } catch (RTI::RTIinternalError& e) {
1033         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not register federation synchronization point: " << e._name << " " << e._reason);
1034         return false;
1035     }
1036 }
1037
1038 bool
1039 RTI13Federate::getFederationSynchronizationPointAnnounced(const std::string& label)
1040 {
1041     return _federateAmbassador->getFederationSynchronizationPointAnnounced(label);
1042 }
1043
1044 bool
1045 RTI13Federate::synchronizationPointAchieved(const std::string& label)
1046 {
1047     try {
1048         _ambassador->synchronizationPointAchieved(label);
1049         SG_LOG(SG_NETWORK, SG_INFO, "RTI: synchronizationPointAchieved(" << label << ")");
1050         return true;
1051     } catch (RTI::SynchronizationPointLabelWasNotAnnounced& e) {
1052         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
1053         return false;
1054     } catch (RTI::FederateNotExecutionMember& e) {
1055         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
1056         return false;
1057     } catch (RTI::ConcurrentAccessAttempted& e) {
1058         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
1059         return false;
1060     } catch (RTI::SaveInProgress& e) {
1061         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
1062         return false;
1063     } catch (RTI::RestoreInProgress& e) {
1064         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
1065         return false;
1066     } catch (RTI::RTIinternalError& e) {
1067         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not signal synchronization point: " << e._name << " " << e._reason);
1068         return false;
1069     }
1070 }
1071
1072 bool
1073 RTI13Federate::getFederationSynchronized(const std::string& label)
1074 {
1075     return _federateAmbassador->getFederationSynchronized(label);
1076 }
1077
1078 bool
1079 RTI13Federate::enableTimeConstrained()
1080 {
1081     if (!_ambassador.valid()) {
1082         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time constrained at unconnected federate.");
1083         return false;
1084     }
1085
1086     if (_federateAmbassador->_timeConstrainedEnabled) {
1087         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Time constrained is already enabled.");
1088         return false;
1089     }
1090
1091     try {
1092         _ambassador->enableTimeConstrained();
1093     } catch (RTI::TimeConstrainedAlreadyEnabled& e) {
1094         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time constrained: " << e._name << " " << e._reason);
1095         return false;
1096     } catch (RTI::EnableTimeConstrainedPending& e) {
1097         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time constrained: " << e._name << " " << e._reason);
1098         return false;
1099     } catch (RTI::TimeAdvanceAlreadyInProgress& e) {
1100         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time constrained: " << e._name << " " << e._reason);
1101         return false;
1102     } catch (RTI::ConcurrentAccessAttempted& e) {
1103         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time constrained: " << e._name << " " << e._reason);
1104         return false;
1105     } catch (RTI::FederateNotExecutionMember& e) {
1106         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time constrained: " << e._name << " " << e._reason);
1107         return false;
1108     } catch (RTI::SaveInProgress& e) {
1109         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time constrained: " << e._name << " " << e._reason);
1110         return false;
1111     } catch (RTI::RestoreInProgress& e) {
1112         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time constrained: " << e._name << " " << e._reason);
1113         return false;
1114     } catch (RTI::RTIinternalError& e) {
1115         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time constrained: " << e._name << " " << e._reason);
1116         return false;
1117     }
1118
1119     return true;
1120 }
1121
1122 bool
1123 RTI13Federate::disableTimeConstrained()
1124 {
1125     if (!_ambassador.valid()) {
1126         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time constrained at unconnected federate.");
1127         return false;
1128     }
1129
1130     if (!_federateAmbassador->_timeConstrainedEnabled) {
1131         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Time constrained is not enabled.");
1132         return false;
1133     }
1134
1135     try {
1136         _ambassador->disableTimeConstrained();
1137         _federateAmbassador->_timeConstrainedEnabled = false;
1138     } catch (RTI::TimeConstrainedWasNotEnabled& e) {
1139         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time constrained: " << e._name << " " << e._reason);
1140         return false;
1141     } catch (RTI::FederateNotExecutionMember& e) {
1142         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time constrained: " << e._name << " " << e._reason);
1143         return false;
1144     } catch (RTI::ConcurrentAccessAttempted& e) {
1145         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time constrained: " << e._name << " " << e._reason);
1146         return false;
1147     } catch (RTI::SaveInProgress& e) {
1148         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time constrained: " << e._name << " " << e._reason);
1149         return false;
1150     } catch (RTI::RestoreInProgress& e) {
1151         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time constrained: " << e._name << " " << e._reason);
1152         return false;
1153     } catch (RTI::RTIinternalError& e) {
1154         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time constrained: " << e._name << " " << e._reason);
1155         return false;
1156     }
1157
1158     return true;
1159 }
1160
1161 bool
1162 RTI13Federate::getTimeConstrainedEnabled()
1163 {
1164     return _federateAmbassador->_timeConstrainedEnabled;
1165 }
1166
1167 bool
1168 RTI13Federate::enableTimeRegulation(const SGTimeStamp& lookahead)
1169 {
1170     if (!_ambassador.valid()) {
1171         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time regulation at unconnected federate.");
1172         return false;
1173     }
1174
1175     if (_federateAmbassador->_timeRegulationEnabled) {
1176         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Time regulation already enabled.");
1177         return false;
1178     }
1179
1180     try {
1181         _ambassador->enableTimeRegulation(lookahead);
1182     } catch (RTI::TimeRegulationAlreadyEnabled& e) {
1183         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time regulation: " << e._name << " " << e._reason);
1184         return false;
1185     } catch (RTI::EnableTimeRegulationPending& e) {
1186         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time regulation: " << e._name << " " << e._reason);
1187         return false;
1188     } catch (RTI::TimeAdvanceAlreadyInProgress& e) {
1189         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time regulation: " << e._name << " " << e._reason);
1190         return false;
1191     } catch (RTI::InvalidFederationTime& e) {
1192         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time regulation: " << e._name << " " << e._reason);
1193         return false;
1194     } catch (RTI::InvalidLookahead& e) {
1195         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time regulation: " << e._name << " " << e._reason);
1196         return false;
1197     } catch (RTI::ConcurrentAccessAttempted& e) {
1198         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time regulation: " << e._name << " " << e._reason);
1199         return false;
1200     } catch (RTI::FederateNotExecutionMember& e) {
1201         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time regulation: " << e._name << " " << e._reason);
1202         return false;
1203     } catch (RTI::SaveInProgress& e) {
1204         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time regulation: " << e._name << " " << e._reason);
1205         return false;
1206     } catch (RTI::RestoreInProgress& e) {
1207         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time regulation: " << e._name << " " << e._reason);
1208         return false;
1209     } catch (RTI::RTIinternalError& e) {
1210         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not enable time regulation: " << e._name << " " << e._reason);
1211         return false;
1212     }
1213
1214     return true;
1215 }
1216
1217 bool
1218 RTI13Federate::disableTimeRegulation()
1219 {
1220     if (!_ambassador.valid()) {
1221         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time regulation at unconnected federate.");
1222         return false;
1223     }
1224
1225     if (!_federateAmbassador->_timeRegulationEnabled) {
1226         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Time regulation is not enabled.");
1227         return false;
1228     }
1229
1230     try {
1231         _ambassador->disableTimeRegulation();
1232         _federateAmbassador->_timeRegulationEnabled = false;
1233     } catch (RTI::TimeRegulationWasNotEnabled& e) {
1234         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time regulation: " << e._name << " " << e._reason);
1235         return false;
1236     } catch (RTI::ConcurrentAccessAttempted& e) {
1237         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time regulation: " << e._name << " " << e._reason);
1238         return false;
1239     } catch (RTI::FederateNotExecutionMember& e) {
1240         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time regulation: " << e._name << " " << e._reason);
1241         return false;
1242     } catch (RTI::SaveInProgress& e) {
1243         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time regulation: " << e._name << " " << e._reason);
1244         return false;
1245     } catch (RTI::RestoreInProgress& e) {
1246         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time regulation: " << e._name << " " << e._reason);
1247         return false;
1248     } catch (RTI::RTIinternalError& e) {
1249         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not disable time regulation: " << e._name << " " << e._reason);
1250         return false;
1251     }
1252
1253     return true;
1254 }
1255
1256 bool
1257 RTI13Federate::modifyLookahead(const SGTimeStamp& timeStamp)
1258 {
1259     if (!_ambassador.valid()) {
1260         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead.");
1261         return false;
1262     }
1263     try {
1264         _ambassador->modifyLookahead(timeStamp);
1265     } catch (RTI::InvalidLookahead& e) {
1266         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
1267         return false;
1268     } catch (RTI::FederateNotExecutionMember& e) {
1269         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
1270         return false;
1271     } catch (RTI::ConcurrentAccessAttempted& e) {
1272         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
1273         return false;
1274     } catch (RTI::SaveInProgress& e) {
1275         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
1276         return false;
1277     } catch (RTI::RestoreInProgress& e) {
1278         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
1279         return false;
1280     } catch (RTI::RTIinternalError& e) {
1281         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not modify lookahead: " << e._name << " " << e._reason);
1282         return false;
1283     }
1284     return true;
1285 }
1286
1287 bool
1288 RTI13Federate::getTimeRegulationEnabled()
1289 {
1290     return _federateAmbassador->_timeRegulationEnabled;
1291 }
1292
1293 bool
1294 RTI13Federate::timeAdvanceRequest(const SGTimeStamp& timeStamp)
1295 {
1296     if (!_ambassador.valid()) {
1297         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time at unconnected federate.");
1298         return false;
1299     }
1300
1301     try {
1302         _ambassador->timeAdvanceRequest(timeStamp);
1303         _federateAmbassador->_timeAdvancePending = true;
1304     } catch (RTI::InvalidFederationTime& e) {
1305         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1306         return false;
1307     } catch (RTI::FederationTimeAlreadyPassed& e) {
1308         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1309         return false;
1310     } catch (RTI::TimeAdvanceAlreadyInProgress& e) {
1311         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1312         return false;
1313     } catch (RTI::EnableTimeRegulationPending& e) {
1314         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1315         return false;
1316     } catch (RTI::EnableTimeConstrainedPending& e) {
1317         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1318         return false;
1319     } catch (RTI::FederateNotExecutionMember& e) {
1320         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1321         return false;
1322     } catch (RTI::ConcurrentAccessAttempted& e) {
1323         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1324         return false;
1325     } catch (RTI::SaveInProgress& e) {
1326         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1327         return false;
1328     } catch (RTI::RestoreInProgress& e) {
1329         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1330         return false;
1331     } catch (RTI::RTIinternalError& e) {
1332         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1333         return false;
1334     }
1335
1336     return true;
1337 }
1338
1339 bool
1340 RTI13Federate::timeAdvanceRequestAvailable(const SGTimeStamp& timeStamp)
1341 {
1342     if (!_ambassador.valid()) {
1343         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time at unconnected federate.");
1344         return false;
1345     }
1346
1347     try {
1348         _ambassador->timeAdvanceRequestAvailable(timeStamp);
1349         _federateAmbassador->_timeAdvancePending = true;
1350     } catch (RTI::InvalidFederationTime& e) {
1351         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1352         return false;
1353     } catch (RTI::FederationTimeAlreadyPassed& e) {
1354         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1355         return false;
1356     } catch (RTI::TimeAdvanceAlreadyInProgress& e) {
1357         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1358         return false;
1359     } catch (RTI::EnableTimeRegulationPending& e) {
1360         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1361         return false;
1362     } catch (RTI::EnableTimeConstrainedPending& e) {
1363         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1364         return false;
1365     } catch (RTI::FederateNotExecutionMember& e) {
1366         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1367         return false;
1368     } catch (RTI::ConcurrentAccessAttempted& e) {
1369         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1370         return false;
1371     } catch (RTI::SaveInProgress& e) {
1372         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1373         return false;
1374     } catch (RTI::RestoreInProgress& e) {
1375         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1376         return false;
1377     } catch (RTI::RTIinternalError& e) {
1378         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not advance time: " << e._name << " " << e._reason);
1379         return false;
1380     }
1381
1382     return true;
1383 }
1384
1385 bool
1386 RTI13Federate::flushQueueRequest(const SGTimeStamp& timeStamp)
1387 {
1388     if (!_ambassador.valid()) {
1389         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not flush queue at unconnected federate.");
1390         return false;
1391     }
1392
1393     try {
1394         _ambassador->flushQueueRequest(timeStamp);
1395         _federateAmbassador->_timeAdvancePending = true;
1396     } catch (RTI::InvalidFederationTime& e) {
1397         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not flush queue: " << e._name << " " << e._reason);
1398         return false;
1399     } catch (RTI::FederationTimeAlreadyPassed& e) {
1400         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not flush queue: " << e._name << " " << e._reason);
1401         return false;
1402     } catch (RTI::TimeAdvanceAlreadyInProgress& e) {
1403         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not flush queue: " << e._name << " " << e._reason);
1404         return false;
1405     } catch (RTI::EnableTimeRegulationPending& e) {
1406         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not flush queue: " << e._name << " " << e._reason);
1407         return false;
1408     } catch (RTI::EnableTimeConstrainedPending& e) {
1409         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not flush queue: " << e._name << " " << e._reason);
1410         return false;
1411     } catch (RTI::FederateNotExecutionMember& e) {
1412         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not flush queue: " << e._name << " " << e._reason);
1413         return false;
1414     } catch (RTI::ConcurrentAccessAttempted& e) {
1415         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not flush queue: " << e._name << " " << e._reason);
1416         return false;
1417     } catch (RTI::SaveInProgress& e) {
1418         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not flush queue: " << e._name << " " << e._reason);
1419         return false;
1420     } catch (RTI::RestoreInProgress& e) {
1421         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not flush queue: " << e._name << " " << e._reason);
1422         return false;
1423     } catch (RTI::RTIinternalError& e) {
1424         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not flush queue: " << e._name << " " << e._reason);
1425         return false;
1426     }
1427
1428     return true;
1429 }
1430
1431 bool
1432 RTI13Federate::getTimeAdvancePending()
1433 {
1434     return _federateAmbassador->_timeAdvancePending;
1435 }
1436
1437 bool
1438 RTI13Federate::queryFederateTime(SGTimeStamp& timeStamp)
1439 {
1440     if (!_ambassador.valid()) {
1441         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time.");
1442         return false;
1443     }
1444
1445     try {
1446         _ambassador->queryFederateTime(timeStamp);
1447     } catch (RTI::FederateNotExecutionMember& e) {
1448         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time: " << e._name << " " << e._reason);
1449         return false;
1450     } catch (RTI::ConcurrentAccessAttempted& e) {
1451         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time: " << e._name << " " << e._reason);
1452         return false;
1453     } catch (RTI::SaveInProgress& e) {
1454         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time: " << e._name << " " << e._reason);
1455         return false;
1456     } catch (RTI::RestoreInProgress& e) {
1457         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time: " << e._name << " " << e._reason);
1458         return false;
1459     } catch (RTI::RTIinternalError& e) {
1460         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query federate time: " << e._name << " " << e._reason);
1461         return false;
1462     }
1463     return true;
1464 }
1465
1466 bool
1467 RTI13Federate::queryLookahead(SGTimeStamp& timeStamp)
1468 {
1469     if (!_ambassador.valid()) {
1470         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead.");
1471         return false;
1472     }
1473
1474     try {
1475         _ambassador->queryLookahead(timeStamp);
1476     } catch (RTI::FederateNotExecutionMember& e) {
1477         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead: " << e._name << " " << e._reason);
1478         return false;
1479     } catch (RTI::ConcurrentAccessAttempted& e) {
1480         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead: " << e._name << " " << e._reason);
1481         return false;
1482     } catch (RTI::SaveInProgress& e) {
1483         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead: " << e._name << " " << e._reason);
1484         return false;
1485     } catch (RTI::RestoreInProgress& e) {
1486         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead: " << e._name << " " << e._reason);
1487         return false;
1488     } catch (RTI::RTIinternalError& e) {
1489         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query lookahead: " << e._name << " " << e._reason);
1490         return false;
1491     }
1492     return true;
1493 }
1494
1495 bool
1496 RTI13Federate::queryGALT(SGTimeStamp& timeStamp)
1497 {
1498     if (!_ambassador.valid()) {
1499         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT.");
1500         return false;
1501     }
1502
1503     try {
1504         return _ambassador->queryGALT(timeStamp);
1505     } catch (RTI::FederateNotExecutionMember& e) {
1506         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT: " << e._name << " " << e._reason);
1507         return false;
1508     } catch (RTI::ConcurrentAccessAttempted& e) {
1509         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT: " << e._name << " " << e._reason);
1510         return false;
1511     } catch (RTI::SaveInProgress& e) {
1512         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT: " << e._name << " " << e._reason);
1513         return false;
1514     } catch (RTI::RestoreInProgress& e) {
1515         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT: " << e._name << " " << e._reason);
1516         return false;
1517     } catch (RTI::RTIinternalError& e) {
1518         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query GALT: " << e._name << " " << e._reason);
1519         return false;
1520     }
1521     return true;
1522 }
1523
1524 bool
1525 RTI13Federate::queryLITS(SGTimeStamp& timeStamp)
1526 {
1527     if (!_ambassador.valid()) {
1528         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS.");
1529         return false;
1530     }
1531
1532     try {
1533         return _ambassador->queryLITS(timeStamp);
1534     } catch (RTI::FederateNotExecutionMember& e) {
1535         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS: " << e._name << " " << e._reason);
1536         return false;
1537     } catch (RTI::ConcurrentAccessAttempted& e) {
1538         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS: " << e._name << " " << e._reason);
1539         return false;
1540     } catch (RTI::SaveInProgress& e) {
1541         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS: " << e._name << " " << e._reason);
1542         return false;
1543     } catch (RTI::RestoreInProgress& e) {
1544         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS: " << e._name << " " << e._reason);
1545         return false;
1546     } catch (RTI::RTIinternalError& e) {
1547         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query LITS: " << e._name << " " << e._reason);
1548         return false;
1549     }
1550     return true;
1551 }
1552
1553 bool
1554 RTI13Federate::processMessage()
1555 {
1556     bool result = _ambassador->tick();
1557     _federateAmbassador->processQueues();
1558     return result;
1559 }
1560
1561 bool
1562 RTI13Federate::processMessages(const double& minimum, const double& maximum)
1563 {
1564     bool result = _ambassador->tick(minimum, 0);
1565     _federateAmbassador->processQueues();
1566     if (!result)
1567         return false;
1568     SGTimeStamp timeStamp = SGTimeStamp::now() + SGTimeStamp::fromSec(maximum);
1569     do {
1570         result = _ambassador->tick(0, 0);
1571         _federateAmbassador->processQueues();
1572     } while (result && SGTimeStamp::now() <= timeStamp);
1573     return result;
1574 }
1575
1576 RTI13ObjectClass*
1577 RTI13Federate::createObjectClass(const std::string& objectClassName, HLAObjectClass* hlaObjectClass)
1578 {
1579     try {
1580         RTI::ObjectClassHandle objectClassHandle;
1581         objectClassHandle = _ambassador->getObjectClassHandle(objectClassName);
1582         if (_federateAmbassador->_objectClassMap.find(objectClassHandle) != _federateAmbassador->_objectClassMap.end()) {
1583             SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create object class, object class already exists!");
1584             return 0;
1585         }
1586         RTI13ObjectClass* rtiObjectClass;
1587         rtiObjectClass = new RTI13ObjectClass(hlaObjectClass, objectClassHandle, _ambassador.get());
1588         _federateAmbassador->_objectClassMap[objectClassHandle] = rtiObjectClass;
1589         return rtiObjectClass;
1590     } catch (RTI::NameNotFound& e) {
1591         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1592         return 0;
1593     } catch (RTI::FederateNotExecutionMember& e) {
1594         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1595         return 0;
1596     } catch (RTI::ConcurrentAccessAttempted& e) {
1597         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1598         return 0;
1599     } catch (RTI::RTIinternalError& e) {
1600         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: " << e._name << " " << e._reason);
1601         return 0;
1602     }
1603 }
1604
1605 RTI13ObjectInstance*
1606 RTI13Federate::getObjectInstance(const std::string& objectInstanceName)
1607 {
1608     try {
1609         RTI::ObjectHandle objectHandle;
1610         objectHandle = _ambassador->getObjectInstanceHandle(objectInstanceName);
1611         FederateAmbassador::ObjectInstanceMap::iterator i = _federateAmbassador->_objectInstanceMap.find(objectHandle);
1612         if (i == _federateAmbassador->_objectInstanceMap.end()) {
1613             SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object instance: ObjectInstance not found.");
1614             return 0;
1615         }
1616         return i->second;
1617     } catch (RTI::ObjectNotKnown& e) {
1618         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object instance: " << e._name << " " << e._reason);
1619         return 0;
1620     } catch (RTI::FederateNotExecutionMember& e) {
1621         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object instance: " << e._name << " " << e._reason);
1622         return 0;
1623     } catch (RTI::ConcurrentAccessAttempted& e) {
1624         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object instance: " << e._name << " " << e._reason);
1625         return 0;
1626     } catch (RTI::RTIinternalError& e) {
1627         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object instance: " << e._name << " " << e._reason);
1628         return 0;
1629     }
1630 }
1631
1632 void
1633 RTI13Federate::insertObjectInstance(RTI13ObjectInstance* objectInstance)
1634 {
1635     _federateAmbassador->_objectInstanceMap[objectInstance->getHandle()] = objectInstance;
1636 }
1637
1638 }