simgear/hla/RTI13Ambassador.hxx

   1 // Copyright (C) 2009 - 2010  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 #ifndef RTIAmbassador_hxx
  19 #define RTIAmbassador_hxx
  20
  21 #include <cstdlib>
  22 #include <list>
  23 #include <memory>
  24 #include <vector>
  25 #include <map>
  26 #include <set>
  27
  28 #ifndef RTI_USES_STD_FSTREAM
  29 #define RTI_USES_STD_FSTREAM
  30 #endif
  31
  32 #include <RTI.hh>
  33 #include <fedtime.hh>
  34
  35 #include <simgear/debug/logstream.hxx>
  36 #include <simgear/structure/SGWeakReferenced.hxx>
  37 #include <simgear/structure/SGSharedPtr.hxx>
  38 #include <simgear/structure/SGWeakPtr.hxx>
  39 #include <simgear/timing/timestamp.hxx>
  40
  41 #include "RTIObjectClass.hxx"
  42 #include "RTIData.hxx"
  43 #include "RTI13Federate.hxx"
  44 #include "RTI13ObjectInstance.hxx"
  45
  46 namespace simgear {
  47
  48 class RTI13Ambassador : public SGWeakReferenced {
  49 public:
  50     RTI13Ambassador() :
  51         _federateAmbassador(*this),
  52         _timeRegulationEnabled(false),
  53         _timeConstrainedEnabled(false),
  54         _timeAdvancePending(false)
  55     { }
  56     virtual ~RTI13Ambassador()
  57     { }
  58
  59     // processes the queues that filled up during the past
  60     void processQueues()
  61     {
  62         while (!_queueCallbackList.empty()) {
  63             (*_queueCallbackList.front())();
  64             _queueCallbackList.pop_front();
  65         }
  66
  67         while (!_objectInstancePendingCallbackList.empty()) {
  68             (*_objectInstancePendingCallbackList.begin())->flushPendingRequests();
  69             _objectInstancePendingCallbackList.erase(_objectInstancePendingCallbackList.begin());
  70         }
  71     }
  72
  73     bool getTimeRegulationEnabled() const
  74     { return _timeRegulationEnabled; }
  75     bool getTimeConstrainedEnabled() const
  76     { return _timeConstrainedEnabled; }
  77     bool getTimeAdvancePending() const
  78     { return _timeAdvancePending; }
  79     const SGTimeStamp& getCurrentLogicalTime() const
  80     { return _federateTime; }
  81
  82     bool getFederationSynchronizationPointAnnounced(const std::string& label)
  83     { return _pendingSyncLabels.find(label) != _pendingSyncLabels.end(); }
  84     bool getFederationSynchronized(const std::string& label)
  85     {
  86         std::set<std::string>::iterator i = _syncronizedSyncLabels.find(label);
  87         if (i == _syncronizedSyncLabels.end())
  88             return false;
  89         _syncronizedSyncLabels.erase(i);
  90         return true;
  91     }
  92
  93     void createFederationExecution(const std::string& name, const std::string& objectModel)
  94     { _rtiAmbassador.createFederationExecution(name.c_str(), objectModel.c_str()); }
  95     void destroyFederationExecution(const std::string& name)
  96     { _rtiAmbassador.destroyFederationExecution(name.c_str()); }
  97
  98     RTI::FederateHandle joinFederationExecution(const std::string& federate, const std::string& federation)
  99     { return _rtiAmbassador.joinFederationExecution(federate.c_str(), federation.c_str(), &_federateAmbassador); }
 100     void resignFederationExecution()
 101     { _rtiAmbassador.resignFederationExecution(RTI::DELETE_OBJECTS_AND_RELEASE_ATTRIBUTES); }
 102
 103     void registerFederationSynchronizationPoint(const std::string& label, const RTIData& tag)
 104     { _rtiAmbassador.registerFederationSynchronizationPoint(label.c_str(), tag.data()); }
 105     void synchronizationPointAchieved(const std::string& label)
 106     { _rtiAmbassador.synchronizationPointAchieved(label.c_str()); }
 107
 108     void publishObjectClass(const RTI::ObjectClassHandle& handle, const RTI::AttributeHandleSet& attributeHandleSet)
 109     { _rtiAmbassador.publishObjectClass(handle, attributeHandleSet); }
 110     void unpublishObjectClass(const RTI::ObjectClassHandle& handle)
 111     { _rtiAmbassador.unpublishObjectClass(handle); }
 112     void subscribeObjectClassAttributes(const RTI::ObjectClassHandle& handle, const RTI::AttributeHandleSet& attributeHandleSet, bool active)
 113     { _rtiAmbassador.subscribeObjectClassAttributes(handle, attributeHandleSet, active ? RTI::RTI_TRUE : RTI::RTI_FALSE); }
 114     void unsubscribeObjectClass(const RTI::ObjectClassHandle& handle)
 115     { _rtiAmbassador.unsubscribeObjectClass(handle); }
 116
 117     RTI13ObjectInstance* registerObjectInstance(const RTI13ObjectClass* objectClass, HLAObjectInstance* hlaObjectInstance)
 118     {
 119         RTI::ObjectHandle objectHandle = _rtiAmbassador.registerObjectInstance(objectClass->getHandle());
 120         RTI13ObjectInstance* objectInstance = new RTI13ObjectInstance(objectHandle, hlaObjectInstance, objectClass, this, true);
 121         _objectInstanceMap[objectHandle] = objectInstance;
 122         return objectInstance;
 123     }
 124     void updateAttributeValues(const RTI::ObjectHandle& objectHandle, const RTI::AttributeHandleValuePairSet& attributeValues,
 125                                const SGTimeStamp& timeStamp, const RTIData& tag)
 126     { _rtiAmbassador.updateAttributeValues(objectHandle, attributeValues, toFedTime(timeStamp), tag.data()); }
 127     void updateAttributeValues(const RTI::ObjectHandle& objectHandle, const RTI::AttributeHandleValuePairSet& attributeValues, const RTIData& tag)
 128     { _rtiAmbassador.updateAttributeValues(objectHandle, attributeValues, tag.data()); }
 129
 130     // RTI::EventRetractionHandle sendInteraction(RTI::InteractionClassHandle interactionClassHandle, const RTI::ParameterHandleValuePairSet& parameters, const RTI::FedTime& fedTime, const RTIData& tag)
 131     // { return _rtiAmbassador.sendInteraction(interactionClassHandle, parameters, fedTime, tag.data()); }
 132     // void sendInteraction(RTI::InteractionClassHandle interactionClassHandle, const RTI::ParameterHandleValuePairSet& parameters, const RTIData& tag)
 133     // { _rtiAmbassador.sendInteraction(interactionClassHandle, parameters, tag.data()); }
 134
 135     void deleteObjectInstance(const RTI::ObjectHandle& objectHandle, const SGTimeStamp& timeStamp, const RTIData& tag)
 136     {
 137         RTI::EventRetractionHandle h = _rtiAmbassador.deleteObjectInstance(objectHandle, toFedTime(timeStamp), tag.data());
 138         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 139         if (i == _objectInstanceMap.end()) {
 140             SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: ObjectInstance not found.");
 141             return;
 142         }
 143         _objectInstancePendingCallbackList.erase(i->second);
 144         _objectInstanceMap.erase(i);
 145     }
 146     void deleteObjectInstance(const RTI::ObjectHandle& objectHandle, const RTIData& tag)
 147     {
 148         _rtiAmbassador.deleteObjectInstance(objectHandle, tag.data());
 149         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 150         if (i == _objectInstanceMap.end()) {
 151             SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: ObjectInstance not found.");
 152             return;
 153         }
 154         _objectInstancePendingCallbackList.erase(i->second);
 155         _objectInstanceMap.erase(i);
 156     }
 157     void localDeleteObjectInstance(const RTI::ObjectHandle& objectHandle)
 158     {
 159         _rtiAmbassador.localDeleteObjectInstance(objectHandle);
 160         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 161         if (i == _objectInstanceMap.end()) {
 162             SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: ObjectInstance not found.");
 163             return;
 164         }
 165         _objectInstancePendingCallbackList.erase(i->second);
 166         _objectInstanceMap.erase(i);
 167     }
 168
 169     void requestObjectAttributeValueUpdate(const RTI::ObjectHandle& handle, const RTI::AttributeHandleSet& attributeHandleSet)
 170     { _rtiAmbassador.requestObjectAttributeValueUpdate(handle, attributeHandleSet); }
 171     void requestClassAttributeValueUpdate(const RTI::ObjectClassHandle& handle, const RTI::AttributeHandleSet& attributeHandleSet)
 172     { _rtiAmbassador.requestClassAttributeValueUpdate(handle, attributeHandleSet); }
 173
 174     // Ownership Management -------------------
 175
 176     // bool unconditionalAttributeOwnershipDivestiture(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles)
 177     // {
 178     //     try {
 179     //         std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
 180     //         for (RTIHandleSet::const_iterator i = attributeHandles.begin(); i != attributeHandles.end(); ++i)
 181     //             attributeHandleSet->add(*i);
 182     //         _rtiAmbassador.unconditionalAttributeOwnershipDivestiture(objectHandle, *attributeHandleSet);
 183     //         return true;
 184     //     } catch (RTI::ObjectNotKnown& e) {
 185     //     } catch (RTI::AttributeNotDefined& e) {
 186     //     } catch (RTI::AttributeNotOwned& e) {
 187     //     } catch (RTI::FederateNotExecutionMember& e) {
 188     //     } catch (RTI::ConcurrentAccessAttempted& e) {
 189     //     } catch (RTI::SaveInProgress& e) {
 190     //     } catch (RTI::RestoreInProgress& e) {
 191     //     } catch (RTI::RTIinternalError& e) {
 192     //     }
 193     //     return false;
 194     // }
 195     // bool negotiatedAttributeOwnershipDivestiture(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles, const RTIData& tag)
 196     // {
 197     //     try {
 198     //         std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
 199     //         for (RTIHandleSet::const_iterator i = attributeHandles.begin(); i != attributeHandles.end(); ++i)
 200     //             attributeHandleSet->add(*i);
 201     //         _rtiAmbassador.negotiatedAttributeOwnershipDivestiture(objectHandle, *attributeHandleSet, tag.data());
 202     //         return true;
 203     //     } catch (RTI::ObjectNotKnown& e) {
 204     //     } catch (RTI::AttributeNotDefined& e) {
 205     //     } catch (RTI::AttributeNotOwned& e) {
 206     //     } catch (RTI::AttributeAlreadyBeingDivested& e) {
 207     //     } catch (RTI::FederateNotExecutionMember& e) {
 208     //     } catch (RTI::ConcurrentAccessAttempted& e) {
 209     //     } catch (RTI::SaveInProgress& e) {
 210     //     } catch (RTI::RestoreInProgress& e) {
 211     //     } catch (RTI::RTIinternalError& e) {
 212     //     }
 213     //     return false;
 214     // }
 215     // bool attributeOwnershipAcquisition(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles, const RTIData& tag)
 216     // {
 217     //     try {
 218     //         std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
 219     //         for (RTIHandleSet::const_iterator i = attributeHandles.begin(); i != attributeHandles.end(); ++i)
 220     //             attributeHandleSet->add(*i);
 221     //         _rtiAmbassador.attributeOwnershipAcquisition(objectHandle, *attributeHandleSet, tag.data());
 222     //         return true;
 223     //     } catch (RTI::ObjectNotKnown& e) {
 224     //     } catch (RTI::ObjectClassNotPublished& e) {
 225     //     } catch (RTI::AttributeNotDefined& e) {
 226     //     } catch (RTI::AttributeNotPublished& e) {
 227     //     } catch (RTI::FederateOwnsAttributes& e) {
 228     //     } catch (RTI::FederateNotExecutionMember& e) {
 229     //     } catch (RTI::ConcurrentAccessAttempted& e) {
 230     //     } catch (RTI::SaveInProgress& e) {
 231     //     } catch (RTI::RestoreInProgress& e) {
 232     //     } catch (RTI::RTIinternalError& e) {
 233     //     }
 234     //     return false;
 235     // }
 236     // bool attributeOwnershipAcquisitionIfAvailable(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles)
 237     // {
 238     //     try {
 239     //         std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
 240     //         for (RTIHandleSet::const_iterator i = attributeHandles.begin(); i != attributeHandles.end(); ++i)
 241     //             attributeHandleSet->add(*i);
 242     //         _rtiAmbassador.attributeOwnershipAcquisitionIfAvailable(objectHandle, *attributeHandleSet);
 243     //         return true;
 244     //     } catch (RTI::ObjectNotKnown& e) {
 245     //     } catch (RTI::ObjectClassNotPublished& e) {
 246     //     } catch (RTI::AttributeNotDefined& e) {
 247     //     } catch (RTI::AttributeNotPublished& e) {
 248     //     } catch (RTI::FederateOwnsAttributes& e) {
 249     //     } catch (RTI::AttributeAlreadyBeingAcquired& e) {
 250     //     } catch (RTI::FederateNotExecutionMember& e) {
 251     //     } catch (RTI::ConcurrentAccessAttempted& e) {
 252     //     } catch (RTI::SaveInProgress& e) {
 253     //     } catch (RTI::RestoreInProgress& e) {
 254     //     } catch (RTI::RTIinternalError& e) {
 255     //     }
 256     //     return false;
 257     // }
 258     // RTIHandleSet attributeOwnershipReleaseResponse(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles)
 259     // {
 260     //     try {
 261     //         std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
 262     //         for (RTIHandleSet::const_iterator i = attributeHandles.begin(); i != attributeHandles.end(); ++i)
 263     //             attributeHandleSet->add(*i);
 264     //         attributeHandleSet.reset(_rtiAmbassador.attributeOwnershipReleaseResponse(objectHandle, *attributeHandleSet));
 265     //         RTIHandleSet handleSet;
 266     //         RTI::ULong numAttribs = attributeHandleSet->size();
 267     //         for (RTI::ULong i = 0; i < numAttribs; ++i)
 268     //             handleSet.insert(attributeHandleSet->getHandle(i));
 269     //         return handleSet;
 270     //     } catch (RTI::ObjectNotKnown& e) {
 271     //     } catch (RTI::AttributeNotDefined& e) {
 272     //     } catch (RTI::AttributeNotOwned& e) {
 273     //     } catch (RTI::FederateWasNotAskedToReleaseAttribute& e) {
 274     //     } catch (RTI::FederateNotExecutionMember& e) {
 275     //     } catch (RTI::ConcurrentAccessAttempted& e) {
 276     //     } catch (RTI::SaveInProgress& e) {
 277     //     } catch (RTI::RestoreInProgress& e) {
 278     //     } catch (RTI::RTIinternalError& e) {
 279     //     }
 280     //     return RTIHandleSet();
 281     // }
 282     // bool cancelNegotiatedAttributeOwnershipDivestiture(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles)
 283     // {
 284     //     try {
 285     //         std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
 286     //         for (RTIHandleSet::const_iterator i = attributeHandles.begin(); i != attributeHandles.end(); ++i)
 287     //             attributeHandleSet->add(*i);
 288     //         _rtiAmbassador.cancelNegotiatedAttributeOwnershipDivestiture(objectHandle, *attributeHandleSet);
 289     //         return true;
 290     //     } catch (RTI::ObjectNotKnown& e) {
 291     //     } catch (RTI::AttributeNotDefined& e) {
 292     //     } catch (RTI::AttributeNotOwned& e) {
 293     //     } catch (RTI::AttributeDivestitureWasNotRequested& e) {
 294     //     } catch (RTI::FederateNotExecutionMember& e) {
 295     //     } catch (RTI::ConcurrentAccessAttempted& e) {
 296     //     } catch (RTI::SaveInProgress& e) {
 297     //     } catch (RTI::RestoreInProgress& e) {
 298     //     } catch (RTI::RTIinternalError& e) {
 299     //     }
 300     //     return false;
 301     // }
 302     // bool cancelAttributeOwnershipAcquisition(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles)
 303     // {
 304     //     try {
 305     //         std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
 306     //         for (RTIHandleSet::const_iterator i = attributeHandles.begin(); i != attributeHandles.end(); ++i)
 307     //             attributeHandleSet->add(*i);
 308     //         _rtiAmbassador.cancelAttributeOwnershipAcquisition(objectHandle, *attributeHandleSet);
 309     //         return true;
 310     //     } catch (RTI::ObjectNotKnown& e) {
 311     //     } catch (RTI::AttributeNotDefined& e) {
 312     //     } catch (RTI::AttributeAlreadyOwned& e) {
 313     //     } catch (RTI::AttributeAcquisitionWasNotRequested& e) {
 314     //     } catch (RTI::FederateNotExecutionMember& e) {
 315     //     } catch (RTI::ConcurrentAccessAttempted& e) {
 316     //     } catch (RTI::SaveInProgress& e) {
 317     //     } catch (RTI::RestoreInProgress& e) {
 318     //     } catch (RTI::RTIinternalError& e) {
 319     //     }
 320     //     return false;
 321     // }
 322     // bool queryAttributeOwnership(const RTIHandle& objectHandle, const RTIHandle& attributeHandle)
 323     // {
 324     //     try {
 325     //         _rtiAmbassador.queryAttributeOwnership(objectHandle, attributeHandle);
 326     //         return true;
 327     //     } catch (RTI::ObjectNotKnown& e) {
 328     //     } catch (RTI::AttributeNotDefined& e) {
 329     //     } catch (RTI::FederateNotExecutionMember& e) {
 330     //     } catch (RTI::ConcurrentAccessAttempted& e) {
 331     //     } catch (RTI::SaveInProgress& e) {
 332     //     } catch (RTI::RestoreInProgress& e) {
 333     //     } catch (RTI::RTIinternalError& e) {
 334     //     }
 335     //     return false;
 336     // }
 337     // bool isAttributeOwnedByFederate(const RTIHandle& objectHandle, const RTIHandle& attributeHandle)
 338     // {
 339     //     try {
 340     //         return _rtiAmbassador.isAttributeOwnedByFederate(objectHandle, attributeHandle);
 341     //     } catch (RTI::ObjectNotKnown& e) {
 342     //     } catch (RTI::AttributeNotDefined& e) {
 343     //     } catch (RTI::FederateNotExecutionMember& e) {
 344     //     } catch (RTI::ConcurrentAccessAttempted& e) {
 345     //     } catch (RTI::SaveInProgress& e) {
 346     //     } catch (RTI::RestoreInProgress& e) {
 347     //     } catch (RTI::RTIinternalError& e) {
 348     //     }
 349     //     return false;
 350     // }
 351
 352     /// Time Management
 353
 354     void enableTimeRegulation(const SGTimeStamp& federateTime, const SGTimeStamp& lookahead)
 355     { _rtiAmbassador.enableTimeRegulation(toFedTime(federateTime), toFedTime(lookahead)); }
 356     void disableTimeRegulation()
 357     { _rtiAmbassador.disableTimeRegulation(); _timeRegulationEnabled = false; }
 358
 359     void enableTimeConstrained()
 360     { _rtiAmbassador.enableTimeConstrained(); }
 361     void disableTimeConstrained()
 362     { _rtiAmbassador.disableTimeConstrained(); _timeConstrainedEnabled = false; }
 363
 364     void timeAdvanceRequest(const SGTimeStamp& time)
 365     { _rtiAmbassador.timeAdvanceRequest(toFedTime(time)); _timeAdvancePending = true; }
 366     void timeAdvanceRequestAvailable(const SGTimeStamp& time)
 367     { _rtiAmbassador.timeAdvanceRequestAvailable(toFedTime(time)); _timeAdvancePending = true; }
 368
 369     // bool queryLBTS(double& time)
 370     // {
 371     //     try {
 372     //         RTIfedTime fedTime;
 373     //         _rtiAmbassador.queryLBTS(fedTime);
 374     //         time = fedTime.getTime();
 375     //         return true;
 376     //     } catch (RTI::FederateNotExecutionMember& e) {
 377     //     } catch (RTI::ConcurrentAccessAttempted& e) {
 378     //     } catch (RTI::SaveInProgress& e) {
 379     //     } catch (RTI::RestoreInProgress& e) {
 380     //     } catch (RTI::RTIinternalError& e) {
 381     //     }
 382     //     return false;
 383     // }
 384     void queryFederateTime(SGTimeStamp& timeStamp)
 385     {
 386         RTIfedTime fedTime;
 387         _rtiAmbassador.queryFederateTime(fedTime);
 388         timeStamp = toTimeStamp(fedTime);
 389     }
 390     void modifyLookahead(const SGTimeStamp& timeStamp)
 391     { _rtiAmbassador.modifyLookahead(toFedTime(timeStamp)); }
 392     void queryLookahead(SGTimeStamp& timeStamp)
 393     {
 394         RTIfedTime fedTime;
 395         _rtiAmbassador.queryLookahead(fedTime);
 396         timeStamp = toTimeStamp(fedTime);
 397     }
 398
 399     RTI13ObjectClass* createObjectClass(const std::string& name, HLAObjectClass* hlaObjectClass)
 400     {
 401         RTI::ObjectClassHandle objectClassHandle;
 402         objectClassHandle = getObjectClassHandle(name);
 403         if (_objectClassMap.find(objectClassHandle) != _objectClassMap.end()) {
 404             SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create object class, object class already exists!");
 405             return 0;
 406         }
 407         RTI13ObjectClass* rtiObjectClass;
 408         rtiObjectClass = new RTI13ObjectClass(hlaObjectClass, objectClassHandle, this);
 409         _objectClassMap[objectClassHandle] = rtiObjectClass;
 410         return rtiObjectClass;
 411     }
 412     RTI::ObjectClassHandle getObjectClassHandle(const std::string& name)
 413     { return _rtiAmbassador.getObjectClassHandle(name.c_str()); }
 414     std::string getObjectClassName(const RTI::ObjectClassHandle& handle)
 415     { return rtiToStdString(_rtiAmbassador.getObjectClassName(handle)); }
 416
 417     RTI::AttributeHandle getAttributeHandle(const std::string& attributeName, const RTI::ObjectClassHandle& objectClassHandle)
 418     { return _rtiAmbassador.getAttributeHandle(attributeName.c_str(), objectClassHandle); }
 419     std::string getAttributeName(const RTI::AttributeHandle& attributeHandle, const RTI::ObjectClassHandle& objectClassHandle)
 420     { return rtiToStdString(_rtiAmbassador.getAttributeName(attributeHandle, objectClassHandle)); }
 421
 422     // RTIHandle getInteractionClassHandle(const std::string& name)
 423     // {
 424     //     try {
 425     //         return _rtiAmbassador.getInteractionClassHandle(name.c_str());
 426     //     } catch (RTI::NameNotFound& e) {
 427     //     } catch (RTI::FederateNotExecutionMember& e) {
 428     //     } catch (RTI::ConcurrentAccessAttempted& e) {
 429     //     } catch (RTI::RTIinternalError& e) {
 430     //     }
 431     //     return RTIHandle(-1);
 432     // }
 433     // std::string getInteractionClassName(const RTIHandle& handle)
 434     // {
 435     //     std::string name;
 436     //     try {
 437     //         rtiToStdString(name, _rtiAmbassador.getInteractionClassName(handle));
 438     //     } catch (RTI::InteractionClassNotDefined& e) {
 439     //     } catch (RTI::FederateNotExecutionMember& e) {
 440     //     } catch (RTI::ConcurrentAccessAttempted& e) {
 441     //     } catch (RTI::RTIinternalError& e) {
 442     //     }
 443     //     return name;
 444     // }
 445
 446     // RTIHandle getParameterHandle(const std::string& parameterName, const RTIHandle& interactionClassHandle)
 447     // {
 448     //     try {
 449     //         return _rtiAmbassador.getParameterHandle(parameterName.c_str(), interactionClassHandle);
 450     //     } catch (RTI::InteractionClassNotDefined& e) {
 451     //     } catch (RTI::NameNotFound& e) {
 452     //     } catch (RTI::FederateNotExecutionMember& e) {
 453     //     } catch (RTI::ConcurrentAccessAttempted& e) {
 454     //     } catch (RTI::RTIinternalError& e) {
 455     //     }
 456     //     return RTIHandle(-1);
 457     // }
 458     // std::string getParameterName(const RTIHandle& parameterHandle, const RTIHandle& interactionClassHandle)
 459     // {
 460     //     std::string parameterName;
 461     //     try {
 462     //         rtiToStdString(parameterName, _rtiAmbassador.getParameterName(parameterHandle, interactionClassHandle));
 463     //     } catch (RTI::InteractionClassNotDefined& e) {
 464     //     } catch (RTI::InteractionParameterNotDefined& e) {
 465     //     } catch (RTI::FederateNotExecutionMember& e) {
 466     //     } catch (RTI::ConcurrentAccessAttempted& e) {
 467     //     } catch (RTI::RTIinternalError& e) {
 468     //     }
 469     //     return parameterName;
 470     // }
 471
 472     RTI13ObjectInstance* getObjectInstance(const std::string& name)
 473     {
 474         RTI::ObjectHandle objectHandle;
 475         objectHandle = getObjectInstanceHandle(name);
 476         ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
 477         if (i == _objectInstanceMap.end()) {
 478             SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: ObjectInstance not found.");
 479             return 0;
 480         }
 481         return i->second;
 482     }
 483     RTI::ObjectHandle getObjectInstanceHandle(const std::string& name)
 484     { return _rtiAmbassador.getObjectInstanceHandle(name.c_str()); }
 485     std::string getObjectInstanceName(const RTI::ObjectHandle& objectHandle)
 486     { return rtiToStdString(_rtiAmbassador.getObjectInstanceName(objectHandle)); }
 487
 488     // RTIHandle getRoutingSpaceHandle(const std::string& routingSpaceName)
 489     // {
 490     //     try {
 491     //         return _rtiAmbassador.getRoutingSpaceHandle(routingSpaceName.c_str());
 492     //     } catch (RTI::NameNotFound& e) {
 493     //     } catch (RTI::FederateNotExecutionMember& e) {
 494     //     } catch (RTI::ConcurrentAccessAttempted& e) {
 495     //     } catch (RTI::RTIinternalError& e) {
 496     //     }
 497     //     return RTIHandle(-1);
 498     // }
 499     // std::string getRoutingSpaceName(const RTIHandle& routingSpaceHandle)
 500     // {
 501     //     std::string routingSpaceName;
 502     //     try {
 503     //         rtiToStdString(routingSpaceName, _rtiAmbassador.wgetRoutingSpaceName(routingSpaceHandle));
 504     //     } catch (RTI::SpaceNotDefined& e) {
 505     //     } catch (RTI::FederateNotExecutionMember& e) {
 506     //     } catch (RTI::ConcurrentAccessAttempted& e) {
 507     //     } catch (RTI::RTIinternalError& e) {
 508     //     }
 509     //     return routingSpaceName;
 510     // }
 511
 512     void enableClassRelevanceAdvisorySwitch()
 513     { _rtiAmbassador.enableClassRelevanceAdvisorySwitch(); }
 514     void disableClassRelevanceAdvisorySwitch()
 515     { _rtiAmbassador.disableClassRelevanceAdvisorySwitch(); }
 516
 517     void enableAttributeRelevanceAdvisorySwitch()
 518     { _rtiAmbassador.enableAttributeRelevanceAdvisorySwitch(); }
 519     void disableAttributeRelevanceAdvisorySwitch()
 520     { _rtiAmbassador.disableAttributeRelevanceAdvisorySwitch(); }
 521
 522     void enableAttributeScopeAdvisorySwitch()
 523     { _rtiAmbassador.enableAttributeScopeAdvisorySwitch(); }
 524     void disableAttributeScopeAdvisorySwitch()
 525     { _rtiAmbassador.disableAttributeScopeAdvisorySwitch(); }
 526
 527     void enableInteractionRelevanceAdvisorySwitch()
 528     { _rtiAmbassador.enableInteractionRelevanceAdvisorySwitch(); }
 529     void disableInteractionRelevanceAdvisorySwitch()
 530     { _rtiAmbassador.disableInteractionRelevanceAdvisorySwitch(); }
 531
 532
 533     bool tick()
 534     { return _rtiAmbassador.tick(); }
 535     bool tick(double minimum, double maximum)
 536     { return _rtiAmbassador.tick(minimum, maximum); }
 537
 538     void addObjectInstanceForCallback(RTIObjectInstance* objectIntance)
 539     { _objectInstancePendingCallbackList.insert(objectIntance); }
 540
 541 private:
 542     /// Generic callback to execute some notification on objects in a way that they are not prone to
 543     /// ConcurrentAccess exceptions.
 544     class QueueCallback : public SGReferenced {
 545     public:
 546         virtual ~QueueCallback() {}
 547         virtual void operator()() = 0;
 548     };
 549
 550     class RemoveObjectCallback : public QueueCallback {
 551     public:
 552         RemoveObjectCallback(SGSharedPtr<RTIObjectInstance> objectInstance, const RTIData& tag) :
 553             _objectInstance(objectInstance),
 554             _tag(tag)
 555         { }
 556         virtual void operator()()
 557         {
 558             _objectInstance->removeInstance(_tag);
 559         }
 560     private:
 561         SGSharedPtr<RTIObjectInstance> _objectInstance;
 562         RTIData _tag;
 563     };
 564
 565     /// Just the interface class doing the callbacks into the parent class
 566     struct FederateAmbassador : public RTI::FederateAmbassador {
 567         FederateAmbassador(RTI13Ambassador& rtiAmbassador) :
 568             _rtiAmbassador(rtiAmbassador)
 569         {
 570         }
 571         virtual ~FederateAmbassador()
 572         throw (RTI::FederateInternalError)
 573         {
 574         }
 575
 576         /// RTI federate ambassador callback functions.
 577         virtual void synchronizationPointRegistrationSucceeded(const char* label)
 578             throw (RTI::FederateInternalError)
 579         {
 580         }
 581
 582         virtual void synchronizationPointRegistrationFailed(const char* label)
 583             throw (RTI::FederateInternalError)
 584         {
 585         }
 586
 587         virtual void announceSynchronizationPoint(const char* label, const char* tag)
 588             throw (RTI::FederateInternalError)
 589         {
 590             _rtiAmbassador._pendingSyncLabels.insert(toStdString(label));
 591         }
 592
 593         virtual void federationSynchronized(const char* label)
 594             throw (RTI::FederateInternalError)
 595         {
 596             std::string s = toStdString(label);
 597             _rtiAmbassador._pendingSyncLabels.erase(s);
 598             _rtiAmbassador._syncronizedSyncLabels.insert(s);
 599         }
 600
 601         virtual void initiateFederateSave(const char* label)
 602             throw (RTI::UnableToPerformSave,
 603                    RTI::FederateInternalError)
 604         {
 605         }
 606
 607         virtual void federationSaved()
 608             throw (RTI::FederateInternalError)
 609         {
 610         }
 611
 612         virtual void federationNotSaved()
 613             throw (RTI::FederateInternalError)
 614         {
 615         }
 616
 617         virtual void requestFederationRestoreSucceeded(const char* label)
 618             throw (RTI::FederateInternalError)
 619         {
 620         }
 621
 622         virtual void requestFederationRestoreFailed(const char* label, const char* reason)
 623             throw (RTI::FederateInternalError)
 624         {
 625         }
 626
 627         virtual void federationRestoreBegun()
 628             throw (RTI::FederateInternalError)
 629         {
 630         }
 631
 632         virtual void initiateFederateRestore(const char* label, RTI::FederateHandle federateHandle)
 633             throw (RTI::SpecifiedSaveLabelDoesNotExist,
 634                    RTI::CouldNotRestore,
 635                    RTI::FederateInternalError)
 636         {
 637         }
 638
 639         virtual void federationRestored()
 640             throw (RTI::FederateInternalError)
 641         {
 642         }
 643
 644         virtual void federationNotRestored()
 645             throw (RTI::FederateInternalError)
 646         {
 647         }
 648
 649         // Declaration Management
 650         virtual void startRegistrationForObjectClass(RTI::ObjectClassHandle objectClassHandle)
 651             throw (RTI::ObjectClassNotPublished,
 652                    RTI::FederateInternalError)
 653         {
 654             ObjectClassMap::iterator i = _rtiAmbassador._objectClassMap.find(objectClassHandle);
 655             if (i == _rtiAmbassador._objectClassMap.end())
 656                 return;
 657             if (!i->second.valid())
 658                 return;
 659             i->second->startRegistration();
 660         }
 661
 662         virtual void stopRegistrationForObjectClass(RTI::ObjectClassHandle objectClassHandle)
 663             throw (RTI::ObjectClassNotPublished,
 664                    RTI::FederateInternalError)
 665         {
 666             ObjectClassMap::iterator i = _rtiAmbassador._objectClassMap.find(objectClassHandle);
 667             if (i == _rtiAmbassador._objectClassMap.end())
 668                 return;
 669             if (!i->second.valid())
 670                 return;
 671             i->second->stopRegistration();
 672         }
 673
 674         virtual void turnInteractionsOn(RTI::InteractionClassHandle interactionClassHandle)
 675             throw (RTI::InteractionClassNotPublished,
 676                    RTI::FederateInternalError)
 677         {
 678         }
 679
 680         virtual void turnInteractionsOff(RTI::InteractionClassHandle interactionClassHandle)
 681             throw (RTI::InteractionClassNotPublished,
 682                    RTI::FederateInternalError)
 683         {
 684         }
 685
 686
 687         // Object Management
 688         virtual void discoverObjectInstance(RTI::ObjectHandle objectHandle, RTI::ObjectClassHandle objectClassHandle, const char* tag)
 689             throw (RTI::CouldNotDiscover,
 690                    RTI::ObjectClassNotKnown,
 691                    RTI::FederateInternalError)
 692         {
 693             ObjectClassMap::iterator i = _rtiAmbassador._objectClassMap.find(objectClassHandle);
 694             if (i == _rtiAmbassador._objectClassMap.end())
 695                 throw RTI::ObjectClassNotKnown("Federate: discoverObjectInstance()!");
 696             if (!i->second.valid())
 697                 return;
 698             SGSharedPtr<RTI13ObjectInstance> objectInstance = new RTI13ObjectInstance(objectHandle, 0, i->second, &_rtiAmbassador, false);
 699             _rtiAmbassador._objectInstanceMap[objectHandle] = objectInstance;
 700             _rtiAmbassador._objectInstancePendingCallbackList.insert(objectInstance);
 701             i->second->discoverInstance(objectInstance.get(), tagToData(tag));
 702         }
 703
 704         virtual void reflectAttributeValues(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleValuePairSet& attributeValuePairSet,
 705                                             const RTI::FedTime& fedTime, const char* tag, RTI::EventRetractionHandle eventRetractionHandle)
 706             throw (RTI::ObjectNotKnown,
 707                    RTI::AttributeNotKnown,
 708                    RTI::FederateOwnsAttributes,
 709                    RTI::InvalidFederationTime,
 710                    RTI::FederateInternalError)
 711         {
 712             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 713             if (i == _rtiAmbassador._objectInstanceMap.end())
 714                 throw RTI::ObjectNotKnown("Reflect attributes for unknown object!");
 715             if (!i->second.valid())
 716                 return;
 717             i->second->reflectAttributeValues(attributeValuePairSet, toTimeStamp(fedTime), tagToData(tag));
 718         }
 719
 720         virtual void reflectAttributeValues(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleValuePairSet& attributeValuePairSet,
 721                                             const char* tag)
 722             throw (RTI::ObjectNotKnown,
 723                    RTI::AttributeNotKnown,
 724                    RTI::FederateOwnsAttributes,
 725                    RTI::FederateInternalError)
 726         {
 727             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 728             if (i == _rtiAmbassador._objectInstanceMap.end())
 729                 throw RTI::ObjectNotKnown("Reflect attributes for unknown object!");
 730             if (!i->second.valid())
 731                 return;
 732             i->second->reflectAttributeValues(attributeValuePairSet, tagToData(tag));
 733         }
 734
 735         virtual void receiveInteraction(RTI::InteractionClassHandle interactionClassHandle, const RTI::ParameterHandleValuePairSet& parameters,
 736                                         const RTI::FedTime& fedTime, const char* tag, RTI::EventRetractionHandle eventRetractionHandle)
 737             throw (RTI::InteractionClassNotKnown,
 738                    RTI::InteractionParameterNotKnown,
 739                    RTI::InvalidFederationTime,
 740                    RTI::FederateInternalError)
 741         {
 742         }
 743
 744         virtual void receiveInteraction(RTI::InteractionClassHandle interactionClassHandle,
 745                                         const RTI::ParameterHandleValuePairSet& parameters, const char* tag)
 746             throw (RTI::InteractionClassNotKnown,
 747                    RTI::InteractionParameterNotKnown,
 748                    RTI::FederateInternalError)
 749         {
 750         }
 751
 752         virtual void removeObjectInstance(RTI::ObjectHandle objectHandle, const RTI::FedTime& fedTime,
 753                                           const char* tag, RTI::EventRetractionHandle eventRetractionHandle)
 754             throw (RTI::ObjectNotKnown,
 755                    RTI::InvalidFederationTime,
 756                    RTI::FederateInternalError)
 757         {
 758             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 759             if (i == _rtiAmbassador._objectInstanceMap.end())
 760                 throw RTI::ObjectNotKnown("Federate: removeObjectInstance()!");
 761             if (i->second.valid())
 762                 _rtiAmbassador._queueCallbackList.push_back(new RemoveObjectCallback(i->second, tagToData(tag)));
 763             _rtiAmbassador._objectInstancePendingCallbackList.erase(i->second);
 764             _rtiAmbassador._objectInstanceMap.erase(i);
 765         }
 766
 767         virtual void removeObjectInstance(RTI::ObjectHandle objectHandle, const char* tag)
 768             throw (RTI::ObjectNotKnown,
 769                    RTI::FederateInternalError)
 770         {
 771             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 772             if (i == _rtiAmbassador._objectInstanceMap.end())
 773                 throw RTI::ObjectNotKnown("Federate: removeObjectInstance()!");
 774             if (i->second.valid())
 775                 _rtiAmbassador._queueCallbackList.push_back(new RemoveObjectCallback(i->second, tagToData(tag)));
 776             _rtiAmbassador._objectInstancePendingCallbackList.erase(i->second);
 777             _rtiAmbassador._objectInstanceMap.erase(i);
 778         }
 779
 780         virtual void attributesInScope(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 781             throw (RTI::ObjectNotKnown,
 782                    RTI::AttributeNotKnown,
 783                    RTI::FederateInternalError)
 784         {
 785             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 786             if (i == _rtiAmbassador._objectInstanceMap.end())
 787                 throw RTI::ObjectNotKnown("Attributes in scope for unknown object!");
 788             if (!i->second.valid())
 789                 return;
 790             i->second->attributesInScope(attributes);
 791         }
 792
 793         virtual void attributesOutOfScope(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 794             throw (RTI::ObjectNotKnown,
 795                    RTI::AttributeNotKnown,
 796                    RTI::FederateInternalError)
 797         {
 798             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 799             if (i == _rtiAmbassador._objectInstanceMap.end())
 800                 throw RTI::ObjectNotKnown("Attributes in scope for unknown object!");
 801             if (!i->second.valid())
 802                 return;
 803             i->second->attributesOutOfScope(attributes);
 804         }
 805
 806         virtual void provideAttributeValueUpdate(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 807             throw (RTI::ObjectNotKnown,
 808                    RTI::AttributeNotKnown,
 809                    RTI::AttributeNotOwned,
 810                    RTI::FederateInternalError)
 811         {
 812             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 813             if (i == _rtiAmbassador._objectInstanceMap.end())
 814                 throw RTI::ObjectNotKnown("Reflect attributes for unknown object!");
 815             if (!i->second.valid())
 816                 return;
 817             i->second->provideAttributeValueUpdate(attributes);
 818         }
 819
 820         virtual void turnUpdatesOnForObjectInstance(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 821             throw (RTI::ObjectNotKnown,
 822                    RTI::AttributeNotOwned,
 823                    RTI::FederateInternalError)
 824         {
 825             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 826             if (i == _rtiAmbassador._objectInstanceMap.end())
 827                 throw RTI::ObjectNotKnown("Turn on attributes for unknown object!");
 828             if (!i->second.valid())
 829                 return;
 830             i->second->turnUpdatesOnForObjectInstance(attributes);
 831         }
 832
 833         virtual void turnUpdatesOffForObjectInstance(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 834             throw (RTI::ObjectNotKnown,
 835                    RTI::AttributeNotOwned,
 836                    RTI::FederateInternalError)
 837         {
 838             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 839             if (i == _rtiAmbassador._objectInstanceMap.end())
 840                 throw RTI::ObjectNotKnown("Turn off attributes for unknown object!");
 841             if (!i->second.valid())
 842                 return;
 843             i->second->turnUpdatesOffForObjectInstance(attributes);
 844         }
 845
 846         // Ownership Management
 847         virtual void requestAttributeOwnershipAssumption(RTI::ObjectHandle objectHandle,
 848                                                          const RTI::AttributeHandleSet& attributes, const char* tag)
 849             throw (RTI::ObjectNotKnown,
 850                    RTI::AttributeNotKnown,
 851                    RTI::AttributeAlreadyOwned,
 852                    RTI::AttributeNotPublished,
 853                    RTI::FederateInternalError)
 854         {
 855             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 856             if (i == _rtiAmbassador._objectInstanceMap.end())
 857                 throw RTI::ObjectNotKnown("requestAttributeOwnershipAssumption for unknown object!");
 858             if (!i->second.valid())
 859                 return;
 860             i->second->requestAttributeOwnershipAssumption(attributes, tagToData(tag));
 861         }
 862
 863         virtual void attributeOwnershipDivestitureNotification(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 864             throw (RTI::ObjectNotKnown,
 865                    RTI::AttributeNotKnown,
 866                    RTI::AttributeNotOwned,
 867                    RTI::AttributeDivestitureWasNotRequested,
 868                    RTI::FederateInternalError)
 869         {
 870             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 871             if (i == _rtiAmbassador._objectInstanceMap.end())
 872                 throw RTI::ObjectNotKnown("attributeOwnershipDivestitureNotification for unknown object!");
 873             if (!i->second.valid())
 874                 return;
 875             i->second->attributeOwnershipDivestitureNotification(attributes);
 876         }
 877
 878         virtual void attributeOwnershipAcquisitionNotification(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 879             throw (RTI::ObjectNotKnown,
 880                    RTI::AttributeNotKnown,
 881                    RTI::AttributeAcquisitionWasNotRequested,
 882                    RTI::AttributeAlreadyOwned,
 883                    RTI::AttributeNotPublished,
 884                    RTI::FederateInternalError)
 885         {
 886             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 887             if (i == _rtiAmbassador._objectInstanceMap.end())
 888                 throw RTI::ObjectNotKnown("attributeOwnershipAcquisitionNotification for unknown object!");
 889             if (!i->second.valid())
 890                 return;
 891             i->second->attributeOwnershipAcquisitionNotification(attributes);
 892         }
 893
 894         virtual void attributeOwnershipUnavailable(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 895             throw (RTI::ObjectNotKnown,
 896                    RTI::AttributeNotKnown,
 897                    RTI::AttributeAlreadyOwned,
 898                    RTI::AttributeAcquisitionWasNotRequested,
 899                    RTI::FederateInternalError)
 900         {
 901             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 902             if (i == _rtiAmbassador._objectInstanceMap.end())
 903                 throw RTI::ObjectNotKnown("attributeOwnershipUnavailable for unknown object!");
 904             if (!i->second.valid())
 905                 return;
 906             i->second->attributeOwnershipUnavailable(attributes);
 907         }
 908
 909         virtual void requestAttributeOwnershipRelease(RTI::ObjectHandle objectHandle,
 910                                                       const RTI::AttributeHandleSet& attributes, const char* tag)
 911             throw (RTI::ObjectNotKnown,
 912                    RTI::AttributeNotKnown,
 913                    RTI::AttributeNotOwned,
 914                    RTI::FederateInternalError)
 915         {
 916             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 917             if (i == _rtiAmbassador._objectInstanceMap.end())
 918                 throw RTI::ObjectNotKnown("requestAttributeOwnershipRelease for unknown object!");
 919             if (!i->second.valid())
 920                 return;
 921             i->second->requestAttributeOwnershipRelease(attributes, tagToData(tag));
 922         }
 923
 924         virtual void confirmAttributeOwnershipAcquisitionCancellation(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
 925             throw (RTI::ObjectNotKnown,
 926                    RTI::AttributeNotKnown,
 927                    RTI::AttributeAlreadyOwned,
 928                    RTI::AttributeAcquisitionWasNotCanceled,
 929                    RTI::FederateInternalError)
 930         {
 931             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 932             if (i == _rtiAmbassador._objectInstanceMap.end())
 933                 throw RTI::ObjectNotKnown("confirmAttributeOwnershipAcquisitionCancellation for unknown object!");
 934             if (!i->second.valid())
 935                 return;
 936             i->second->confirmAttributeOwnershipAcquisitionCancellation(attributes);
 937         }
 938
 939         virtual void informAttributeOwnership(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle,
 940                                               RTI::FederateHandle federateHandle)
 941             throw (RTI::ObjectNotKnown,
 942                    RTI::AttributeNotKnown,
 943                    RTI::FederateInternalError)
 944         {
 945             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 946             if (i == _rtiAmbassador._objectInstanceMap.end())
 947                 throw RTI::ObjectNotKnown("informAttributeOwnership for unknown object!");
 948             if (!i->second.valid())
 949                 return;
 950             i->second->informAttributeOwnership(attributeHandle, federateHandle);
 951         }
 952
 953         virtual void attributeIsNotOwned(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle)
 954             throw (RTI::ObjectNotKnown,
 955                    RTI::AttributeNotKnown,
 956                    RTI::FederateInternalError)
 957         {
 958             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 959             if (i == _rtiAmbassador._objectInstanceMap.end())
 960                 throw RTI::ObjectNotKnown("attributeIsNotOwned for unknown object!");
 961             if (!i->second.valid())
 962                 return;
 963             i->second->attributeIsNotOwned(attributeHandle);
 964         }
 965
 966         virtual void attributeOwnedByRTI(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle)
 967             throw (RTI::ObjectNotKnown,
 968                    RTI::AttributeNotKnown,
 969                    RTI::FederateInternalError)
 970         {
 971             ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
 972             if (i == _rtiAmbassador._objectInstanceMap.end())
 973                 throw RTI::ObjectNotKnown("attributeOwnedByRTI for unknown object!");
 974             if (!i->second.valid())
 975                 return;
 976             i->second->attributeOwnedByRTI(attributeHandle);
 977         }
 978
 979         // Time Management
 980         virtual void timeRegulationEnabled(const RTI::FedTime& fedTime)
 981             throw (RTI::InvalidFederationTime,
 982                    RTI::EnableTimeRegulationWasNotPending,
 983                    RTI::FederateInternalError)
 984         {
 985             _rtiAmbassador._timeRegulationEnabled = true;
 986             _rtiAmbassador._federateTime = toTimeStamp(fedTime);
 987             SG_LOG(SG_NETWORK, SG_INFO, "RTI: timeRegulationEnabled: " << _rtiAmbassador._federateTime);
 988         }
 989
 990         virtual void timeConstrainedEnabled(const RTI::FedTime& fedTime)
 991             throw (RTI::InvalidFederationTime,
 992                    RTI::EnableTimeConstrainedWasNotPending,
 993                    RTI::FederateInternalError)
 994         {
 995             _rtiAmbassador._timeConstrainedEnabled = true;
 996             _rtiAmbassador._federateTime = toTimeStamp(fedTime);
 997             SG_LOG(SG_NETWORK, SG_INFO, "RTI: timeConstrainedEnabled: " << _rtiAmbassador._federateTime);
 998         }
 999
1000         virtual void timeAdvanceGrant(const RTI::FedTime& fedTime)
1001             throw (RTI::InvalidFederationTime,
1002                    RTI::TimeAdvanceWasNotInProgress,
1003                    RTI::FederateInternalError)
1004         {
1005             _rtiAmbassador._federateTime = toTimeStamp(fedTime);
1006             _rtiAmbassador._timeAdvancePending = false;
1007             SG_LOG(SG_NETWORK, SG_INFO, "RTI: timeAdvanceGrant: " << _rtiAmbassador._federateTime);
1008         }
1009
1010         virtual void requestRetraction(RTI::EventRetractionHandle eventRetractionHandle)
1011             throw (RTI::EventNotKnown,
1012                    RTI::FederateInternalError)
1013         {
1014             // No retraction concept yet
1015         }
1016
1017     private:
1018         const RTIData& tagToData(const char* tag)
1019         {
1020             if (tag)
1021                 _cachedTag.setData(tag, std::strlen(tag) + 1);
1022             else
1023                 _cachedTag.setData("", 1);
1024             return _cachedTag;
1025         }
1026         RTIData _cachedTag;
1027
1028         RTI13Ambassador& _rtiAmbassador;
1029     };
1030
1031     static SGTimeStamp toTimeStamp(const RTI::FedTime& fedTime)
1032     {
1033         RTIfedTime referenceTime(fedTime);
1034         return SGTimeStamp::fromSec(referenceTime.getTime() + 0.5e-9);
1035     }
1036
1037     static RTIfedTime toFedTime(const SGTimeStamp& timeStamp)
1038     {
1039         RTIfedTime referenceTime;
1040         referenceTime.setZero();
1041         referenceTime += timeStamp.toSecs();
1042         return referenceTime;
1043     }
1044
1045     static std::string rtiToStdString(char* n)
1046     {
1047         if (!n)
1048             return std::string();
1049         std::string s;
1050         s.assign(n);
1051         delete[] n;
1052         return s;
1053     }
1054
1055     static std::string toStdString(const char* n)
1056     {
1057         if (!n)
1058             return std::string();
1059         return std::string(n);
1060     }
1061
1062     // The connection class
1063     RTI::RTIambassador _rtiAmbassador;
1064
1065     // The class with all the callbacks.
1066     FederateAmbassador _federateAmbassador;
1067
1068     // All the sync labels we got an announcement for
1069     std::set<std::string> _pendingSyncLabels;
1070     std::set<std::string> _syncronizedSyncLabels;
1071
1072     // All that calls back into user code is just queued.
1073     // That is to make sure we do not call recursively into the RTI
1074     typedef std::list<SGSharedPtr<QueueCallback> > QueueCallbackList;
1075     QueueCallbackList _queueCallbackList;
1076     // All object instances that need to be called due to some event are noted here
1077     // That is to make sure we do not call recursively into the RTI
1078     typedef std::set<SGSharedPtr<RTIObjectInstance> > ObjectInstanceSet;
1079     ObjectInstanceSet _objectInstancePendingCallbackList;
1080
1081     // Top level information for dispatching federate object attribute updates
1082     typedef std::map<RTI::ObjectHandle, SGSharedPtr<RTI13ObjectInstance> > ObjectInstanceMap;
1083     // Map of all available objects
1084     ObjectInstanceMap _objectInstanceMap;
1085
1086     // Top level information for dispatching creation of federate objects
1087     typedef std::map<RTI::ObjectClassHandle, SGSharedPtr<RTI13ObjectClass> > ObjectClassMap;
1088     ObjectClassMap _objectClassMap;
1089
1090     bool _timeRegulationEnabled;
1091     bool _timeConstrainedEnabled;
1092     bool _timeAdvancePending;
1093     SGTimeStamp _federateTime;
1094 };
1095
1096 } // namespace simgear
1097
1098 #endif